projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
New SIMD code for -a 1 -m 1460
[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 131
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 6211,
264 6221,
265 6231,
266 6241,
267 8800,
268 12900,
269 12200,
270 9700,
271 9710,
272 9800,
273 9810,
274 9400,
275 9500,
276 9600,
277 10400,
278 10410,
279 10500,
280 10600,
281 10700,
282 9000,
283 5200,
284 6800,
285 6600,
286 8200,
287 11300,
288 12700
289 };
290
291 /**
292 * types
293 */
294
295 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
296
297 /**
298 * globals
299 */
300
301 static unsigned int full01 = 0x01010101;
302 static unsigned int full80 = 0x80808080;
303
304 int SUPPRESS_OUTPUT = 0;
305
306 hc_thread_mutex_t mux_adl;
307 hc_thread_mutex_t mux_counter;
308 hc_thread_mutex_t mux_dispatcher;
309 hc_thread_mutex_t mux_display;
310
311 hc_global_data_t data;
312
313 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
314
315 const char *USAGE_MINI[] =
316 {
317 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
318 "",
319 "Try --help for more help.",
320 NULL
321 };
322
323 const char *USAGE_BIG[] =
324 {
325 "%s, advanced password recovery",
326 "",
327 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
328 "",
329 "=======",
330 "Options",
331 "=======",
332 "",
333 "* General:",
334 "",
335 " -m, --hash-type=NUM Hash-type, see references below",
336 " -a, --attack-mode=NUM Attack-mode, see references below",
337 " -V, --version Print version",
338 " -h, --help Print help",
339 " --quiet Suppress output",
340 "",
341 "* Misc:",
342 "",
343 " --hex-charset Assume charset is given in hex",
344 " --hex-salt Assume salt is given in hex",
345 " --hex-wordlist Assume words in wordlist is given in hex",
346 " --force Ignore warnings",
347 " --status Enable automatic update of the status-screen",
348 " --status-timer=NUM Seconds between status-screen update",
349 " --status-automat Display the status view in a machine readable format",
350 " --loopback Add new plains to induct directory",
351 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
352 "",
353 "* Markov:",
354 "",
355 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
356 " --markov-disable Disables markov-chains, emulates classic brute-force",
357 " --markov-classic Enables classic markov-chains, no per-position enhancement",
358 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
359 "",
360 "* Session:",
361 "",
362 " --runtime=NUM Abort session after NUM seconds of runtime",
363 " --session=STR Define specific session name",
364 " --restore Restore session from --session",
365 " --restore-disable Do not write restore file",
366 "",
367 "* Files:",
368 "",
369 " -o, --outfile=FILE Define outfile for recovered hash",
370 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
371 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
372 " --outfile-check-timer=NUM Seconds between outfile checks",
373 " -p, --separator=CHAR Separator char for hashlists and outfile",
374 " --show Show cracked passwords only",
375 " --left Show un-cracked passwords only",
376 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
377 " --remove Enable remove of hash once it is cracked",
378 " --remove-timer=NUM Update input hash file each NUM seconds",
379 " --potfile-disable Do not write potfile",
380 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
381 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
382 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
383 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
384 " --logfile-disable Disable the logfile",
385 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
386 "",
387 "* Resources:",
388 "",
389 " -b, --benchmark Run benchmark",
390 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
391 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
392 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
393 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
394 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
395 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
396 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
397 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
398 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
399 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
400 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
401 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
402 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
403 #ifdef HAVE_HWMON
404 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
405 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
406 #ifdef HAVE_ADL
407 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
408 #endif
409 #endif
410 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
411 "",
412 "* Distributed:",
413 "",
414 " -s, --skip=NUM Skip number of words",
415 " -l, --limit=NUM Limit number of words",
416 " --keyspace Show keyspace base:mod values and quit",
417 "",
418 "* Rules:",
419 "",
420 " -j, --rule-left=RULE Single rule applied to each word from left dict",
421 " -k, --rule-right=RULE Single rule applied to each word from right dict",
422 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
423 " -g, --generate-rules=NUM Generate NUM random rules",
424 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
425 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
426 " --generate-rules-seed=NUM Force RNG seed to NUM",
427 "",
428 "* Custom charsets:",
429 "",
430 " -1, --custom-charset1=CS User-defined charsets",
431 " -2, --custom-charset2=CS Example:",
432 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
433 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
434 "",
435 "* Increment:",
436 "",
437 " -i, --increment Enable increment mode",
438 " --increment-min=NUM Start incrementing at NUM",
439 " --increment-max=NUM Stop incrementing at NUM",
440 "",
441 "==========",
442 "References",
443 "==========",
444 "",
445 "* Workload Profile:",
446 "",
447 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
448 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
449 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
450 "",
451 "* OpenCL device-types:",
452 "",
453 " 1 = CPU devices",
454 " 2 = GPU devices",
455 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
456 "",
457 "* Outfile Formats:",
458 "",
459 " 1 = hash[:salt]",
460 " 2 = plain",
461 " 3 = hash[:salt]:plain",
462 " 4 = hex_plain",
463 " 5 = hash[:salt]:hex_plain",
464 " 6 = plain:hex_plain",
465 " 7 = hash[:salt]:plain:hex_plain",
466 " 8 = crackpos",
467 " 9 = hash[:salt]:crackpos",
468 " 10 = plain:crackpos",
469 " 11 = hash[:salt]:plain:crackpos",
470 " 12 = hex_plain:crackpos",
471 " 13 = hash[:salt]:hex_plain:crackpos",
472 " 14 = plain:hex_plain:crackpos",
473 " 15 = hash[:salt]:plain:hex_plain:crackpos",
474 "",
475 "* Debug mode output formats (for hybrid mode only, by using rules):",
476 "",
477 " 1 = save finding rule",
478 " 2 = save original word",
479 " 3 = save original word and finding rule",
480 " 4 = save original word, finding rule and modified plain",
481 "",
482 "* Built-in charsets:",
483 "",
484 " ?l = abcdefghijklmnopqrstuvwxyz",
485 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
486 " ?d = 0123456789",
487 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
488 " ?a = ?l?u?d?s",
489 " ?b = 0x00 - 0xff",
490 "",
491 "* Attack modes:",
492 "",
493 " 0 = Straight",
494 " 1 = Combination",
495 " 3 = Brute-force",
496 " 6 = Hybrid dict + mask",
497 " 7 = Hybrid mask + dict",
498 "",
499 "* Hash types:",
500 "",
501 "[[ Roll-your-own: Raw Hashes ]]",
502 "",
503 " 900 = MD4",
504 " 0 = MD5",
505 " 5100 = Half MD5",
506 " 100 = SHA1",
507 " 10800 = SHA-384",
508 " 1400 = SHA-256",
509 " 1700 = SHA-512",
510 " 5000 = SHA-3(Keccak)",
511 " 10100 = SipHash",
512 " 6000 = RipeMD160",
513 " 6100 = Whirlpool",
514 " 6900 = GOST R 34.11-94",
515 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
516 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
517 "",
518 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
519 "",
520 " 10 = md5($pass.$salt)",
521 " 20 = md5($salt.$pass)",
522 " 30 = md5(unicode($pass).$salt)",
523 " 40 = md5($salt.unicode($pass))",
524 " 3800 = md5($salt.$pass.$salt)",
525 " 3710 = md5($salt.md5($pass))",
526 " 2600 = md5(md5($pass)",
527 " 4300 = md5(strtoupper(md5($pass)))",
528 " 4400 = md5(sha1($pass))",
529 " 110 = sha1($pass.$salt)",
530 " 120 = sha1($salt.$pass)",
531 " 130 = sha1(unicode($pass).$salt)",
532 " 140 = sha1($salt.unicode($pass))",
533 " 4500 = sha1(sha1($pass)",
534 " 4700 = sha1(md5($pass))",
535 " 4900 = sha1($salt.$pass.$salt)",
536 " 1410 = sha256($pass.$salt)",
537 " 1420 = sha256($salt.$pass)",
538 " 1430 = sha256(unicode($pass).$salt)",
539 " 1440 = sha256($salt.unicode($pass))",
540 " 1710 = sha512($pass.$salt)",
541 " 1720 = sha512($salt.$pass)",
542 " 1730 = sha512(unicode($pass).$salt)",
543 " 1740 = sha512($salt.unicode($pass))",
544 "",
545 "[[ Roll-your-own: Authenticated Hashes ]]",
546 "",
547 " 50 = HMAC-MD5 (key = $pass)",
548 " 60 = HMAC-MD5 (key = $salt)",
549 " 150 = HMAC-SHA1 (key = $pass)",
550 " 160 = HMAC-SHA1 (key = $salt)",
551 " 1450 = HMAC-SHA256 (key = $pass)",
552 " 1460 = HMAC-SHA256 (key = $salt)",
553 " 1750 = HMAC-SHA512 (key = $pass)",
554 " 1760 = HMAC-SHA512 (key = $salt)",
555 "",
556 "[[ Generic KDF ]]",
557 "",
558 " 400 = phpass",
559 " 8900 = scrypt",
560 " 11900 = PBKDF2-HMAC-MD5",
561 " 12000 = PBKDF2-HMAC-SHA1",
562 " 10900 = PBKDF2-HMAC-SHA256",
563 " 12100 = PBKDF2-HMAC-SHA512",
564 "",
565 "[[ Network protocols, Challenge-Response ]]",
566 "",
567 " 23 = Skype",
568 " 2500 = WPA/WPA2",
569 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
570 " 5300 = IKE-PSK MD5",
571 " 5400 = IKE-PSK SHA1",
572 " 5500 = NetNTLMv1",
573 " 5500 = NetNTLMv1 + ESS",
574 " 5600 = NetNTLMv2",
575 " 7300 = IPMI2 RAKP HMAC-SHA1",
576 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
577 " 8300 = DNSSEC (NSEC3)",
578 " 10200 = Cram MD5",
579 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
580 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
581 " 11400 = SIP digest authentication (MD5)",
582 " 13100 = Kerberos 5 TGS-REP etype 23",
583 "",
584 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
585 "",
586 " 121 = SMF (Simple Machines Forum)",
587 " 400 = phpBB3",
588 " 2611 = vBulletin < v3.8.5",
589 " 2711 = vBulletin > v3.8.5",
590 " 2811 = MyBB",
591 " 2811 = IPB (Invison Power Board)",
592 " 8400 = WBB3 (Woltlab Burning Board)",
593 " 11 = Joomla < 2.5.18",
594 " 400 = Joomla > 2.5.18",
595 " 400 = Wordpress",
596 " 2612 = PHPS",
597 " 7900 = Drupal7",
598 " 21 = osCommerce",
599 " 21 = xt:Commerce",
600 " 11000 = PrestaShop",
601 " 124 = Django (SHA-1)",
602 " 10000 = Django (PBKDF2-SHA256)",
603 " 3711 = Mediawiki B type",
604 " 7600 = Redmine",
605 "",
606 "[[ Database Server ]]",
607 "",
608 " 12 = PostgreSQL",
609 " 131 = MSSQL(2000)",
610 " 132 = MSSQL(2005)",
611 " 1731 = MSSQL(2012)",
612 " 1731 = MSSQL(2014)",
613 " 200 = MySQL323",
614 " 300 = MySQL4.1/MySQL5",
615 " 3100 = Oracle H: Type (Oracle 7+)",
616 " 112 = Oracle S: Type (Oracle 11+)",
617 " 12300 = Oracle T: Type (Oracle 12+)",
618 " 8000 = Sybase ASE",
619 "",
620 "[[ HTTP, SMTP, LDAP Server ]]",
621 "",
622 " 141 = EPiServer 6.x < v4",
623 " 1441 = EPiServer 6.x > v4",
624 " 1600 = Apache $apr1$",
625 " 12600 = ColdFusion 10+",
626 " 1421 = hMailServer",
627 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
628 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
629 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
630 "",
631 "[[ Checksums ]]",
632 "",
633 " 11500 = CRC32",
634 "",
635 "[[ Operating-Systems ]]",
636 "",
637 " 3000 = LM",
638 " 1000 = NTLM",
639 " 1100 = Domain Cached Credentials (DCC), MS Cache",
640 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
641 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
642 " 1500 = descrypt, DES(Unix), Traditional DES",
643 " 12400 = BSDiCrypt, Extended DES",
644 " 500 = md5crypt $1$, MD5(Unix)",
645 " 3200 = bcrypt $2*$, Blowfish(Unix)",
646 " 7400 = sha256crypt $5$, SHA256(Unix)",
647 " 1800 = sha512crypt $6$, SHA512(Unix)",
648 " 122 = OSX v10.4",
649 " 122 = OSX v10.5",
650 " 122 = OSX v10.6",
651 " 1722 = OSX v10.7",
652 " 7100 = OSX v10.8",
653 " 7100 = OSX v10.9",
654 " 7100 = OSX v10.10",
655 " 6300 = AIX {smd5}",
656 " 6700 = AIX {ssha1}",
657 " 6400 = AIX {ssha256}",
658 " 6500 = AIX {ssha512}",
659 " 2400 = Cisco-PIX",
660 " 2410 = Cisco-ASA",
661 " 500 = Cisco-IOS $1$",
662 " 5700 = Cisco-IOS $4$",
663 " 9200 = Cisco-IOS $8$",
664 " 9300 = Cisco-IOS $9$",
665 " 22 = Juniper Netscreen/SSG (ScreenOS)",
666 " 501 = Juniper IVE",
667 " 5800 = Android PIN",
668 " 8100 = Citrix Netscaler",
669 " 8500 = RACF",
670 " 7200 = GRUB 2",
671 " 9900 = Radmin2",
672 "",
673 "[[ Enterprise Application Software (EAS) ]]",
674 "",
675 " 7700 = SAP CODVN B (BCODE)",
676 " 7800 = SAP CODVN F/G (PASSCODE)",
677 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
678 " 8600 = Lotus Notes/Domino 5",
679 " 8700 = Lotus Notes/Domino 6",
680 " 9100 = Lotus Notes/Domino 8",
681 " 133 = PeopleSoft",
682 "",
683 "[[ Archives ]]",
684 "",
685 " 11600 = 7-Zip",
686 " 12500 = RAR3-hp",
687 " 13000 = RAR5",
688 "",
689 "[[ Full-Disk encryptions (FDE) ]]",
690 "",
691 " 62XY = TrueCrypt 5.0+",
692 " X = 1 = PBKDF2-HMAC-RipeMD160",
693 " X = 2 = PBKDF2-HMAC-SHA512",
694 " X = 3 = PBKDF2-HMAC-Whirlpool",
695 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
696 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
697 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
698 " Y = 3 = XTS 1536 bit (Ciphers: All)",
699 " 8800 = Android FDE < v4.3",
700 " 12900 = Android FDE (Samsung DEK)",
701 " 12200 = eCryptfs",
702 "",
703 "[[ Documents ]]",
704 "",
705 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
706 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
707 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
708 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
709 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
710 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
711 " 9400 = MS Office 2007",
712 " 9500 = MS Office 2010",
713 " 9600 = MS Office 2013",
714 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
715 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
716 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
717 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
718 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
719 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
720 "",
721 "[[ Password Managers ]]",
722 "",
723 " 9000 = Password Safe v2",
724 " 5200 = Password Safe v3",
725 " 6800 = Lastpass",
726 " 6600 = 1Password, agilekeychain",
727 " 8200 = 1Password, cloudkeychain",
728 " 11300 = Bitcoin/Litecoin wallet.dat",
729 " 12700 = Blockchain, My Wallet",
730 "",
731 NULL
732 };
733
734 /**
735 * oclHashcat specific functions
736 */
737
738 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
739 {
740 int exec_pos = (int) device_param->exec_pos - last_num_entries;
741
742 if (exec_pos < 0) exec_pos += EXEC_CACHE;
743
744 double exec_ms_sum = 0;
745
746 int exec_ms_cnt = 0;
747
748 for (int i = 0; i < last_num_entries; i++)
749 {
750 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
751
752 if (exec_ms)
753 {
754 exec_ms_sum += exec_ms;
755
756 exec_ms_cnt++;
757 }
758 }
759
760 if (exec_ms_cnt == 0) return 0;
761
762 return exec_ms_sum / exec_ms_cnt;
763 }
764
765 void status_display_automat ()
766 {
767 FILE *out = stdout;
768
769 fprintf (out, "STATUS\t%u\t", data.devices_status);
770
771 /**
772 * speed new
773 */
774
775 fprintf (out, "SPEED\t");
776
777 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
778 {
779 hc_device_param_t *device_param = &data.devices_param[device_id];
780
781 if (device_param->skipped) continue;
782
783 u64 speed_cnt = 0;
784 float speed_ms = 0;
785
786 for (int i = 0; i < SPEED_CACHE; i++)
787 {
788 float rec_ms;
789
790 hc_timer_get (device_param->speed_rec[i], rec_ms);
791
792 if (rec_ms > SPEED_MAXAGE) continue;
793
794 speed_cnt += device_param->speed_cnt[i];
795 speed_ms += device_param->speed_ms[i];
796 }
797
798 speed_cnt /= SPEED_CACHE;
799 speed_ms /= SPEED_CACHE;
800
801 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
802 }
803
804 /**
805 * exec time
806 */
807
808 fprintf (out, "EXEC_RUNTIME\t");
809
810 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
811 {
812 hc_device_param_t *device_param = &data.devices_param[device_id];
813
814 if (device_param->skipped) continue;
815
816 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
817
818 fprintf (out, "%f\t", exec_ms_avg);
819 }
820
821 /**
822 * words_cur
823 */
824
825 u64 words_cur = get_lowest_words_done ();
826
827 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
828
829 /**
830 * counter
831 */
832
833 uint salts_left = data.salts_cnt - data.salts_done;
834
835 if (salts_left == 0) salts_left = 1;
836
837 u64 progress_total = data.words_cnt * salts_left;
838
839 u64 all_done = 0;
840 u64 all_rejected = 0;
841 u64 all_restored = 0;
842
843 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
844 {
845 if (salts_left > 1)
846 {
847 // otherwise the final cracked status shows 0/XXX progress
848
849 if (data.salts_shown[salt_pos] == 1) continue;
850 }
851
852 all_done += data.words_progress_done[salt_pos];
853 all_rejected += data.words_progress_rejected[salt_pos];
854 all_restored += data.words_progress_restored[salt_pos];
855 }
856
857 u64 progress_cur = all_restored + all_done + all_rejected;
858 u64 progress_end = progress_total;
859
860 u64 progress_skip = 0;
861
862 if (data.skip)
863 {
864 progress_skip = MIN (data.skip, data.words_base) * salts_left;
865
866 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
867 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
868 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
869 }
870
871 if (data.limit)
872 {
873 progress_end = MIN (data.limit, data.words_base) * salts_left;
874
875 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
876 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
877 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
878 }
879
880 u64 progress_cur_relative_skip = progress_cur - progress_skip;
881 u64 progress_end_relative_skip = progress_end - progress_skip;
882
883 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
884
885 /**
886 * cracks
887 */
888
889 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
890 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
891
892 /**
893 * temperature
894 */
895
896 #ifdef HAVE_HWMON
897 if (data.gpu_temp_disable == 0)
898 {
899 fprintf (out, "TEMP\t");
900
901 hc_thread_mutex_lock (mux_adl);
902
903 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
904 {
905 hc_device_param_t *device_param = &data.devices_param[device_id];
906
907 if (device_param->skipped) continue;
908
909 int temp = hm_get_temperature_with_device_id (device_id);
910
911 fprintf (out, "%d\t", temp);
912 }
913
914 hc_thread_mutex_unlock (mux_adl);
915 }
916 #endif // HAVE_HWMON
917
918 /**
919 * flush
920 */
921
922 #ifdef _WIN
923 fputc ('\r', out);
924 fputc ('\n', out);
925 #endif
926
927 #ifdef _POSIX
928 fputc ('\n', out);
929 #endif
930
931 fflush (out);
932 }
933
934 void status_display ()
935 {
936 if (data.devices_status == STATUS_INIT) return;
937 if (data.devices_status == STATUS_STARTING) return;
938 if (data.devices_status == STATUS_BYPASS) return;
939
940 if (data.status_automat == 1)
941 {
942 status_display_automat ();
943
944 return;
945 }
946
947 char tmp_buf[1000] = { 0 };
948
949 uint tmp_len = 0;
950
951 log_info ("Session.Name...: %s", data.session);
952
953 char *status_type = strstatus (data.devices_status);
954
955 uint hash_mode = data.hash_mode;
956
957 char *hash_type = strhashtype (hash_mode); // not a bug
958
959 log_info ("Status.........: %s", status_type);
960
961 /**
962 * show rules
963 */
964
965 if (data.rp_files_cnt)
966 {
967 uint i;
968
969 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
970 {
971 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
972 }
973
974 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
975
976 log_info ("Rules.Type.....: %s", tmp_buf);
977
978 tmp_len = 0;
979 }
980
981 if (data.rp_gen)
982 {
983 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
984
985 if (data.rp_gen_seed)
986 {
987 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
988 }
989 }
990
991 /**
992 * show input
993 */
994
995 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
996 {
997 if (data.wordlist_mode == WL_MODE_FILE)
998 {
999 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1000 }
1001 else if (data.wordlist_mode == WL_MODE_STDIN)
1002 {
1003 log_info ("Input.Mode.....: Pipe");
1004 }
1005 }
1006 else if (data.attack_mode == ATTACK_MODE_COMBI)
1007 {
1008 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1009 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1010 }
1011 else if (data.attack_mode == ATTACK_MODE_BF)
1012 {
1013 char *mask = data.mask;
1014
1015 if (mask != NULL)
1016 {
1017 uint mask_len = data.css_cnt;
1018
1019 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1020
1021 if (mask_len > 0)
1022 {
1023 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1024 {
1025 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1026 {
1027 mask_len -= data.salts_buf[0].salt_len;
1028 }
1029 }
1030
1031 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1032
1033 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1034 }
1035
1036 if (data.maskcnt > 1)
1037 {
1038 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1039
1040 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1041 }
1042
1043 log_info ("Input.Mode.....: %s", tmp_buf);
1044 }
1045
1046 tmp_len = 0;
1047 }
1048 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1049 {
1050 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1051 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1052 }
1053 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1054 {
1055 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1056 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1057 }
1058
1059 if (data.digests_cnt == 1)
1060 {
1061 if (data.hash_mode == 2500)
1062 {
1063 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1064
1065 uint pke[25] = { 0 };
1066
1067 char *pke_ptr = (char *) pke;
1068
1069 for (uint i = 0; i < 25; i++)
1070 {
1071 pke[i] = byte_swap_32 (wpa->pke[i]);
1072 }
1073
1074 char mac1[6] = { 0 };
1075 char mac2[6] = { 0 };
1076
1077 memcpy (mac1, pke_ptr + 23, 6);
1078 memcpy (mac2, pke_ptr + 29, 6);
1079
1080 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1081 (char *) data.salts_buf[0].salt_buf,
1082 mac1[0] & 0xff,
1083 mac1[1] & 0xff,
1084 mac1[2] & 0xff,
1085 mac1[3] & 0xff,
1086 mac1[4] & 0xff,
1087 mac1[5] & 0xff,
1088 mac2[0] & 0xff,
1089 mac2[1] & 0xff,
1090 mac2[2] & 0xff,
1091 mac2[3] & 0xff,
1092 mac2[4] & 0xff,
1093 mac2[5] & 0xff);
1094 }
1095 else if (data.hash_mode == 5200)
1096 {
1097 log_info ("Hash.Target....: File (%s)", data.hashfile);
1098 }
1099 else if (data.hash_mode == 9000)
1100 {
1101 log_info ("Hash.Target....: File (%s)", data.hashfile);
1102 }
1103 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1104 {
1105 log_info ("Hash.Target....: File (%s)", data.hashfile);
1106 }
1107 else
1108 {
1109 char out_buf[4096] = { 0 };
1110
1111 ascii_digest (out_buf, 0, 0);
1112
1113 // limit length
1114 if (strlen (out_buf) > 40)
1115 {
1116 out_buf[41] = '.';
1117 out_buf[42] = '.';
1118 out_buf[43] = '.';
1119 out_buf[44] = 0;
1120 }
1121
1122 log_info ("Hash.Target....: %s", out_buf);
1123 }
1124 }
1125 else
1126 {
1127 if (data.hash_mode == 3000)
1128 {
1129 char out_buf1[4096] = { 0 };
1130 char out_buf2[4096] = { 0 };
1131
1132 ascii_digest (out_buf1, 0, 0);
1133 ascii_digest (out_buf2, 0, 1);
1134
1135 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1136 }
1137 else
1138 {
1139 log_info ("Hash.Target....: File (%s)", data.hashfile);
1140 }
1141 }
1142
1143 log_info ("Hash.Type......: %s", hash_type);
1144
1145 /**
1146 * speed new
1147 */
1148
1149 u64 speed_cnt[DEVICES_MAX] = { 0 };
1150 float speed_ms[DEVICES_MAX] = { 0 };
1151
1152 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1153 {
1154 hc_device_param_t *device_param = &data.devices_param[device_id];
1155
1156 if (device_param->skipped) continue;
1157
1158 // we need to clear values (set to 0) because in case the device does
1159 // not get new candidates it idles around but speed display would
1160 // show it as working.
1161 // if we instantly set it to 0 after reading it happens that the
1162 // speed can be shown as zero if the users refreshes too fast.
1163 // therefore, we add a timestamp when a stat was recorded and if its
1164 // too old we will not use it
1165
1166 speed_cnt[device_id] = 0;
1167 speed_ms[device_id] = 0;
1168
1169 for (int i = 0; i < SPEED_CACHE; i++)
1170 {
1171 float rec_ms;
1172
1173 hc_timer_get (device_param->speed_rec[i], rec_ms);
1174
1175 if (rec_ms > SPEED_MAXAGE) continue;
1176
1177 speed_cnt[device_id] += device_param->speed_cnt[i];
1178 speed_ms[device_id] += device_param->speed_ms[i];
1179 }
1180
1181 speed_cnt[device_id] /= SPEED_CACHE;
1182 speed_ms[device_id] /= SPEED_CACHE;
1183 }
1184
1185 float hashes_all_ms = 0;
1186
1187 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1188
1189 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1190 {
1191 hc_device_param_t *device_param = &data.devices_param[device_id];
1192
1193 if (device_param->skipped) continue;
1194
1195 hashes_dev_ms[device_id] = 0;
1196
1197 if (speed_ms[device_id])
1198 {
1199 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1200
1201 hashes_all_ms += hashes_dev_ms[device_id];
1202 }
1203 }
1204
1205 /**
1206 * exec time
1207 */
1208
1209 double exec_all_ms[DEVICES_MAX] = { 0 };
1210
1211 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1212 {
1213 hc_device_param_t *device_param = &data.devices_param[device_id];
1214
1215 if (device_param->skipped) continue;
1216
1217 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1218
1219 exec_all_ms[device_id] = exec_ms_avg;
1220 }
1221
1222 /**
1223 * timers
1224 */
1225
1226 float ms_running = 0;
1227
1228 hc_timer_get (data.timer_running, ms_running);
1229
1230 float ms_paused = data.ms_paused;
1231
1232 if (data.devices_status == STATUS_PAUSED)
1233 {
1234 float ms_paused_tmp = 0;
1235
1236 hc_timer_get (data.timer_paused, ms_paused_tmp);
1237
1238 ms_paused += ms_paused_tmp;
1239 }
1240
1241 #ifdef WIN
1242
1243 __time64_t sec_run = ms_running / 1000;
1244
1245 #else
1246
1247 time_t sec_run = ms_running / 1000;
1248
1249 #endif
1250
1251 if (sec_run)
1252 {
1253 char display_run[32] = { 0 };
1254
1255 struct tm tm_run;
1256
1257 struct tm *tmp = NULL;
1258
1259 #ifdef WIN
1260
1261 tmp = _gmtime64 (&sec_run);
1262
1263 #else
1264
1265 tmp = gmtime (&sec_run);
1266
1267 #endif
1268
1269 if (tmp != NULL)
1270 {
1271 memset (&tm_run, 0, sizeof (tm_run));
1272
1273 memcpy (&tm_run, tmp, sizeof (tm_run));
1274
1275 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1276
1277 char *start = ctime (&data.proc_start);
1278
1279 size_t start_len = strlen (start);
1280
1281 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1282 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1283
1284 log_info ("Time.Started...: %s (%s)", start, display_run);
1285 }
1286 }
1287 else
1288 {
1289 log_info ("Time.Started...: 0 secs");
1290 }
1291
1292 /**
1293 * counters
1294 */
1295
1296 uint salts_left = data.salts_cnt - data.salts_done;
1297
1298 if (salts_left == 0) salts_left = 1;
1299
1300 u64 progress_total = data.words_cnt * salts_left;
1301
1302 u64 all_done = 0;
1303 u64 all_rejected = 0;
1304 u64 all_restored = 0;
1305
1306 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1307 {
1308 if (salts_left > 1)
1309 {
1310 // otherwise the final cracked status shows 0/XXX progress
1311
1312 if (data.salts_shown[salt_pos] == 1) continue;
1313 }
1314
1315 all_done += data.words_progress_done[salt_pos];
1316 all_rejected += data.words_progress_rejected[salt_pos];
1317 all_restored += data.words_progress_restored[salt_pos];
1318 }
1319
1320 u64 progress_cur = all_restored + all_done + all_rejected;
1321 u64 progress_end = progress_total;
1322
1323 u64 progress_skip = 0;
1324
1325 if (data.skip)
1326 {
1327 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1328
1329 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1330 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1331 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1332 }
1333
1334 if (data.limit)
1335 {
1336 progress_end = MIN (data.limit, data.words_base) * salts_left;
1337
1338 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1339 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1340 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1341 }
1342
1343 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1344 u64 progress_end_relative_skip = progress_end - progress_skip;
1345
1346 float speed_ms_real = ms_running - ms_paused;
1347 u64 speed_plains_real = all_done;
1348
1349 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1350 {
1351 if (data.devices_status != STATUS_CRACKED)
1352 {
1353 u64 words_per_ms = 0;
1354
1355 if (speed_plains_real && speed_ms_real)
1356 {
1357 words_per_ms = speed_plains_real / speed_ms_real;
1358 }
1359
1360 #ifdef WIN
1361 __time64_t sec_etc = 0;
1362 #else
1363 time_t sec_etc = 0;
1364 #endif
1365
1366 if (words_per_ms)
1367 {
1368 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1369
1370 u64 ms_left = progress_left_relative_skip / words_per_ms;
1371
1372 sec_etc = ms_left / 1000;
1373 }
1374
1375 if (sec_etc == 0)
1376 {
1377 log_info ("Time.Estimated.: 0 secs");
1378 }
1379 else if ((u64) sec_etc > ETC_MAX)
1380 {
1381 log_info ("Time.Estimated.: > 10 Years");
1382 }
1383 else
1384 {
1385 char display_etc[32] = { 0 };
1386
1387 struct tm tm_etc;
1388
1389 struct tm *tmp = NULL;
1390
1391 #ifdef WIN
1392
1393 tmp = _gmtime64 (&sec_etc);
1394
1395 #else
1396
1397 tmp = gmtime (&sec_etc);
1398
1399 #endif
1400
1401 if (tmp != NULL)
1402 {
1403 memset (&tm_etc, 0, sizeof (tm_etc));
1404
1405 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1406
1407 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1408
1409 time_t now;
1410
1411 time (&now);
1412
1413 now += sec_etc;
1414
1415 char *etc = ctime (&now);
1416
1417 size_t etc_len = strlen (etc);
1418
1419 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1420 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1421
1422 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1423 }
1424 }
1425 }
1426 }
1427
1428 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1429 {
1430 hc_device_param_t *device_param = &data.devices_param[device_id];
1431
1432 if (device_param->skipped) continue;
1433
1434 char display_dev_cur[16] = { 0 };
1435
1436 strncpy (display_dev_cur, "0.00", 4);
1437
1438 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1439
1440 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1441 }
1442
1443 char display_all_cur[16] = { 0 };
1444
1445 strncpy (display_all_cur, "0.00", 4);
1446
1447 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1448
1449 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1450
1451 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1452 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1453
1454 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);
1455
1456 // crack-per-time
1457
1458 if (data.digests_cnt > 100)
1459 {
1460 time_t now = time (NULL);
1461
1462 int cpt_cur_min = 0;
1463 int cpt_cur_hour = 0;
1464 int cpt_cur_day = 0;
1465
1466 for (int i = 0; i < CPT_BUF; i++)
1467 {
1468 const uint cracked = data.cpt_buf[i].cracked;
1469 const time_t timestamp = data.cpt_buf[i].timestamp;
1470
1471 if ((timestamp + 60) > now)
1472 {
1473 cpt_cur_min += cracked;
1474 }
1475
1476 if ((timestamp + 3600) > now)
1477 {
1478 cpt_cur_hour += cracked;
1479 }
1480
1481 if ((timestamp + 86400) > now)
1482 {
1483 cpt_cur_day += cracked;
1484 }
1485 }
1486
1487 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1488 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1489 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1490
1491 if ((data.cpt_start + 86400) < now)
1492 {
1493 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1494 cpt_cur_min,
1495 cpt_cur_hour,
1496 cpt_cur_day,
1497 cpt_avg_min,
1498 cpt_avg_hour,
1499 cpt_avg_day);
1500 }
1501 else if ((data.cpt_start + 3600) < now)
1502 {
1503 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1504 cpt_cur_min,
1505 cpt_cur_hour,
1506 cpt_avg_min,
1507 cpt_avg_hour,
1508 cpt_avg_day);
1509 }
1510 else if ((data.cpt_start + 60) < now)
1511 {
1512 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1513 cpt_cur_min,
1514 cpt_avg_min,
1515 cpt_avg_hour,
1516 cpt_avg_day);
1517 }
1518 else
1519 {
1520 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1521 cpt_avg_min,
1522 cpt_avg_hour,
1523 cpt_avg_day);
1524 }
1525 }
1526
1527 // Restore point
1528
1529 u64 restore_point = get_lowest_words_done ();
1530
1531 u64 restore_total = data.words_base;
1532
1533 float percent_restore = 0;
1534
1535 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1536
1537 if (progress_end_relative_skip)
1538 {
1539 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1540 {
1541 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1542 float percent_rejected = 0.0;
1543
1544 if (progress_cur)
1545 {
1546 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1547 }
1548
1549 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);
1550 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1551
1552 if (data.restore_disable == 0)
1553 {
1554 if (percent_finished != 1)
1555 {
1556 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1557 }
1558 }
1559 }
1560 }
1561 else
1562 {
1563 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1564 {
1565 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1566 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1567
1568 if (data.restore_disable == 0)
1569 {
1570 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1571 }
1572 }
1573 else
1574 {
1575 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1576 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1577
1578 // --restore not allowed if stdin is used -- really? why?
1579
1580 //if (data.restore_disable == 0)
1581 //{
1582 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1583 //}
1584 }
1585 }
1586
1587 #ifdef HAVE_HWMON
1588 if (data.gpu_temp_disable == 0)
1589 {
1590 hc_thread_mutex_lock (mux_adl);
1591
1592 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1593 {
1594 hc_device_param_t *device_param = &data.devices_param[device_id];
1595
1596 if (device_param->skipped) continue;
1597
1598 #define HM_STR_BUF_SIZE 255
1599
1600 if (data.hm_device[device_id].fan_supported == 1)
1601 {
1602 char utilization[HM_STR_BUF_SIZE] = { 0 };
1603 char temperature[HM_STR_BUF_SIZE] = { 0 };
1604 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1605
1606 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1607 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1608
1609 if (device_param->vendor_id == VENDOR_ID_AMD)
1610 {
1611 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1612 }
1613 else if (device_param->vendor_id == VENDOR_ID_NV)
1614 {
1615 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1616 }
1617
1618 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1619 }
1620 else
1621 {
1622 char utilization[HM_STR_BUF_SIZE] = { 0 };
1623 char temperature[HM_STR_BUF_SIZE] = { 0 };
1624
1625 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1626 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1627
1628 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1629 }
1630 }
1631
1632 hc_thread_mutex_unlock (mux_adl);
1633 }
1634 #endif // HAVE_HWMON
1635 }
1636
1637 static void status_benchmark ()
1638 {
1639 if (data.devices_status == STATUS_INIT) return;
1640 if (data.devices_status == STATUS_STARTING) return;
1641
1642 if (data.words_cnt == 0) return;
1643
1644 u64 speed_cnt[DEVICES_MAX] = { 0 };
1645 float speed_ms[DEVICES_MAX] = { 0 };
1646
1647 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1648 {
1649 hc_device_param_t *device_param = &data.devices_param[device_id];
1650
1651 if (device_param->skipped) continue;
1652
1653 speed_cnt[device_id] = 0;
1654 speed_ms[device_id] = 0;
1655
1656 for (int i = 0; i < SPEED_CACHE; i++)
1657 {
1658 speed_cnt[device_id] += device_param->speed_cnt[i];
1659 speed_ms[device_id] += device_param->speed_ms[i];
1660 }
1661
1662 speed_cnt[device_id] /= SPEED_CACHE;
1663 speed_ms[device_id] /= SPEED_CACHE;
1664 }
1665
1666 float hashes_all_ms = 0;
1667
1668 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1669
1670 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1671 {
1672 hc_device_param_t *device_param = &data.devices_param[device_id];
1673
1674 if (device_param->skipped) continue;
1675
1676 hashes_dev_ms[device_id] = 0;
1677
1678 if (speed_ms[device_id])
1679 {
1680 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1681
1682 hashes_all_ms += hashes_dev_ms[device_id];
1683 }
1684 }
1685
1686 /**
1687 * exec time
1688 */
1689
1690 double exec_all_ms[DEVICES_MAX] = { 0 };
1691
1692 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1693 {
1694 hc_device_param_t *device_param = &data.devices_param[device_id];
1695
1696 if (device_param->skipped) continue;
1697
1698 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1699
1700 exec_all_ms[device_id] = exec_ms_avg;
1701 }
1702
1703 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1704 {
1705 hc_device_param_t *device_param = &data.devices_param[device_id];
1706
1707 if (device_param->skipped) continue;
1708
1709 char display_dev_cur[16] = { 0 };
1710
1711 strncpy (display_dev_cur, "0.00", 4);
1712
1713 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1714
1715 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1716 }
1717
1718 char display_all_cur[16] = { 0 };
1719
1720 strncpy (display_all_cur, "0.00", 4);
1721
1722 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1723
1724 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1725 }
1726
1727 /**
1728 * oclHashcat -only- functions
1729 */
1730
1731 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1732 {
1733 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1734 {
1735 if (attack_kern == ATTACK_KERN_STRAIGHT)
1736 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1737 else if (attack_kern == ATTACK_KERN_COMBI)
1738 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1739 else if (attack_kern == ATTACK_KERN_BF)
1740 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1741 }
1742 else
1743 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1744 }
1745
1746 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)
1747 {
1748 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1749 {
1750 if (attack_kern == ATTACK_KERN_STRAIGHT)
1751 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1752 else if (attack_kern == ATTACK_KERN_COMBI)
1753 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1754 else if (attack_kern == ATTACK_KERN_BF)
1755 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1756 }
1757 else
1758 {
1759 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1760 }
1761 }
1762
1763 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1764 {
1765 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1766 {
1767 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1768 }
1769 else
1770 {
1771 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1772 }
1773 }
1774
1775 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)
1776 {
1777 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1778 {
1779 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1780 }
1781 else
1782 {
1783 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1784 }
1785 }
1786
1787 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1788 {
1789 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1790 }
1791
1792 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1793 {
1794 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1795 }
1796
1797 static uint convert_from_hex (char *line_buf, const uint line_len)
1798 {
1799 if (line_len & 1) return (line_len); // not in hex
1800
1801 if (data.hex_wordlist == 1)
1802 {
1803 uint i;
1804 uint j;
1805
1806 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1807 {
1808 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1809 }
1810
1811 memset (line_buf + i, 0, line_len - i);
1812
1813 return (i);
1814 }
1815 else if (line_len >= 6) // $HEX[] = 6
1816 {
1817 if (line_buf[0] != '$') return (line_len);
1818 if (line_buf[1] != 'H') return (line_len);
1819 if (line_buf[2] != 'E') return (line_len);
1820 if (line_buf[3] != 'X') return (line_len);
1821 if (line_buf[4] != '[') return (line_len);
1822 if (line_buf[line_len - 1] != ']') return (line_len);
1823
1824 uint i;
1825 uint j;
1826
1827 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1828 {
1829 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1830 }
1831
1832 memset (line_buf + i, 0, line_len - i);
1833
1834 return (i);
1835 }
1836
1837 return (line_len);
1838 }
1839
1840 static void clear_prompt ()
1841 {
1842 fputc ('\r', stdout);
1843
1844 for (size_t i = 0; i < strlen (PROMPT); i++)
1845 {
1846 fputc (' ', stdout);
1847 }
1848
1849 fputc ('\r', stdout);
1850
1851 fflush (stdout);
1852 }
1853
1854 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1855 {
1856 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);
1857 }
1858
1859 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1860 {
1861 char *outfile = data.outfile;
1862 uint quiet = data.quiet;
1863 FILE *pot_fp = data.pot_fp;
1864 uint loopback = data.loopback;
1865 uint debug_mode = data.debug_mode;
1866 char *debug_file = data.debug_file;
1867
1868 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1869 int debug_rule_len = 0; // -1 error
1870 uint debug_plain_len = 0;
1871
1872 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1873
1874 // hash
1875
1876 char out_buf[4096] = { 0 };
1877
1878 ascii_digest (out_buf, salt_pos, digest_pos);
1879
1880 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1881
1882 // plain
1883
1884 plain_t plain;
1885
1886 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);
1887
1888 uint gidvid = plain.gidvid;
1889 uint il_pos = plain.il_pos;
1890
1891 u64 crackpos = device_param->words_off;
1892
1893 uint plain_buf[16] = { 0 };
1894
1895 u8 *plain_ptr = (u8 *) plain_buf;
1896 unsigned int plain_len = 0;
1897
1898 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1899 {
1900 u64 gidd = gidvid;
1901 u64 gidm = 0;
1902
1903 pw_t pw;
1904
1905 gidd_to_pw_t (device_param, gidd, &pw);
1906
1907 for (int i = 0, j = gidm; i < 16; i++, j++)
1908 {
1909 plain_buf[i] = pw.i[j];
1910 }
1911
1912 plain_len = pw.pw_len;
1913
1914 const uint off = device_param->innerloop_pos + il_pos;
1915
1916 if (debug_mode > 0)
1917 {
1918 debug_rule_len = 0;
1919
1920 // save rule
1921 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1922 {
1923 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1924
1925 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1926 }
1927
1928 // save plain
1929 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1930 {
1931 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1932
1933 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1934
1935 debug_plain_len = plain_len;
1936 }
1937 }
1938
1939 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1940
1941 crackpos += gidvid;
1942 crackpos *= data.kernel_rules_cnt;
1943 crackpos += device_param->innerloop_pos + il_pos;
1944
1945 if (plain_len > data.pw_max) plain_len = data.pw_max;
1946 }
1947 else if (data.attack_mode == ATTACK_MODE_COMBI)
1948 {
1949 u64 gidd = gidvid;
1950 u64 gidm = 0;
1951
1952 pw_t pw;
1953
1954 gidd_to_pw_t (device_param, gidd, &pw);
1955
1956 for (int i = 0, j = gidm; i < 16; i++, j++)
1957 {
1958 plain_buf[i] = pw.i[j];
1959 }
1960
1961 plain_len = pw.pw_len;
1962
1963 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1964 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1965
1966 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1967 {
1968 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1969 }
1970 else
1971 {
1972 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1973
1974 memcpy (plain_ptr, comb_buf, comb_len);
1975 }
1976
1977 plain_len += comb_len;
1978
1979 crackpos += gidvid;
1980 crackpos *= data.combs_cnt;
1981 crackpos += device_param->innerloop_pos + il_pos;
1982
1983 if (data.pw_max != PW_DICTMAX1)
1984 {
1985 if (plain_len > data.pw_max) plain_len = data.pw_max;
1986 }
1987 }
1988 else if (data.attack_mode == ATTACK_MODE_BF)
1989 {
1990 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1991 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1992
1993 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1994 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1995
1996 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1997 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1998
1999 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2000 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2001
2002 plain_len = data.css_cnt;
2003
2004 crackpos += gidvid;
2005 crackpos *= data.bfs_cnt;
2006 crackpos += device_param->innerloop_pos + il_pos;
2007 }
2008 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2009 {
2010 u64 gidd = gidvid;
2011 u64 gidm = 0;
2012
2013 pw_t pw;
2014
2015 gidd_to_pw_t (device_param, gidd, &pw);
2016
2017 for (int i = 0, j = gidm; i < 16; i++, j++)
2018 {
2019 plain_buf[i] = pw.i[j];
2020 }
2021
2022 plain_len = pw.pw_len;
2023
2024 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2025
2026 uint start = 0;
2027 uint stop = device_param->kernel_params_mp_buf32[4];
2028
2029 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2030
2031 plain_len += start + stop;
2032
2033 crackpos += gidvid;
2034 crackpos *= data.combs_cnt;
2035 crackpos += device_param->innerloop_pos + il_pos;
2036
2037 if (data.pw_max != PW_DICTMAX1)
2038 {
2039 if (plain_len > data.pw_max) plain_len = data.pw_max;
2040 }
2041 }
2042 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2043 {
2044 u64 gidd = gidvid;
2045 u64 gidm = 0;
2046
2047 pw_t pw;
2048
2049 gidd_to_pw_t (device_param, gidd, &pw);
2050
2051 for (int i = 0, j = gidm; i < 16; i++, j++)
2052 {
2053 plain_buf[i] = pw.i[j];
2054 }
2055
2056 plain_len = pw.pw_len;
2057
2058 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2059
2060 uint start = 0;
2061 uint stop = device_param->kernel_params_mp_buf32[4];
2062
2063 memmove (plain_ptr + stop, plain_ptr, plain_len);
2064
2065 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2066
2067 plain_len += start + stop;
2068
2069 crackpos += gidvid;
2070 crackpos *= data.combs_cnt;
2071 crackpos += device_param->innerloop_pos + il_pos;
2072
2073 if (data.pw_max != PW_DICTMAX1)
2074 {
2075 if (plain_len > data.pw_max) plain_len = data.pw_max;
2076 }
2077 }
2078
2079 if (data.attack_mode == ATTACK_MODE_BF)
2080 {
2081 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2082 {
2083 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2084 {
2085 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2086 {
2087 plain_len = plain_len - data.salts_buf[0].salt_len;
2088 }
2089 }
2090
2091 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2092 {
2093 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2094 {
2095 plain_ptr[j] = plain_ptr[i];
2096 }
2097
2098 plain_len = plain_len / 2;
2099 }
2100 }
2101 }
2102
2103 // if enabled, update also the potfile
2104
2105 if (pot_fp)
2106 {
2107 lock_file (pot_fp);
2108
2109 fprintf (pot_fp, "%s:", out_buf);
2110
2111 format_plain (pot_fp, plain_ptr, plain_len, 1);
2112
2113 fputc ('\n', pot_fp);
2114
2115 fflush (pot_fp);
2116
2117 unlock_file (pot_fp);
2118 }
2119
2120 // outfile
2121
2122 FILE *out_fp = NULL;
2123
2124 if (outfile != NULL)
2125 {
2126 if ((out_fp = fopen (outfile, "ab")) == NULL)
2127 {
2128 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2129
2130 out_fp = stdout;
2131 }
2132 lock_file (out_fp);
2133 }
2134 else
2135 {
2136 out_fp = stdout;
2137
2138 if (quiet == 0) clear_prompt ();
2139 }
2140
2141 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2142
2143 if (outfile != NULL)
2144 {
2145 if (out_fp != stdout)
2146 {
2147 fclose (out_fp);
2148 }
2149 }
2150 else
2151 {
2152 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2153 {
2154 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2155 {
2156 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2157 if (quiet == 0) fflush (stdout);
2158 }
2159 }
2160 }
2161
2162 // loopback
2163
2164 if (loopback)
2165 {
2166 char *loopback_file = data.loopback_file;
2167
2168 FILE *fb_fp = NULL;
2169
2170 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2171 {
2172 lock_file (fb_fp);
2173
2174 format_plain (fb_fp, plain_ptr, plain_len, 1);
2175
2176 fputc ('\n', fb_fp);
2177
2178 fclose (fb_fp);
2179 }
2180 }
2181
2182 // (rule) debug mode
2183
2184 // the next check implies that:
2185 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2186 // - debug_mode > 0
2187
2188 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2189 {
2190 if (debug_rule_len < 0) debug_rule_len = 0;
2191
2192 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2193
2194 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2195
2196 if ((quiet == 0) && (debug_file == NULL))
2197 {
2198 fprintf (stdout, "%s", PROMPT);
2199 fflush (stdout);
2200 }
2201 }
2202 }
2203
2204 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2205 {
2206 salt_t *salt_buf = &data.salts_buf[salt_pos];
2207
2208 int found = 0;
2209
2210 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);
2211
2212 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2213
2214 if (found == 1)
2215 {
2216 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2217
2218 log_info_nn ("");
2219
2220 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);
2221
2222 uint cpt_cracked = 0;
2223
2224 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2225 {
2226 uint idx = salt_buf->digests_offset + digest_pos;
2227
2228 if (data.digests_shown_tmp[idx] == 0) continue;
2229
2230 if (data.digests_shown[idx] == 1) continue;
2231
2232 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2233 {
2234 data.digests_shown[idx] = 1;
2235
2236 data.digests_done++;
2237
2238 cpt_cracked++;
2239
2240 salt_buf->digests_done++;
2241
2242 if (salt_buf->digests_done == salt_buf->digests_cnt)
2243 {
2244 data.salts_shown[salt_pos] = 1;
2245
2246 data.salts_done++;
2247 }
2248 }
2249
2250 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2251
2252 check_hash (device_param, salt_pos, digest_pos);
2253 }
2254
2255 if (cpt_cracked > 0)
2256 {
2257 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2258 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2259
2260 data.cpt_pos++;
2261
2262 data.cpt_total += cpt_cracked;
2263
2264 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2265 }
2266
2267 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2268 {
2269 // we need to reset cracked state on the device
2270 // otherwise host thinks again and again the hash was cracked
2271 // and returns invalid password each time
2272
2273 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2274
2275 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);
2276 }
2277
2278 memset (device_param->result, 0, device_param->size_results);
2279
2280 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);
2281 }
2282 }
2283
2284 static void save_hash ()
2285 {
2286 char *hashfile = data.hashfile;
2287
2288 char new_hashfile[256] = { 0 };
2289 char old_hashfile[256] = { 0 };
2290
2291 snprintf (new_hashfile, 255, "%s.new", hashfile);
2292 snprintf (old_hashfile, 255, "%s.old", hashfile);
2293
2294 unlink (new_hashfile);
2295
2296 char separator = data.separator;
2297
2298 FILE *fp = fopen (new_hashfile, "wb");
2299
2300 if (fp == NULL)
2301 {
2302 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2303
2304 exit (-1);
2305 }
2306
2307 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2308 {
2309 if (data.salts_shown[salt_pos] == 1) continue;
2310
2311 salt_t *salt_buf = &data.salts_buf[salt_pos];
2312
2313 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2314 {
2315 uint idx = salt_buf->digests_offset + digest_pos;
2316
2317 if (data.digests_shown[idx] == 1) continue;
2318
2319 if (data.hash_mode != 2500)
2320 {
2321 char out_buf[4096] = { 0 };
2322
2323 if (data.username == 1)
2324 {
2325 user_t *user = data.hash_info[idx]->user;
2326
2327 uint i;
2328
2329 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2330
2331 fputc (separator, fp);
2332 }
2333
2334 ascii_digest (out_buf, salt_pos, digest_pos);
2335
2336 fputs (out_buf, fp);
2337
2338 log_out (fp, "");
2339 }
2340 else
2341 {
2342 hccap_t hccap;
2343
2344 to_hccap_t (&hccap, salt_pos, digest_pos);
2345
2346 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2347 }
2348 }
2349 }
2350
2351 fflush (fp);
2352
2353 fclose (fp);
2354
2355 unlink (old_hashfile);
2356
2357 if (rename (hashfile, old_hashfile) != 0)
2358 {
2359 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2360
2361 exit (-1);
2362 }
2363
2364 unlink (hashfile);
2365
2366 if (rename (new_hashfile, hashfile) != 0)
2367 {
2368 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2369
2370 exit (-1);
2371 }
2372
2373 unlink (old_hashfile);
2374 }
2375
2376 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2377 {
2378 // function called only in case kernel_power_all > words_left
2379
2380 float kernel_power_div = (float) (total_left) / kernel_power_all;
2381
2382 kernel_power_div += kernel_power_div / 100;
2383
2384 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2385
2386 while (kernel_power_new < total_left)
2387 {
2388 kernel_power_div += kernel_power_div / 100;
2389
2390 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2391 }
2392
2393 if (data.quiet == 0)
2394 {
2395 clear_prompt ();
2396
2397 log_info ("");
2398
2399 log_info ("INFO: approaching final keyspace, workload adjusted");
2400
2401 log_info ("");
2402
2403 fprintf (stdout, "%s", PROMPT);
2404
2405 fflush (stdout);
2406 }
2407
2408 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2409
2410 return kernel_power_div;
2411 }
2412
2413 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2414 {
2415 uint num_elements = num;
2416
2417 device_param->kernel_params_buf32[30] = data.combs_mode;
2418 device_param->kernel_params_buf32[31] = num;
2419
2420 uint kernel_threads = device_param->kernel_threads;
2421
2422 while (num_elements % kernel_threads) num_elements++;
2423
2424 cl_kernel kernel = NULL;
2425
2426 switch (kern_run)
2427 {
2428 case KERN_RUN_1: kernel = device_param->kernel1; break;
2429 case KERN_RUN_12: kernel = device_param->kernel12; break;
2430 case KERN_RUN_2: kernel = device_param->kernel2; break;
2431 case KERN_RUN_23: kernel = device_param->kernel23; break;
2432 case KERN_RUN_3: kernel = device_param->kernel3; break;
2433 }
2434
2435 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2436 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2437 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2438 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2439 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2440 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2441 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2442 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2443 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2444 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2445 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2446
2447 hc_timer_t timer;
2448
2449 hc_timer_set (&timer);
2450
2451 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2452 {
2453 const size_t global_work_size[3] = { num_elements, 32, 1 };
2454 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2455
2456 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2457 }
2458 else
2459 {
2460 size_t workgroup_size = 0;
2461
2462 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2463
2464 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2465
2466 const size_t global_work_size[3] = { num_elements, 1, 1 };
2467 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2468
2469 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2470 }
2471
2472 hc_clFlush (data.ocl, device_param->command_queue);
2473
2474 hc_clFinish (data.ocl, device_param->command_queue);
2475
2476 if (event_update)
2477 {
2478 float exec_time;
2479
2480 hc_timer_get (timer, exec_time);
2481
2482 uint exec_pos = device_param->exec_pos;
2483
2484 device_param->exec_ms[exec_pos] = exec_time;
2485
2486 exec_pos++;
2487
2488 if (exec_pos == EXEC_CACHE)
2489 {
2490 exec_pos = 0;
2491 }
2492
2493 device_param->exec_pos = exec_pos;
2494 }
2495 }
2496
2497 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2498 {
2499 uint num_elements = num;
2500
2501 switch (kern_run)
2502 {
2503 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2504 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2505 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2506 }
2507
2508 // causes problems with special threads like in bcrypt
2509 // const uint kernel_threads = device_param->kernel_threads;
2510
2511 uint kernel_threads = KERNEL_THREADS;
2512
2513 while (num_elements % kernel_threads) num_elements++;
2514
2515 cl_kernel kernel = NULL;
2516
2517 switch (kern_run)
2518 {
2519 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2520 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2521 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2522 }
2523
2524 switch (kern_run)
2525 {
2526 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2527 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2528 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2529 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2530 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2531 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2532 break;
2533 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2534 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2535 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2536 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2537 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2538 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2539 break;
2540 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2541 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2542 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2543 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2544 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2545 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2546 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2547 break;
2548 }
2549
2550 size_t workgroup_size = 0;
2551 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
2552 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2553
2554 const size_t global_work_size[3] = { num_elements, 1, 1 };
2555 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2556
2557 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2558
2559 hc_clFlush (data.ocl, device_param->command_queue);
2560
2561 hc_clFinish (data.ocl, device_param->command_queue);
2562 }
2563
2564 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2565 {
2566 uint num_elements = num;
2567
2568 uint kernel_threads = device_param->kernel_threads;
2569
2570 while (num_elements % kernel_threads) num_elements++;
2571
2572 cl_kernel kernel = device_param->kernel_tb;
2573
2574 size_t workgroup_size = 0;
2575 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2576 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2577
2578 const size_t global_work_size[3] = { num_elements, 1, 1 };
2579 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2580
2581 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2582
2583 hc_clFlush (data.ocl, device_param->command_queue);
2584
2585 hc_clFinish (data.ocl, device_param->command_queue);
2586 }
2587
2588 static void run_kernel_tm (hc_device_param_t *device_param)
2589 {
2590 const uint num_elements = 1024; // fixed
2591
2592 uint kernel_threads = 32;
2593
2594 cl_kernel kernel = device_param->kernel_tm;
2595
2596 size_t workgroup_size = 0;
2597 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2598 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2599
2600 const size_t global_work_size[3] = { num_elements, 1, 1 };
2601 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2602
2603 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2604
2605 hc_clFlush (data.ocl, device_param->command_queue);
2606
2607 hc_clFinish (data.ocl, device_param->command_queue);
2608 }
2609
2610 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2611 {
2612 uint num_elements = num;
2613
2614 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2615 device_param->kernel_params_amp_buf32[6] = num_elements;
2616
2617 // causes problems with special threads like in bcrypt
2618 // const uint kernel_threads = device_param->kernel_threads;
2619
2620 uint kernel_threads = KERNEL_THREADS;
2621
2622 while (num_elements % kernel_threads) num_elements++;
2623
2624 cl_kernel kernel = device_param->kernel_amp;
2625
2626 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2627 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2628
2629 size_t workgroup_size = 0;
2630 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2631 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2632
2633 const size_t global_work_size[3] = { num_elements, 1, 1 };
2634 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2635
2636 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2637
2638 hc_clFlush (data.ocl, device_param->command_queue);
2639
2640 hc_clFinish (data.ocl, device_param->command_queue);
2641 }
2642
2643 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2644 {
2645 int rc = -1;
2646
2647 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2648 {
2649 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2650
2651 const cl_uchar zero = 0;
2652
2653 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2654 }
2655
2656 if (rc != 0)
2657 {
2658 // NOTE: clEnqueueFillBuffer () always fails with -59
2659 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2660 // How's that possible, OpenCL 1.2 support is advertised??
2661 // We need to workaround...
2662
2663 #define FILLSZ 0x100000
2664
2665 char *tmp = (char *) mymalloc (FILLSZ);
2666
2667 for (uint i = 0; i < size; i += FILLSZ)
2668 {
2669 const int left = size - i;
2670
2671 const int fillsz = MIN (FILLSZ, left);
2672
2673 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2674 }
2675
2676 myfree (tmp);
2677 }
2678 }
2679
2680 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)
2681 {
2682 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2683 {
2684 if (attack_mode == ATTACK_MODE_BF)
2685 {
2686 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2687 {
2688 const uint size_tm = 32 * sizeof (bs_word_t);
2689
2690 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2691
2692 run_kernel_tm (device_param);
2693
2694 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);
2695 }
2696 }
2697
2698 if (highest_pw_len < 16)
2699 {
2700 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2701 }
2702 else if (highest_pw_len < 32)
2703 {
2704 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2705 }
2706 else
2707 {
2708 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2709 }
2710 }
2711 else
2712 {
2713 run_kernel_amp (device_param, pws_cnt);
2714
2715 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2716
2717 if (opts_type & OPTS_TYPE_HOOK12)
2718 {
2719 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2720 }
2721
2722 uint iter = salt_buf->salt_iter;
2723
2724 uint loop_step = device_param->kernel_loops;
2725
2726 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2727 {
2728 uint loop_left = iter - loop_pos;
2729
2730 loop_left = MIN (loop_left, loop_step);
2731
2732 device_param->kernel_params_buf32[25] = loop_pos;
2733 device_param->kernel_params_buf32[26] = loop_left;
2734
2735 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2736
2737 if (data.devices_status == STATUS_CRACKED) break;
2738 if (data.devices_status == STATUS_ABORTED) break;
2739 if (data.devices_status == STATUS_QUIT) break;
2740 }
2741
2742 if (opts_type & OPTS_TYPE_HOOK23)
2743 {
2744 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2745
2746 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);
2747
2748 // do something with data
2749
2750 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);
2751 }
2752
2753 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2754 }
2755 }
2756
2757 static int run_rule_engine (const int rule_len, const char *rule_buf)
2758 {
2759 if (rule_len == 0)
2760 {
2761 return 0;
2762 }
2763 else if (rule_len == 1)
2764 {
2765 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2766 }
2767
2768 return 1;
2769 }
2770
2771 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2772 {
2773 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2774 {
2775 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);
2776 }
2777 else if (data.attack_kern == ATTACK_KERN_COMBI)
2778 {
2779 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2780 {
2781 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2782 {
2783 for (u32 i = 0; i < pws_cnt; i++)
2784 {
2785 const u32 pw_len = device_param->pws_buf[i].pw_len;
2786
2787 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2788
2789 ptr[pw_len] = 0x01;
2790 }
2791 }
2792 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2793 {
2794 for (u32 i = 0; i < pws_cnt; i++)
2795 {
2796 const u32 pw_len = device_param->pws_buf[i].pw_len;
2797
2798 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2799
2800 ptr[pw_len] = 0x80;
2801 }
2802 }
2803 }
2804
2805 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);
2806 }
2807 else if (data.attack_kern == ATTACK_KERN_BF)
2808 {
2809 const u64 off = device_param->words_off;
2810
2811 device_param->kernel_params_mp_l_buf64[3] = off;
2812
2813 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2814 }
2815 }
2816
2817 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops, const int repeat)
2818 {
2819 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2820
2821 device_param->kernel_params_buf32[26] = kernel_loops;
2822 device_param->kernel_params_buf32[27] = kernel_loops;
2823
2824 // init some fake words
2825
2826 for (u32 i = 0; i < kernel_power; i++)
2827 {
2828 device_param->pws_buf[i].i[0] = i;
2829 device_param->pws_buf[i].i[1] = 0x01234567;
2830 device_param->pws_buf[i].pw_len = 4 + (i & 3);
2831 }
2832
2833 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);
2834
2835 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2836 {
2837 run_kernel_amp (device_param, kernel_power);
2838 }
2839
2840 // caching run
2841
2842 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2843 {
2844 run_kernel (KERN_RUN_1, device_param, kernel_power, false);
2845 }
2846 else
2847 {
2848 run_kernel (KERN_RUN_2, device_param, kernel_power, false);
2849 }
2850
2851 // now user repeats
2852
2853 for (int i = 0; i < repeat; i++)
2854 {
2855 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2856 {
2857 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2858 }
2859 else
2860 {
2861 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2862 }
2863 }
2864
2865 const double exec_ms_prev = get_avg_exec_time (device_param, repeat);
2866
2867 // reset fake words
2868
2869 memset (device_param->pws_buf, 0, kernel_power * sizeof (pw_t));
2870
2871 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);
2872 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);
2873
2874 return exec_ms_prev;
2875 }
2876
2877 static void autotune (hc_device_param_t *device_param)
2878 {
2879 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2880
2881 const u32 kernel_accel_min = device_param->kernel_accel_min;
2882 const u32 kernel_accel_max = device_param->kernel_accel_max;
2883
2884 const u32 kernel_loops_min = device_param->kernel_loops_min;
2885 const u32 kernel_loops_max = device_param->kernel_loops_max;
2886
2887 u32 kernel_accel = kernel_accel_min;
2888 u32 kernel_loops = kernel_loops_min;
2889
2890 // steps
2891
2892 #define STEPS_CNT 10
2893
2894 #define STEPS_ACCEL_CNT (STEPS_CNT + 2)
2895 #define STEPS_LOOPS_CNT (STEPS_CNT + 2)
2896
2897 u32 steps_accel[STEPS_ACCEL_CNT];
2898 u32 steps_loops[STEPS_LOOPS_CNT];
2899
2900 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2901 {
2902 steps_accel[i] = 1 << i;
2903 }
2904
2905 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2906 {
2907 steps_loops[i] = 1 << i;
2908 }
2909
2910 steps_accel[STEPS_CNT + 0] = kernel_accel_min;
2911 steps_accel[STEPS_CNT + 1] = kernel_accel_max;
2912
2913 steps_loops[STEPS_CNT + 0] = kernel_loops_min;
2914 steps_loops[STEPS_CNT + 1] = kernel_loops_max;
2915
2916 qsort (steps_accel, STEPS_ACCEL_CNT, sizeof (u32), sort_by_u32);
2917 qsort (steps_loops, STEPS_LOOPS_CNT, sizeof (u32), sort_by_u32);
2918
2919 // find out highest kernel-loops that stays below target_ms, we can use it later for multiplication as this is a linear function
2920
2921 u32 kernel_loops_tmp;
2922
2923 for (kernel_loops_tmp = kernel_loops_max; kernel_loops_tmp > kernel_loops_min; kernel_loops_tmp >>= 1)
2924 {
2925 const double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops_tmp, 1);
2926
2927 if (exec_ms < target_ms) break;
2928 }
2929
2930 // kernel-accel
2931
2932 if (kernel_accel_min < kernel_accel_max)
2933 {
2934 double e_best = 0;
2935
2936 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2937 {
2938 const u32 kernel_accel_try = steps_accel[i];
2939
2940 if (kernel_accel_try < kernel_accel_min) continue;
2941 if (kernel_accel_try > kernel_accel_max) break;
2942
2943 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_tmp, 1);
2944
2945 if (exec_ms > target_ms) break;
2946
2947 const double e = kernel_accel_try / exec_ms;
2948
2949 if (e > e_best)
2950 {
2951 kernel_accel = kernel_accel_try;
2952
2953 e_best = e;
2954 }
2955 }
2956 }
2957
2958 // kernel-loops final
2959
2960 if (kernel_loops_min < kernel_loops_max)
2961 {
2962 double e_best = 0;
2963
2964 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2965 {
2966 const u32 kernel_loops_try = steps_loops[i];
2967
2968 if (kernel_loops_try < kernel_loops_min) continue;
2969 if (kernel_loops_try > kernel_loops_max) break;
2970
2971 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops_try, 1);
2972
2973 if (exec_ms > target_ms) break;
2974
2975 const double e = kernel_loops_try / exec_ms;
2976
2977 if (e > e_best)
2978 {
2979 kernel_loops = kernel_loops_try;
2980
2981 e_best = e;
2982 }
2983 }
2984 }
2985
2986 // final balance
2987
2988 u32 kernel_accel_best = kernel_accel;
2989 u32 kernel_loops_best = kernel_loops;
2990
2991 u32 exec_best = -1;
2992
2993 if ((kernel_accel_min < kernel_accel_max) || (kernel_loops_min < kernel_loops_max))
2994 {
2995 const double exec_ms = try_run (device_param, kernel_accel_best, kernel_loops_best, 1);
2996
2997 exec_best = exec_ms;
2998 }
2999
3000 // reset
3001
3002 if (kernel_accel_min < kernel_accel_max)
3003 {
3004 u32 kernel_accel_try = kernel_accel;
3005 u32 kernel_loops_try = kernel_loops;
3006
3007 for (int i = 0; i < 2; i++)
3008 {
3009 kernel_accel_try >>= 1;
3010 kernel_loops_try <<= 1;
3011
3012 if (kernel_accel_try < kernel_accel_min) break;
3013 if (kernel_loops_try > kernel_loops_max) break;
3014
3015 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
3016
3017 if (exec_ms < exec_best)
3018 {
3019 kernel_accel_best = kernel_accel_try;
3020 kernel_loops_best = kernel_loops_try;
3021
3022 exec_best = exec_ms;
3023 }
3024 }
3025 }
3026
3027 // reset
3028
3029 if (kernel_loops_min < kernel_loops_max)
3030 {
3031 u32 kernel_accel_try = kernel_accel;
3032 u32 kernel_loops_try = kernel_loops;
3033
3034 for (int i = 0; i < 2; i++)
3035 {
3036 kernel_accel_try <<= 1;
3037 kernel_loops_try >>= 1;
3038
3039 if (kernel_accel_try > kernel_accel_max) break;
3040 if (kernel_loops_try < kernel_loops_min) break;
3041
3042 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
3043
3044 if (exec_ms < exec_best)
3045 {
3046 kernel_accel_best = kernel_accel_try;
3047 kernel_loops_best = kernel_loops_try;
3048
3049 exec_best = exec_ms;
3050 }
3051 }
3052 }
3053
3054 // reset timer
3055
3056 device_param->exec_pos = 0;
3057
3058 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3059
3060 // store
3061
3062 kernel_accel = kernel_accel_best;
3063 kernel_loops = kernel_loops_best;
3064
3065 device_param->kernel_accel = kernel_accel;
3066 device_param->kernel_loops = kernel_loops;
3067
3068 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3069
3070 device_param->kernel_power = kernel_power;
3071
3072 if (data.quiet == 0) log_info ("Device #%u: autotuned kernel-accel to %u", device_param->device_id + 1, kernel_accel);
3073 if (data.quiet == 0) log_info ("Device #%u: autotuned kernel-loops to %u", device_param->device_id + 1, kernel_loops);
3074 if (data.quiet == 0) log_info ("");
3075 }
3076
3077 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3078 {
3079 // init speed timer
3080
3081 uint speed_pos = device_param->speed_pos;
3082
3083 #ifdef _POSIX
3084 if (device_param->timer_speed.tv_sec == 0)
3085 {
3086 hc_timer_set (&device_param->timer_speed);
3087 }
3088 #endif
3089
3090 #ifdef _WIN
3091 if (device_param->timer_speed.QuadPart == 0)
3092 {
3093 hc_timer_set (&device_param->timer_speed);
3094 }
3095 #endif
3096
3097 // find higest password length, this is for optimization stuff
3098
3099 uint highest_pw_len = 0;
3100
3101 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3102 {
3103 }
3104 else if (data.attack_kern == ATTACK_KERN_COMBI)
3105 {
3106 }
3107 else if (data.attack_kern == ATTACK_KERN_BF)
3108 {
3109 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3110 + device_param->kernel_params_mp_l_buf32[5];
3111 }
3112
3113 // bitslice optimization stuff
3114
3115 if (data.attack_mode == ATTACK_MODE_BF)
3116 {
3117 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
3118 {
3119 run_kernel_tb (device_param, pws_cnt);
3120 }
3121 }
3122
3123 // iteration type
3124
3125 uint innerloop_step = 0;
3126 uint innerloop_cnt = 0;
3127
3128 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3129 else innerloop_step = 1;
3130
3131 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3132 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3133 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3134
3135 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3136
3137 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3138 {
3139 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3140
3141 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3142
3143 if (data.devices_status == STATUS_CRACKED) break;
3144 if (data.devices_status == STATUS_ABORTED) break;
3145 if (data.devices_status == STATUS_QUIT) break;
3146 if (data.devices_status == STATUS_BYPASS) break;
3147
3148 if (data.salts_shown[salt_pos] == 1) continue;
3149
3150 salt_t *salt_buf = &data.salts_buf[salt_pos];
3151
3152 device_param->kernel_params_buf32[24] = salt_pos;
3153 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3154 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3155
3156 FILE *combs_fp = device_param->combs_fp;
3157
3158 if (data.attack_mode == ATTACK_MODE_COMBI)
3159 {
3160 rewind (combs_fp);
3161 }
3162
3163 // innerloops
3164
3165 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3166 {
3167 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3168
3169 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3170
3171 if (data.devices_status == STATUS_CRACKED) break;
3172 if (data.devices_status == STATUS_ABORTED) break;
3173 if (data.devices_status == STATUS_QUIT) break;
3174 if (data.devices_status == STATUS_BYPASS) break;
3175
3176 uint innerloop_left = innerloop_cnt - innerloop_pos;
3177
3178 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3179
3180 device_param->innerloop_pos = innerloop_pos;
3181 device_param->innerloop_left = innerloop_left;
3182
3183 device_param->kernel_params_buf32[27] = innerloop_left;
3184
3185 // i think we can get rid of this
3186 if (innerloop_left == 0)
3187 {
3188 puts ("bug, how should this happen????\n");
3189
3190 continue;
3191 }
3192
3193 // initialize amplifiers
3194
3195 if (data.attack_mode == ATTACK_MODE_COMBI)
3196 {
3197 char line_buf[BUFSIZ] = { 0 };
3198
3199 uint i = 0;
3200
3201 while (i < innerloop_left)
3202 {
3203 if (feof (combs_fp)) break;
3204
3205 int line_len = fgetl (combs_fp, line_buf);
3206
3207 if (line_len >= PW_MAX1) continue;
3208
3209 line_len = convert_from_hex (line_buf, line_len);
3210
3211 char *line_buf_new = line_buf;
3212
3213 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3214 {
3215 char rule_buf_out[BLOCK_SIZE] = { 0 };
3216
3217 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3218
3219 if (rule_len_out < 0)
3220 {
3221 data.words_progress_rejected[salt_pos] += pws_cnt;
3222
3223 continue;
3224 }
3225
3226 line_len = rule_len_out;
3227
3228 line_buf_new = rule_buf_out;
3229 }
3230
3231 line_len = MIN (line_len, PW_DICTMAX);
3232
3233 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3234
3235 memcpy (ptr, line_buf_new, line_len);
3236
3237 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3238
3239 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3240 {
3241 uppercase (ptr, line_len);
3242 }
3243
3244 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3245 {
3246 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3247 {
3248 ptr[line_len] = 0x80;
3249 }
3250
3251 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3252 {
3253 ptr[line_len] = 0x01;
3254 }
3255 }
3256
3257 device_param->combs_buf[i].pw_len = line_len;
3258
3259 i++;
3260 }
3261
3262 for (uint j = i; j < innerloop_left; j++)
3263 {
3264 device_param->combs_buf[j].i[0] = 0;
3265 device_param->combs_buf[j].i[1] = 0;
3266 device_param->combs_buf[j].i[2] = 0;
3267 device_param->combs_buf[j].i[3] = 0;
3268 device_param->combs_buf[j].i[4] = 0;
3269 device_param->combs_buf[j].i[5] = 0;
3270 device_param->combs_buf[j].i[6] = 0;
3271 device_param->combs_buf[j].i[7] = 0;
3272
3273 device_param->combs_buf[j].pw_len = 0;
3274 }
3275
3276 innerloop_left = i;
3277 }
3278 else if (data.attack_mode == ATTACK_MODE_BF)
3279 {
3280 u64 off = innerloop_pos;
3281
3282 device_param->kernel_params_mp_r_buf64[3] = off;
3283
3284 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3285 }
3286 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3287 {
3288 u64 off = innerloop_pos;
3289
3290 device_param->kernel_params_mp_buf64[3] = off;
3291
3292 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3293 }
3294 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3295 {
3296 u64 off = innerloop_pos;
3297
3298 device_param->kernel_params_mp_buf64[3] = off;
3299
3300 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3301 }
3302
3303 // copy amplifiers
3304
3305 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3306 {
3307 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);
3308 }
3309 else if (data.attack_mode == ATTACK_MODE_COMBI)
3310 {
3311 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);
3312 }
3313 else if (data.attack_mode == ATTACK_MODE_BF)
3314 {
3315 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);
3316 }
3317 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3318 {
3319 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);
3320 }
3321 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3322 {
3323 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);
3324 }
3325
3326 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3327
3328 if (data.benchmark == 1)
3329 {
3330 for (u32 i = 0; i < data.benchmark_repeats; i++)
3331 {
3332 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3333 }
3334 }
3335
3336 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3337
3338 if (data.devices_status == STATUS_CRACKED) break;
3339 if (data.devices_status == STATUS_ABORTED) break;
3340 if (data.devices_status == STATUS_QUIT) break;
3341
3342 /**
3343 * result
3344 */
3345
3346 hc_thread_mutex_lock (mux_display);
3347
3348 check_cracked (device_param, salt_pos);
3349
3350 hc_thread_mutex_unlock (mux_display);
3351
3352 /**
3353 * progress
3354 */
3355
3356 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3357
3358 if (data.benchmark == 1)
3359 {
3360 perf_sum_all = (perf_sum_all * data.benchmark_repeats) + perf_sum_all;
3361 }
3362
3363 hc_thread_mutex_lock (mux_counter);
3364
3365 data.words_progress_done[salt_pos] += perf_sum_all;
3366
3367 hc_thread_mutex_unlock (mux_counter);
3368
3369 /**
3370 * speed
3371 */
3372
3373 float speed_ms;
3374
3375 hc_timer_get (device_param->timer_speed, speed_ms);
3376
3377 hc_timer_set (&device_param->timer_speed);
3378
3379 hc_thread_mutex_lock (mux_display);
3380
3381 device_param->speed_cnt[speed_pos] = perf_sum_all;
3382
3383 device_param->speed_ms[speed_pos] = speed_ms;
3384
3385 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3386
3387 hc_thread_mutex_unlock (mux_display);
3388
3389 speed_pos++;
3390
3391 if (speed_pos == SPEED_CACHE)
3392 {
3393 speed_pos = 0;
3394 }
3395
3396 /**
3397 * benchmark
3398 */
3399
3400 if (data.benchmark == 1) break;
3401 }
3402 }
3403
3404 device_param->speed_pos = speed_pos;
3405 }
3406
3407 static void load_segment (wl_data_t *wl_data, FILE *fd)
3408 {
3409 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3410
3411 wl_data->pos = 0;
3412
3413 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3414
3415 wl_data->buf[wl_data->cnt] = 0;
3416
3417 if (wl_data->cnt == 0) return;
3418
3419 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3420
3421 while (!feof (fd))
3422 {
3423 if (wl_data->cnt == wl_data->avail)
3424 {
3425 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3426
3427 wl_data->avail += wl_data->incr;
3428 }
3429
3430 const int c = fgetc (fd);
3431
3432 if (c == EOF) break;
3433
3434 wl_data->buf[wl_data->cnt] = (char) c;
3435
3436 wl_data->cnt++;
3437
3438 if (c == '\n') break;
3439 }
3440
3441 // ensure stream ends with a newline
3442
3443 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3444 {
3445 wl_data->cnt++;
3446
3447 wl_data->buf[wl_data->cnt - 1] = '\n';
3448 }
3449
3450 return;
3451 }
3452
3453 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3454 {
3455 char *ptr = buf;
3456
3457 for (u32 i = 0; i < sz; i++, ptr++)
3458 {
3459 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3460
3461 if (i == 7)
3462 {
3463 *off = i;
3464 *len = i;
3465
3466 return;
3467 }
3468
3469 if (*ptr != '\n') continue;
3470
3471 *off = i + 1;
3472
3473 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3474
3475 *len = i;
3476
3477 return;
3478 }
3479
3480 *off = sz;
3481 *len = sz;
3482 }
3483
3484 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3485 {
3486 char *ptr = buf;
3487
3488 for (u32 i = 0; i < sz; i++, ptr++)
3489 {
3490 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3491
3492 if (*ptr != '\n') continue;
3493
3494 *off = i + 1;
3495
3496 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3497
3498 *len = i;
3499
3500 return;
3501 }
3502
3503 *off = sz;
3504 *len = sz;
3505 }
3506
3507 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3508 {
3509 char *ptr = buf;
3510
3511 for (u32 i = 0; i < sz; i++, ptr++)
3512 {
3513 if (*ptr != '\n') continue;
3514
3515 *off = i + 1;
3516
3517 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3518
3519 *len = i;
3520
3521 return;
3522 }
3523
3524 *off = sz;
3525 *len = sz;
3526 }
3527
3528 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3529 {
3530 while (wl_data->pos < wl_data->cnt)
3531 {
3532 uint off;
3533 uint len;
3534
3535 char *ptr = wl_data->buf + wl_data->pos;
3536
3537 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3538
3539 wl_data->pos += off;
3540
3541 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3542 {
3543 char rule_buf_out[BLOCK_SIZE] = { 0 };
3544
3545 int rule_len_out = -1;
3546
3547 if (len < BLOCK_SIZE)
3548 {
3549 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3550 }
3551
3552 if (rule_len_out < 0)
3553 {
3554 continue;
3555 }
3556
3557 if (rule_len_out > PW_MAX)
3558 {
3559 continue;
3560 }
3561 }
3562 else
3563 {
3564 if (len > PW_MAX)
3565 {
3566 continue;
3567 }
3568 }
3569
3570 *out_buf = ptr;
3571 *out_len = len;
3572
3573 return;
3574 }
3575
3576 if (feof (fd))
3577 {
3578 fprintf (stderr, "BUG feof()!!\n");
3579
3580 return;
3581 }
3582
3583 load_segment (wl_data, fd);
3584
3585 get_next_word (wl_data, fd, out_buf, out_len);
3586 }
3587
3588 #ifdef _POSIX
3589 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3590 #endif
3591
3592 #ifdef _WIN
3593 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3594 #endif
3595 {
3596 hc_signal (NULL);
3597
3598 dictstat_t d;
3599
3600 d.cnt = 0;
3601
3602 #ifdef _POSIX
3603 fstat (fileno (fd), &d.stat);
3604 #endif
3605
3606 #ifdef _WIN
3607 _fstat64 (fileno (fd), &d.stat);
3608 #endif
3609
3610 d.stat.st_mode = 0;
3611 d.stat.st_nlink = 0;
3612 d.stat.st_uid = 0;
3613 d.stat.st_gid = 0;
3614 d.stat.st_rdev = 0;
3615 d.stat.st_atime = 0;
3616
3617 #ifdef _POSIX
3618 d.stat.st_blksize = 0;
3619 d.stat.st_blocks = 0;
3620 #endif
3621
3622 if (d.stat.st_size == 0) return 0;
3623
3624 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3625
3626 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3627 {
3628 if (d_cache)
3629 {
3630 u64 cnt = d_cache->cnt;
3631
3632 u64 keyspace = cnt;
3633
3634 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3635 {
3636 keyspace *= data.kernel_rules_cnt;
3637 }
3638 else if (data.attack_kern == ATTACK_KERN_COMBI)
3639 {
3640 keyspace *= data.combs_cnt;
3641 }
3642
3643 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);
3644 if (data.quiet == 0) log_info ("");
3645
3646 hc_signal (sigHandler_default);
3647
3648 return (keyspace);
3649 }
3650 }
3651
3652 time_t now = 0;
3653 time_t prev = 0;
3654
3655 u64 comp = 0;
3656 u64 cnt = 0;
3657 u64 cnt2 = 0;
3658
3659 while (!feof (fd))
3660 {
3661 load_segment (wl_data, fd);
3662
3663 comp += wl_data->cnt;
3664
3665 u32 i = 0;
3666
3667 while (i < wl_data->cnt)
3668 {
3669 u32 len;
3670 u32 off;
3671
3672 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3673
3674 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3675 {
3676 char rule_buf_out[BLOCK_SIZE] = { 0 };
3677
3678 int rule_len_out = -1;
3679
3680 if (len < BLOCK_SIZE)
3681 {
3682 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3683 }
3684
3685 if (rule_len_out < 0)
3686 {
3687 len = PW_MAX1;
3688 }
3689 else
3690 {
3691 len = rule_len_out;
3692 }
3693 }
3694
3695 if (len < PW_MAX1)
3696 {
3697 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3698 {
3699 cnt += data.kernel_rules_cnt;
3700 }
3701 else if (data.attack_kern == ATTACK_KERN_COMBI)
3702 {
3703 cnt += data.combs_cnt;
3704 }
3705
3706 d.cnt++;
3707 }
3708
3709 i += off;
3710
3711 cnt2++;
3712 }
3713
3714 time (&now);
3715
3716 if ((now - prev) == 0) continue;
3717
3718 float percent = (float) comp / (float) d.stat.st_size;
3719
3720 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);
3721
3722 time (&prev);
3723 }
3724
3725 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);
3726 if (data.quiet == 0) log_info ("");
3727
3728 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3729
3730 hc_signal (sigHandler_default);
3731
3732 return (cnt);
3733 }
3734
3735 static void *thread_monitor (void *p)
3736 {
3737 uint runtime_check = 0;
3738 uint remove_check = 0;
3739 uint status_check = 0;
3740 uint restore_check = 0;
3741
3742 uint restore_left = data.restore_timer;
3743 uint remove_left = data.remove_timer;
3744 uint status_left = data.status_timer;
3745
3746 #ifdef HAVE_HWMON
3747 uint hwmon_check = 0;
3748
3749 // these variables are mainly used for fan control (AMD only)
3750
3751 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3752
3753 // temperature controller "loopback" values
3754
3755 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3756 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3757
3758 #ifdef HAVE_ADL
3759 int temp_threshold = 1; // degrees celcius
3760
3761 int fan_speed_min = 15; // in percentage
3762 int fan_speed_max = 100;
3763 #endif // HAVE_ADL
3764
3765 time_t last_temp_check_time;
3766 #endif // HAVE_HWMON
3767
3768 uint sleep_time = 1;
3769
3770 if (data.runtime)
3771 {
3772 runtime_check = 1;
3773 }
3774
3775 if (data.restore_timer)
3776 {
3777 restore_check = 1;
3778 }
3779
3780 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3781 {
3782 remove_check = 1;
3783 }
3784
3785 if (data.status == 1)
3786 {
3787 status_check = 1;
3788 }
3789
3790 #ifdef HAVE_HWMON
3791 if (data.gpu_temp_disable == 0)
3792 {
3793 time (&last_temp_check_time);
3794
3795 hwmon_check = 1;
3796 }
3797 #endif
3798
3799 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3800 {
3801 #ifdef HAVE_HWMON
3802 if (hwmon_check == 0)
3803 #endif
3804 return (p);
3805 }
3806
3807 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3808 {
3809 hc_sleep (sleep_time);
3810
3811 if (data.devices_status != STATUS_RUNNING) continue;
3812
3813 #ifdef HAVE_HWMON
3814 if (hwmon_check == 1)
3815 {
3816 hc_thread_mutex_lock (mux_adl);
3817
3818 time_t temp_check_time;
3819
3820 time (&temp_check_time);
3821
3822 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3823
3824 if (Ta == 0) Ta = 1;
3825
3826 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3827 {
3828 hc_device_param_t *device_param = &data.devices_param[device_id];
3829
3830 if (device_param->skipped) continue;
3831
3832 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3833
3834 const int temperature = hm_get_temperature_with_device_id (device_id);
3835
3836 if (temperature > (int) data.gpu_temp_abort)
3837 {
3838 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3839
3840 if (data.devices_status != STATUS_QUIT) myabort ();
3841
3842 break;
3843 }
3844
3845 #ifdef HAVE_ADL
3846 const int gpu_temp_retain = data.gpu_temp_retain;
3847
3848 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3849 {
3850 if (data.hm_device[device_id].fan_supported == 1)
3851 {
3852 int temp_cur = temperature;
3853
3854 int temp_diff_new = gpu_temp_retain - temp_cur;
3855
3856 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3857
3858 // calculate Ta value (time difference in seconds between the last check and this check)
3859
3860 last_temp_check_time = temp_check_time;
3861
3862 float Kp = 1.8;
3863 float Ki = 0.005;
3864 float Kd = 6;
3865
3866 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3867
3868 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);
3869
3870 if (abs (fan_diff_required) >= temp_threshold)
3871 {
3872 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3873
3874 int fan_speed_level = fan_speed_cur;
3875
3876 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3877
3878 int fan_speed_new = fan_speed_level - fan_diff_required;
3879
3880 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3881 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3882
3883 if (fan_speed_new != fan_speed_cur)
3884 {
3885 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3886 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3887
3888 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3889 {
3890 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3891
3892 fan_speed_chgd[device_id] = 1;
3893 }
3894
3895 temp_diff_old[device_id] = temp_diff_new;
3896 }
3897 }
3898 }
3899 }
3900 #endif // HAVE_ADL
3901 }
3902
3903 hc_thread_mutex_unlock (mux_adl);
3904 }
3905 #endif // HAVE_HWMON
3906
3907 if (restore_check == 1)
3908 {
3909 restore_left--;
3910
3911 if (restore_left == 0)
3912 {
3913 if (data.restore_disable == 0) cycle_restore ();
3914
3915 restore_left = data.restore_timer;
3916 }
3917 }
3918
3919 if ((runtime_check == 1) && (data.runtime_start > 0))
3920 {
3921 time_t runtime_cur;
3922
3923 time (&runtime_cur);
3924
3925 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3926
3927 if (runtime_left <= 0)
3928 {
3929 if (data.benchmark == 0)
3930 {
3931 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3932 }
3933
3934 if (data.devices_status != STATUS_QUIT) myabort ();
3935 }
3936 }
3937
3938 if (remove_check == 1)
3939 {
3940 remove_left--;
3941
3942 if (remove_left == 0)
3943 {
3944 if (data.digests_saved != data.digests_done)
3945 {
3946 data.digests_saved = data.digests_done;
3947
3948 save_hash ();
3949 }
3950
3951 remove_left = data.remove_timer;
3952 }
3953 }
3954
3955 if (status_check == 1)
3956 {
3957 status_left--;
3958
3959 if (status_left == 0)
3960 {
3961 hc_thread_mutex_lock (mux_display);
3962
3963 if (data.quiet == 0) clear_prompt ();
3964
3965 if (data.quiet == 0) log_info ("");
3966
3967 status_display ();
3968
3969 if (data.quiet == 0) log_info ("");
3970
3971 hc_thread_mutex_unlock (mux_display);
3972
3973 status_left = data.status_timer;
3974 }
3975 }
3976 }
3977
3978 #ifdef HAVE_HWMON
3979 myfree (fan_speed_chgd);
3980
3981 myfree (temp_diff_old);
3982 myfree (temp_diff_sum);
3983 #endif
3984
3985 p = NULL;
3986
3987 return (p);
3988 }
3989
3990 static void *thread_outfile_remove (void *p)
3991 {
3992 // some hash-dependent constants
3993 char *outfile_dir = data.outfile_check_directory;
3994 uint dgst_size = data.dgst_size;
3995 uint isSalted = data.isSalted;
3996 uint esalt_size = data.esalt_size;
3997 uint hash_mode = data.hash_mode;
3998
3999 uint outfile_check_timer = data.outfile_check_timer;
4000
4001 char separator = data.separator;
4002
4003 // some hash-dependent functions
4004 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4005 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4006
4007 // buffers
4008 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4009
4010 hash_buf.digest = mymalloc (dgst_size);
4011
4012 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4013
4014 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4015
4016 uint digest_buf[64] = { 0 };
4017
4018 outfile_data_t *out_info = NULL;
4019
4020 char **out_files = NULL;
4021
4022 time_t folder_mtime = 0;
4023
4024 int out_cnt = 0;
4025
4026 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4027
4028 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4029 {
4030 hc_sleep (1);
4031
4032 if (data.devices_status != STATUS_RUNNING) continue;
4033
4034 check_left--;
4035
4036 if (check_left == 0)
4037 {
4038 struct stat outfile_check_stat;
4039
4040 if (stat (outfile_dir, &outfile_check_stat) == 0)
4041 {
4042 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4043
4044 if (is_dir == 1)
4045 {
4046 if (outfile_check_stat.st_mtime > folder_mtime)
4047 {
4048 char **out_files_new = scan_directory (outfile_dir);
4049
4050 int out_cnt_new = count_dictionaries (out_files_new);
4051
4052 outfile_data_t *out_info_new = NULL;
4053
4054 if (out_cnt_new > 0)
4055 {
4056 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4057
4058 for (int i = 0; i < out_cnt_new; i++)
4059 {
4060 out_info_new[i].file_name = out_files_new[i];
4061
4062 // check if there are files that we have seen/checked before (and not changed)
4063
4064 for (int j = 0; j < out_cnt; j++)
4065 {
4066 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4067 {
4068 struct stat outfile_stat;
4069
4070 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4071 {
4072 if (outfile_stat.st_ctime == out_info[j].ctime)
4073 {
4074 out_info_new[i].ctime = out_info[j].ctime;
4075 out_info_new[i].seek = out_info[j].seek;
4076 }
4077 }
4078 }
4079 }
4080 }
4081 }
4082
4083 local_free (out_info);
4084 local_free (out_files);
4085
4086 out_files = out_files_new;
4087 out_cnt = out_cnt_new;
4088 out_info = out_info_new;
4089
4090 folder_mtime = outfile_check_stat.st_mtime;
4091 }
4092
4093 for (int j = 0; j < out_cnt; j++)
4094 {
4095 FILE *fp = fopen (out_info[j].file_name, "rb");
4096
4097 if (fp != NULL)
4098 {
4099 //hc_thread_mutex_lock (mux_display);
4100
4101 #ifdef _POSIX
4102 struct stat outfile_stat;
4103
4104 fstat (fileno (fp), &outfile_stat);
4105 #endif
4106
4107 #ifdef _WIN
4108 struct stat64 outfile_stat;
4109
4110 _fstat64 (fileno (fp), &outfile_stat);
4111 #endif
4112
4113 if (outfile_stat.st_ctime > out_info[j].ctime)
4114 {
4115 out_info[j].ctime = outfile_stat.st_ctime;
4116 out_info[j].seek = 0;
4117 }
4118
4119 fseek (fp, out_info[j].seek, SEEK_SET);
4120
4121 while (!feof (fp))
4122 {
4123 char line_buf[BUFSIZ] = { 0 };
4124
4125 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
4126
4127 if (ptr == NULL) break;
4128
4129 int line_len = strlen (line_buf);
4130
4131 if (line_len <= 0) continue;
4132
4133 int iter = MAX_CUT_TRIES;
4134
4135 for (uint i = line_len - 1; i && iter; i--, line_len--)
4136 {
4137 if (line_buf[i] != separator) continue;
4138
4139 int parser_status = PARSER_OK;
4140
4141 if ((hash_mode != 2500) && (hash_mode != 6800))
4142 {
4143 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4144 }
4145
4146 uint found = 0;
4147
4148 if (parser_status == PARSER_OK)
4149 {
4150 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4151 {
4152 if (data.salts_shown[salt_pos] == 1) continue;
4153
4154 salt_t *salt_buf = &data.salts_buf[salt_pos];
4155
4156 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4157 {
4158 uint idx = salt_buf->digests_offset + digest_pos;
4159
4160 if (data.digests_shown[idx] == 1) continue;
4161
4162 uint cracked = 0;
4163
4164 if (hash_mode == 6800)
4165 {
4166 if (i == salt_buf->salt_len)
4167 {
4168 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4169 }
4170 }
4171 else if (hash_mode == 2500)
4172 {
4173 // BSSID : MAC1 : MAC2 (:plain)
4174 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4175 {
4176 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4177
4178 if (!cracked) continue;
4179
4180 // now compare MAC1 and MAC2 too, since we have this additional info
4181 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4182 char *mac2_pos = mac1_pos + 12 + 1;
4183
4184 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4185 wpa_t *wpa = &wpas[salt_pos];
4186
4187 uint pke[25] = { 0 };
4188
4189 char *pke_ptr = (char *) pke;
4190
4191 for (uint i = 0; i < 25; i++)
4192 {
4193 pke[i] = byte_swap_32 (wpa->pke[i]);
4194 }
4195
4196 u8 mac1[6] = { 0 };
4197 u8 mac2[6] = { 0 };
4198
4199 memcpy (mac1, pke_ptr + 23, 6);
4200 memcpy (mac2, pke_ptr + 29, 6);
4201
4202 // compare hex string(s) vs binary MAC address(es)
4203
4204 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4205 {
4206 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4207 {
4208 cracked = 0;
4209 break;
4210 }
4211 }
4212
4213 // early skip ;)
4214 if (!cracked) continue;
4215
4216 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4217 {
4218 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4219 {
4220 cracked = 0;
4221 break;
4222 }
4223 }
4224 }
4225 }
4226 else
4227 {
4228 char *digests_buf_ptr = (char *) data.digests_buf;
4229
4230 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4231
4232 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4233 }
4234
4235 if (cracked == 1)
4236 {
4237 found = 1;
4238
4239 data.digests_shown[idx] = 1;
4240
4241 data.digests_done++;
4242
4243 salt_buf->digests_done++;
4244
4245 if (salt_buf->digests_done == salt_buf->digests_cnt)
4246 {
4247 data.salts_shown[salt_pos] = 1;
4248
4249 data.salts_done++;
4250
4251 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4252 }
4253 }
4254 }
4255
4256 if (data.devices_status == STATUS_CRACKED) break;
4257 }
4258 }
4259
4260 if (found) break;
4261
4262 if (data.devices_status == STATUS_CRACKED) break;
4263
4264 iter--;
4265 }
4266
4267 if (data.devices_status == STATUS_CRACKED) break;
4268 }
4269
4270 out_info[j].seek = ftell (fp);
4271
4272 //hc_thread_mutex_unlock (mux_display);
4273
4274 fclose (fp);
4275 }
4276 }
4277 }
4278 }
4279
4280 check_left = outfile_check_timer;
4281 }
4282 }
4283
4284 if (esalt_size) local_free (hash_buf.esalt);
4285
4286 if (isSalted) local_free (hash_buf.salt);
4287
4288 local_free (hash_buf.digest);
4289
4290 local_free (out_info);
4291
4292 local_free (out_files);
4293
4294 p = NULL;
4295
4296 return (p);
4297 }
4298
4299 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4300 {
4301 if (device_param->pws_cnt < device_param->kernel_power)
4302 {
4303 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4304
4305 u8 *ptr = (u8 *) pw->i;
4306
4307 memcpy (ptr, pw_buf, pw_len);
4308
4309 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4310
4311 pw->pw_len = pw_len;
4312
4313 device_param->pws_cnt++;
4314 }
4315 else
4316 {
4317 fprintf (stderr, "BUG pw_add()!!\n");
4318
4319 return;
4320 }
4321 }
4322
4323 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4324 {
4325 hc_thread_mutex_lock (mux_dispatcher);
4326
4327 const u64 words_cur = data.words_cur;
4328 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4329
4330 device_param->words_off = words_cur;
4331
4332 const u64 words_left = words_base - words_cur;
4333
4334 if (allow_div)
4335 {
4336 if (data.kernel_power_all > words_left)
4337 {
4338 if (data.kernel_power_div == 0)
4339 {
4340 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4341 }
4342 }
4343
4344 if (data.kernel_power_div)
4345 {
4346 if (device_param->kernel_power == device_param->kernel_power_user)
4347 {
4348 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4349
4350 if (kernel_power_new < device_param->kernel_power)
4351 {
4352 device_param->kernel_power = kernel_power_new;
4353 }
4354 }
4355 }
4356 }
4357
4358 const uint kernel_power = device_param->kernel_power;
4359
4360 uint work = MIN (words_left, kernel_power);
4361
4362 work = MIN (work, max);
4363
4364 data.words_cur += work;
4365
4366 hc_thread_mutex_unlock (mux_dispatcher);
4367
4368 return work;
4369 }
4370
4371 static void *thread_calc_stdin (void *p)
4372 {
4373 hc_device_param_t *device_param = (hc_device_param_t *) p;
4374
4375 if (device_param->skipped) return NULL;
4376
4377 autotune (device_param);
4378
4379 const uint attack_kern = data.attack_kern;
4380
4381 const uint kernel_power = device_param->kernel_power;
4382
4383 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4384 {
4385 hc_thread_mutex_lock (mux_dispatcher);
4386
4387 if (feof (stdin) != 0)
4388 {
4389 hc_thread_mutex_unlock (mux_dispatcher);
4390
4391 break;
4392 }
4393
4394 uint words_cur = 0;
4395
4396 while (words_cur < kernel_power)
4397 {
4398 char buf[BUFSIZ] = { 0 };
4399
4400 char *line_buf = fgets (buf, sizeof (buf), stdin);
4401
4402 if (line_buf == NULL) break;
4403
4404 uint line_len = in_superchop (line_buf);
4405
4406 line_len = convert_from_hex (line_buf, line_len);
4407
4408 // post-process rule engine
4409
4410 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4411 {
4412 char rule_buf_out[BLOCK_SIZE] = { 0 };
4413
4414 int rule_len_out = -1;
4415
4416 if (line_len < BLOCK_SIZE)
4417 {
4418 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4419 }
4420
4421 if (rule_len_out < 0) continue;
4422
4423 line_buf = rule_buf_out;
4424 line_len = rule_len_out;
4425 }
4426
4427 if (line_len > PW_MAX)
4428 {
4429 continue;
4430 }
4431
4432 if (attack_kern == ATTACK_KERN_STRAIGHT)
4433 {
4434 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4435 {
4436 hc_thread_mutex_lock (mux_counter);
4437
4438 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4439 {
4440 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4441 }
4442
4443 hc_thread_mutex_unlock (mux_counter);
4444
4445 continue;
4446 }
4447 }
4448 else if (attack_kern == ATTACK_KERN_COMBI)
4449 {
4450 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4451 // since we still need to combine the plains
4452
4453 if (line_len > data.pw_max)
4454 {
4455 hc_thread_mutex_lock (mux_counter);
4456
4457 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4458 {
4459 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4460 }
4461
4462 hc_thread_mutex_unlock (mux_counter);
4463
4464 continue;
4465 }
4466 }
4467
4468 pw_add (device_param, (u8 *) line_buf, line_len);
4469
4470 words_cur++;
4471
4472 if (data.devices_status == STATUS_CRACKED) break;
4473 if (data.devices_status == STATUS_ABORTED) break;
4474 if (data.devices_status == STATUS_QUIT) break;
4475 if (data.devices_status == STATUS_BYPASS) break;
4476 }
4477
4478 hc_thread_mutex_unlock (mux_dispatcher);
4479
4480 if (data.devices_status == STATUS_CRACKED) break;
4481 if (data.devices_status == STATUS_ABORTED) break;
4482 if (data.devices_status == STATUS_QUIT) break;
4483 if (data.devices_status == STATUS_BYPASS) break;
4484
4485 // flush
4486
4487 const uint pws_cnt = device_param->pws_cnt;
4488
4489 if (pws_cnt)
4490 {
4491 run_copy (device_param, pws_cnt);
4492
4493 run_cracker (device_param, pws_cnt);
4494
4495 device_param->pws_cnt = 0;
4496
4497 if (attack_kern == ATTACK_KERN_STRAIGHT)
4498 {
4499 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4500 }
4501 else if (attack_kern == ATTACK_KERN_COMBI)
4502 {
4503 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4504 }
4505 }
4506 }
4507
4508 device_param->kernel_accel = 0;
4509 device_param->kernel_loops = 0;
4510
4511 return NULL;
4512 }
4513
4514 static void *thread_calc (void *p)
4515 {
4516 hc_device_param_t *device_param = (hc_device_param_t *) p;
4517
4518 if (device_param->skipped) return NULL;
4519
4520 autotune (device_param);
4521
4522 const uint attack_mode = data.attack_mode;
4523 const uint attack_kern = data.attack_kern;
4524
4525 if (attack_mode == ATTACK_MODE_BF)
4526 {
4527 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4528 {
4529 const uint work = get_work (device_param, -1, true);
4530
4531 if (work == 0) break;
4532
4533 const u64 words_off = device_param->words_off;
4534 const u64 words_fin = words_off + work;
4535
4536 const uint pws_cnt = work;
4537
4538 device_param->pws_cnt = pws_cnt;
4539
4540 if (pws_cnt)
4541 {
4542 run_copy (device_param, pws_cnt);
4543
4544 run_cracker (device_param, pws_cnt);
4545
4546 device_param->pws_cnt = 0;
4547
4548 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4549 }
4550
4551 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4552
4553 if (data.devices_status == STATUS_CRACKED) break;
4554 if (data.devices_status == STATUS_ABORTED) break;
4555 if (data.devices_status == STATUS_QUIT) break;
4556 if (data.devices_status == STATUS_BYPASS) break;
4557
4558 if (data.benchmark == 1) break;
4559
4560 device_param->words_done = words_fin;
4561 }
4562 }
4563 else
4564 {
4565 const uint segment_size = data.segment_size;
4566
4567 char *dictfile = data.dictfile;
4568
4569 if (attack_mode == ATTACK_MODE_COMBI)
4570 {
4571 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4572 {
4573 dictfile = data.dictfile2;
4574 }
4575 }
4576
4577 FILE *fd = fopen (dictfile, "rb");
4578
4579 if (fd == NULL)
4580 {
4581 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4582
4583 return NULL;
4584 }
4585
4586 if (attack_mode == ATTACK_MODE_COMBI)
4587 {
4588 const uint combs_mode = data.combs_mode;
4589
4590 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4591 {
4592 const char *dictfilec = data.dictfile2;
4593
4594 FILE *combs_fp = fopen (dictfilec, "rb");
4595
4596 if (combs_fp == NULL)
4597 {
4598 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4599
4600 fclose (fd);
4601
4602 return NULL;
4603 }
4604
4605 device_param->combs_fp = combs_fp;
4606 }
4607 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4608 {
4609 const char *dictfilec = data.dictfile;
4610
4611 FILE *combs_fp = fopen (dictfilec, "rb");
4612
4613 if (combs_fp == NULL)
4614 {
4615 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4616
4617 fclose (fd);
4618
4619 return NULL;
4620 }
4621
4622 device_param->combs_fp = combs_fp;
4623 }
4624 }
4625
4626 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4627
4628 wl_data->buf = (char *) mymalloc (segment_size);
4629 wl_data->avail = segment_size;
4630 wl_data->incr = segment_size;
4631 wl_data->cnt = 0;
4632 wl_data->pos = 0;
4633
4634 u64 words_cur = 0;
4635
4636 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4637 {
4638 u64 words_off = 0;
4639 u64 words_fin = 0;
4640
4641 bool allow_div = true;
4642
4643 u64 max = -1;
4644
4645 while (max)
4646 {
4647 const uint work = get_work (device_param, max, allow_div);
4648
4649 allow_div = false;
4650
4651 if (work == 0) break;
4652
4653 words_off = device_param->words_off;
4654 words_fin = words_off + work;
4655
4656 char *line_buf;
4657 uint line_len;
4658
4659 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4660
4661 max = 0;
4662
4663 for ( ; words_cur < words_fin; words_cur++)
4664 {
4665 get_next_word (wl_data, fd, &line_buf, &line_len);
4666
4667 line_len = convert_from_hex (line_buf, line_len);
4668
4669 // post-process rule engine
4670
4671 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4672 {
4673 char rule_buf_out[BLOCK_SIZE] = { 0 };
4674
4675 int rule_len_out = -1;
4676
4677 if (line_len < BLOCK_SIZE)
4678 {
4679 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4680 }
4681
4682 if (rule_len_out < 0) continue;
4683
4684 line_buf = rule_buf_out;
4685 line_len = rule_len_out;
4686 }
4687
4688 if (attack_kern == ATTACK_KERN_STRAIGHT)
4689 {
4690 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4691 {
4692 max++;
4693
4694 hc_thread_mutex_lock (mux_counter);
4695
4696 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4697 {
4698 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4699 }
4700
4701 hc_thread_mutex_unlock (mux_counter);
4702
4703 continue;
4704 }
4705 }
4706 else if (attack_kern == ATTACK_KERN_COMBI)
4707 {
4708 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4709 // since we still need to combine the plains
4710
4711 if (line_len > data.pw_max)
4712 {
4713 max++;
4714
4715 hc_thread_mutex_lock (mux_counter);
4716
4717 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4718 {
4719 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4720 }
4721
4722 hc_thread_mutex_unlock (mux_counter);
4723
4724 continue;
4725 }
4726 }
4727
4728 pw_add (device_param, (u8 *) line_buf, line_len);
4729
4730 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4731
4732 if (data.devices_status == STATUS_CRACKED) break;
4733 if (data.devices_status == STATUS_ABORTED) break;
4734 if (data.devices_status == STATUS_QUIT) break;
4735 if (data.devices_status == STATUS_BYPASS) break;
4736 }
4737
4738 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4739
4740 if (data.devices_status == STATUS_CRACKED) break;
4741 if (data.devices_status == STATUS_ABORTED) break;
4742 if (data.devices_status == STATUS_QUIT) break;
4743 if (data.devices_status == STATUS_BYPASS) break;
4744 }
4745
4746 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4747
4748 if (data.devices_status == STATUS_CRACKED) break;
4749 if (data.devices_status == STATUS_ABORTED) break;
4750 if (data.devices_status == STATUS_QUIT) break;
4751 if (data.devices_status == STATUS_BYPASS) break;
4752
4753 //
4754 // flush
4755 //
4756
4757 const uint pws_cnt = device_param->pws_cnt;
4758
4759 if (pws_cnt)
4760 {
4761 run_copy (device_param, pws_cnt);
4762
4763 run_cracker (device_param, pws_cnt);
4764
4765 device_param->pws_cnt = 0;
4766
4767 if (attack_kern == ATTACK_KERN_STRAIGHT)
4768 {
4769 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4770 }
4771 else if (attack_kern == ATTACK_KERN_COMBI)
4772 {
4773 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4774 }
4775 }
4776
4777 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4778
4779 if (data.devices_status == STATUS_CRACKED) break;
4780 if (data.devices_status == STATUS_ABORTED) break;
4781 if (data.devices_status == STATUS_QUIT) break;
4782 if (data.devices_status == STATUS_BYPASS) break;
4783
4784 if (words_fin == 0) break;
4785
4786 device_param->words_done = words_fin;
4787 }
4788
4789 if (attack_mode == ATTACK_MODE_COMBI)
4790 {
4791 fclose (device_param->combs_fp);
4792 }
4793
4794 free (wl_data->buf);
4795 free (wl_data);
4796
4797 fclose (fd);
4798 }
4799
4800 device_param->kernel_accel = 0;
4801 device_param->kernel_loops = 0;
4802
4803 return NULL;
4804 }
4805
4806 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4807 {
4808 if (!device_param)
4809 {
4810 log_error ("ERROR: %s : Invalid argument", __func__);
4811
4812 exit (-1);
4813 }
4814
4815 salt_t *salt_buf = &data.salts_buf[salt_pos];
4816
4817 device_param->kernel_params_buf32[24] = salt_pos;
4818 device_param->kernel_params_buf32[27] = 1;
4819 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4820 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4821 device_param->kernel_params_buf32[30] = 0;
4822 device_param->kernel_params_buf32[31] = 1;
4823
4824 char *dictfile_old = data.dictfile;
4825
4826 const char *weak_hash_check = "weak-hash-check";
4827
4828 data.dictfile = (char *) weak_hash_check;
4829
4830 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4831
4832 data.kernel_rules_buf[0].cmds[0] = 0;
4833
4834 /**
4835 * run the kernel
4836 */
4837
4838 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4839 {
4840 run_kernel (KERN_RUN_1, device_param, 1, false);
4841 }
4842 else
4843 {
4844 run_kernel (KERN_RUN_1, device_param, 1, false);
4845
4846 uint loop_step = 16;
4847
4848 const uint iter = salt_buf->salt_iter;
4849
4850 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4851 {
4852 uint loop_left = iter - loop_pos;
4853
4854 loop_left = MIN (loop_left, loop_step);
4855
4856 device_param->kernel_params_buf32[25] = loop_pos;
4857 device_param->kernel_params_buf32[26] = loop_left;
4858
4859 run_kernel (KERN_RUN_2, device_param, 1, false);
4860 }
4861
4862 run_kernel (KERN_RUN_3, device_param, 1, false);
4863 }
4864
4865 /**
4866 * result
4867 */
4868
4869 check_cracked (device_param, salt_pos);
4870
4871 /**
4872 * cleanup
4873 */
4874
4875 device_param->kernel_params_buf32[24] = 0;
4876 device_param->kernel_params_buf32[25] = 0;
4877 device_param->kernel_params_buf32[26] = 0;
4878 device_param->kernel_params_buf32[27] = 0;
4879 device_param->kernel_params_buf32[28] = 0;
4880 device_param->kernel_params_buf32[29] = 0;
4881 device_param->kernel_params_buf32[30] = 0;
4882 device_param->kernel_params_buf32[31] = 0;
4883
4884 data.dictfile = dictfile_old;
4885
4886 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4887 }
4888
4889 // hlfmt hashcat
4890
4891 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4892 {
4893 if (data.username == 0)
4894 {
4895 *hashbuf_pos = line_buf;
4896 *hashbuf_len = line_len;
4897 }
4898 else
4899 {
4900 char *pos = line_buf;
4901 int len = line_len;
4902
4903 for (int i = 0; i < line_len; i++, pos++, len--)
4904 {
4905 if (line_buf[i] == data.separator)
4906 {
4907 pos++;
4908
4909 len--;
4910
4911 break;
4912 }
4913 }
4914
4915 *hashbuf_pos = pos;
4916 *hashbuf_len = len;
4917 }
4918 }
4919
4920 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4921 {
4922 char *pos = NULL;
4923 int len = 0;
4924
4925 int sep_cnt = 0;
4926
4927 for (int i = 0; i < line_len; i++)
4928 {
4929 if (line_buf[i] == data.separator)
4930 {
4931 sep_cnt++;
4932
4933 continue;
4934 }
4935
4936 if (sep_cnt == 0)
4937 {
4938 if (pos == NULL) pos = line_buf + i;
4939
4940 len++;
4941 }
4942 }
4943
4944 *userbuf_pos = pos;
4945 *userbuf_len = len;
4946 }
4947
4948 // hlfmt pwdump
4949
4950 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4951 {
4952 int sep_cnt = 0;
4953
4954 int sep2_len = 0;
4955 int sep3_len = 0;
4956
4957 for (int i = 0; i < line_len; i++)
4958 {
4959 if (line_buf[i] == ':')
4960 {
4961 sep_cnt++;
4962
4963 continue;
4964 }
4965
4966 if (sep_cnt == 2) sep2_len++;
4967 if (sep_cnt == 3) sep3_len++;
4968 }
4969
4970 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4971
4972 return 0;
4973 }
4974
4975 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4976 {
4977 char *pos = NULL;
4978 int len = 0;
4979
4980 int sep_cnt = 0;
4981
4982 for (int i = 0; i < line_len; i++)
4983 {
4984 if (line_buf[i] == ':')
4985 {
4986 sep_cnt++;
4987
4988 continue;
4989 }
4990
4991 if (data.hash_mode == 1000)
4992 {
4993 if (sep_cnt == 3)
4994 {
4995 if (pos == NULL) pos = line_buf + i;
4996
4997 len++;
4998 }
4999 }
5000 else if (data.hash_mode == 3000)
5001 {
5002 if (sep_cnt == 2)
5003 {
5004 if (pos == NULL) pos = line_buf + i;
5005
5006 len++;
5007 }
5008 }
5009 }
5010
5011 *hashbuf_pos = pos;
5012 *hashbuf_len = len;
5013 }
5014
5015 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5016 {
5017 char *pos = NULL;
5018 int len = 0;
5019
5020 int sep_cnt = 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 == 0)
5032 {
5033 if (pos == NULL) pos = line_buf + i;
5034
5035 len++;
5036 }
5037 }
5038
5039 *userbuf_pos = pos;
5040 *userbuf_len = len;
5041 }
5042
5043 // hlfmt passwd
5044
5045 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
5046 {
5047 int sep_cnt = 0;
5048
5049 char sep5_first = 0;
5050 char sep6_first = 0;
5051
5052 for (int i = 0; i < line_len; i++)
5053 {
5054 if (line_buf[i] == ':')
5055 {
5056 sep_cnt++;
5057
5058 continue;
5059 }
5060
5061 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5062 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5063 }
5064
5065 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5066
5067 return 0;
5068 }
5069
5070 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5071 {
5072 char *pos = NULL;
5073 int len = 0;
5074
5075 int sep_cnt = 0;
5076
5077 for (int i = 0; i < line_len; i++)
5078 {
5079 if (line_buf[i] == ':')
5080 {
5081 sep_cnt++;
5082
5083 continue;
5084 }
5085
5086 if (sep_cnt == 1)
5087 {
5088 if (pos == NULL) pos = line_buf + i;
5089
5090 len++;
5091 }
5092 }
5093
5094 *hashbuf_pos = pos;
5095 *hashbuf_len = len;
5096 }
5097
5098 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5099 {
5100 char *pos = NULL;
5101 int len = 0;
5102
5103 int sep_cnt = 0;
5104
5105 for (int i = 0; i < line_len; i++)
5106 {
5107 if (line_buf[i] == ':')
5108 {
5109 sep_cnt++;
5110
5111 continue;
5112 }
5113
5114 if (sep_cnt == 0)
5115 {
5116 if (pos == NULL) pos = line_buf + i;
5117
5118 len++;
5119 }
5120 }
5121
5122 *userbuf_pos = pos;
5123 *userbuf_len = len;
5124 }
5125
5126 // hlfmt shadow
5127
5128 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
5129 {
5130 int sep_cnt = 0;
5131
5132 for (int i = 0; i < line_len; i++)
5133 {
5134 if (line_buf[i] == ':') sep_cnt++;
5135 }
5136
5137 if (sep_cnt == 8) return 1;
5138
5139 return 0;
5140 }
5141
5142 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5143 {
5144 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5145 }
5146
5147 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5148 {
5149 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5150 }
5151
5152 // hlfmt main
5153
5154 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5155 {
5156 switch (hashfile_format)
5157 {
5158 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5159 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5160 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5161 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5162 }
5163 }
5164
5165 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5166 {
5167 switch (hashfile_format)
5168 {
5169 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5170 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5171 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5172 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5173 }
5174 }
5175
5176 static uint hlfmt_detect (FILE *fp, uint max_check)
5177 {
5178 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5179
5180 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5181 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5182
5183 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5184
5185 uint num_check = 0;
5186
5187 while (!feof (fp))
5188 {
5189 char line_buf[BUFSIZ] = { 0 };
5190
5191 int line_len = fgetl (fp, line_buf);
5192
5193 if (line_len == 0) continue;
5194
5195 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5196 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5197 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5198
5199 if (num_check == max_check) break;
5200
5201 num_check++;
5202 }
5203
5204 uint hashlist_format = HLFMT_HASHCAT;
5205
5206 for (int i = 1; i < HLFMTS_CNT; i++)
5207 {
5208 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5209
5210 hashlist_format = i;
5211 }
5212
5213 free (formats_cnt);
5214
5215 return hashlist_format;
5216 }
5217
5218 /**
5219 * some further helper function
5220 */
5221
5222 // wrapper around mymalloc for ADL
5223
5224 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5225 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5226 {
5227 return mymalloc (iSize);
5228 }
5229 #endif
5230
5231 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)
5232 {
5233 u64 collisions = 0;
5234
5235 const uint dgst_pos0 = data.dgst_pos0;
5236 const uint dgst_pos1 = data.dgst_pos1;
5237 const uint dgst_pos2 = data.dgst_pos2;
5238 const uint dgst_pos3 = data.dgst_pos3;
5239
5240 memset (bitmap_a, 0, bitmap_size);
5241 memset (bitmap_b, 0, bitmap_size);
5242 memset (bitmap_c, 0, bitmap_size);
5243 memset (bitmap_d, 0, bitmap_size);
5244
5245 for (uint i = 0; i < digests_cnt; i++)
5246 {
5247 uint *digest_ptr = (uint *) digests_buf_ptr;
5248
5249 digests_buf_ptr += dgst_size;
5250
5251 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5252 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5253 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5254 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5255
5256 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5257 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5258 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5259 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5260
5261 if (bitmap_a[idx0] & val0) collisions++;
5262 if (bitmap_b[idx1] & val1) collisions++;
5263 if (bitmap_c[idx2] & val2) collisions++;
5264 if (bitmap_d[idx3] & val3) collisions++;
5265
5266 bitmap_a[idx0] |= val0;
5267 bitmap_b[idx1] |= val1;
5268 bitmap_c[idx2] |= val2;
5269 bitmap_d[idx3] |= val3;
5270
5271 if (collisions >= collisions_max) return 0x7fffffff;
5272 }
5273
5274 return collisions;
5275 }
5276
5277 /**
5278 * main
5279 */
5280
5281 int main (int argc, char **argv)
5282 {
5283 /**
5284 * To help users a bit
5285 */
5286
5287 char *compute = getenv ("COMPUTE");
5288
5289 if (compute)
5290 {
5291 static char display[100];
5292
5293 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5294
5295 putenv (display);
5296 }
5297 else
5298 {
5299 if (getenv ("DISPLAY") == NULL)
5300 putenv ((char *) "DISPLAY=:0");
5301 }
5302
5303 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5304 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5305
5306 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5307 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5308
5309 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5310 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5311
5312 /**
5313 * Real init
5314 */
5315
5316 memset (&data, 0, sizeof (hc_global_data_t));
5317
5318 time_t proc_start;
5319
5320 time (&proc_start);
5321
5322 data.proc_start = proc_start;
5323
5324 int myargc = argc;
5325 char **myargv = argv;
5326
5327 hc_thread_mutex_init (mux_dispatcher);
5328 hc_thread_mutex_init (mux_counter);
5329 hc_thread_mutex_init (mux_display);
5330 hc_thread_mutex_init (mux_adl);
5331
5332 /**
5333 * commandline parameters
5334 */
5335
5336 uint usage = USAGE;
5337 uint version = VERSION;
5338 uint quiet = QUIET;
5339 uint benchmark = BENCHMARK;
5340 uint benchmark_repeats = BENCHMARK_REPEATS;
5341 uint show = SHOW;
5342 uint left = LEFT;
5343 uint username = USERNAME;
5344 uint remove = REMOVE;
5345 uint remove_timer = REMOVE_TIMER;
5346 u64 skip = SKIP;
5347 u64 limit = LIMIT;
5348 uint keyspace = KEYSPACE;
5349 uint potfile_disable = POTFILE_DISABLE;
5350 uint debug_mode = DEBUG_MODE;
5351 char *debug_file = NULL;
5352 char *induction_dir = NULL;
5353 char *outfile_check_dir = NULL;
5354 uint force = FORCE;
5355 uint runtime = RUNTIME;
5356 uint hash_mode = HASH_MODE;
5357 uint attack_mode = ATTACK_MODE;
5358 uint markov_disable = MARKOV_DISABLE;
5359 uint markov_classic = MARKOV_CLASSIC;
5360 uint markov_threshold = MARKOV_THRESHOLD;
5361 char *markov_hcstat = NULL;
5362 char *outfile = NULL;
5363 uint outfile_format = OUTFILE_FORMAT;
5364 uint outfile_autohex = OUTFILE_AUTOHEX;
5365 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5366 uint restore = RESTORE;
5367 uint restore_timer = RESTORE_TIMER;
5368 uint restore_disable = RESTORE_DISABLE;
5369 uint status = STATUS;
5370 uint status_timer = STATUS_TIMER;
5371 uint status_automat = STATUS_AUTOMAT;
5372 uint loopback = LOOPBACK;
5373 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5374 char *session = NULL;
5375 uint hex_charset = HEX_CHARSET;
5376 uint hex_salt = HEX_SALT;
5377 uint hex_wordlist = HEX_WORDLIST;
5378 uint rp_gen = RP_GEN;
5379 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5380 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5381 uint rp_gen_seed = RP_GEN_SEED;
5382 char *rule_buf_l = (char *) RULE_BUF_L;
5383 char *rule_buf_r = (char *) RULE_BUF_R;
5384 uint increment = INCREMENT;
5385 uint increment_min = INCREMENT_MIN;
5386 uint increment_max = INCREMENT_MAX;
5387 char *cpu_affinity = NULL;
5388 OCL_PTR *ocl = NULL;
5389 char *opencl_devices = NULL;
5390 char *opencl_platforms = NULL;
5391 char *opencl_device_types = NULL;
5392 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5393 char *truecrypt_keyfiles = NULL;
5394 uint workload_profile = WORKLOAD_PROFILE;
5395 uint kernel_accel = KERNEL_ACCEL;
5396 uint kernel_loops = KERNEL_LOOPS;
5397 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5398 #ifdef HAVE_HWMON
5399 uint gpu_temp_abort = GPU_TEMP_ABORT;
5400 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5401 #ifdef HAVE_ADL
5402 uint powertune_enable = POWERTUNE_ENABLE;
5403 #endif
5404 #endif
5405 uint logfile_disable = LOGFILE_DISABLE;
5406 uint segment_size = SEGMENT_SIZE;
5407 uint scrypt_tmto = SCRYPT_TMTO;
5408 char separator = SEPARATOR;
5409 uint bitmap_min = BITMAP_MIN;
5410 uint bitmap_max = BITMAP_MAX;
5411 char *custom_charset_1 = NULL;
5412 char *custom_charset_2 = NULL;
5413 char *custom_charset_3 = NULL;
5414 char *custom_charset_4 = NULL;
5415
5416 #define IDX_HELP 'h'
5417 #define IDX_VERSION 'V'
5418 #define IDX_VERSION_LOWER 'v'
5419 #define IDX_QUIET 0xff02
5420 #define IDX_SHOW 0xff03
5421 #define IDX_LEFT 0xff04
5422 #define IDX_REMOVE 0xff05
5423 #define IDX_REMOVE_TIMER 0xff37
5424 #define IDX_SKIP 's'
5425 #define IDX_LIMIT 'l'
5426 #define IDX_KEYSPACE 0xff35
5427 #define IDX_POTFILE_DISABLE 0xff06
5428 #define IDX_DEBUG_MODE 0xff43
5429 #define IDX_DEBUG_FILE 0xff44
5430 #define IDX_INDUCTION_DIR 0xff46
5431 #define IDX_OUTFILE_CHECK_DIR 0xff47
5432 #define IDX_USERNAME 0xff07
5433 #define IDX_FORCE 0xff08
5434 #define IDX_RUNTIME 0xff09
5435 #define IDX_BENCHMARK 'b'
5436 #define IDX_BENCHMARK_REPEATS 0xff78
5437 #define IDX_HASH_MODE 'm'
5438 #define IDX_ATTACK_MODE 'a'
5439 #define IDX_RP_FILE 'r'
5440 #define IDX_RP_GEN 'g'
5441 #define IDX_RP_GEN_FUNC_MIN 0xff10
5442 #define IDX_RP_GEN_FUNC_MAX 0xff11
5443 #define IDX_RP_GEN_SEED 0xff34
5444 #define IDX_RULE_BUF_L 'j'
5445 #define IDX_RULE_BUF_R 'k'
5446 #define IDX_INCREMENT 'i'
5447 #define IDX_INCREMENT_MIN 0xff12
5448 #define IDX_INCREMENT_MAX 0xff13
5449 #define IDX_OUTFILE 'o'
5450 #define IDX_OUTFILE_FORMAT 0xff14
5451 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5452 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5453 #define IDX_RESTORE 0xff15
5454 #define IDX_RESTORE_DISABLE 0xff27
5455 #define IDX_STATUS 0xff17
5456 #define IDX_STATUS_TIMER 0xff18
5457 #define IDX_STATUS_AUTOMAT 0xff50
5458 #define IDX_LOOPBACK 0xff38
5459 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5460 #define IDX_SESSION 0xff19
5461 #define IDX_HEX_CHARSET 0xff20
5462 #define IDX_HEX_SALT 0xff21
5463 #define IDX_HEX_WORDLIST 0xff40
5464 #define IDX_MARKOV_DISABLE 0xff22
5465 #define IDX_MARKOV_CLASSIC 0xff23
5466 #define IDX_MARKOV_THRESHOLD 't'
5467 #define IDX_MARKOV_HCSTAT 0xff24
5468 #define IDX_CPU_AFFINITY 0xff25
5469 #define IDX_OPENCL_DEVICES 'd'
5470 #define IDX_OPENCL_PLATFORMS 0xff72
5471 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5472 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5473 #define IDX_WORKLOAD_PROFILE 'w'
5474 #define IDX_KERNEL_ACCEL 'n'
5475 #define IDX_KERNEL_LOOPS 'u'
5476 #define IDX_GPU_TEMP_DISABLE 0xff29
5477 #define IDX_GPU_TEMP_ABORT 0xff30
5478 #define IDX_GPU_TEMP_RETAIN 0xff31
5479 #define IDX_POWERTUNE_ENABLE 0xff41
5480 #define IDX_LOGFILE_DISABLE 0xff51
5481 #define IDX_TRUECRYPT_KEYFILES 0xff52
5482 #define IDX_SCRYPT_TMTO 0xff61
5483 #define IDX_SEGMENT_SIZE 'c'
5484 #define IDX_SEPARATOR 'p'
5485 #define IDX_BITMAP_MIN 0xff70
5486 #define IDX_BITMAP_MAX 0xff71
5487 #define IDX_CUSTOM_CHARSET_1 '1'
5488 #define IDX_CUSTOM_CHARSET_2 '2'
5489 #define IDX_CUSTOM_CHARSET_3 '3'
5490 #define IDX_CUSTOM_CHARSET_4 '4'
5491
5492 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5493
5494 struct option long_options[] =
5495 {
5496 {"help", no_argument, 0, IDX_HELP},
5497 {"version", no_argument, 0, IDX_VERSION},
5498 {"quiet", no_argument, 0, IDX_QUIET},
5499 {"show", no_argument, 0, IDX_SHOW},
5500 {"left", no_argument, 0, IDX_LEFT},
5501 {"username", no_argument, 0, IDX_USERNAME},
5502 {"remove", no_argument, 0, IDX_REMOVE},
5503 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5504 {"skip", required_argument, 0, IDX_SKIP},
5505 {"limit", required_argument, 0, IDX_LIMIT},
5506 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5507 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5508 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5509 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5510 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5511 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5512 {"force", no_argument, 0, IDX_FORCE},
5513 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5514 {"benchmark-repeats", required_argument, 0, IDX_BENCHMARK_REPEATS},
5515 {"restore", no_argument, 0, IDX_RESTORE},
5516 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5517 {"status", no_argument, 0, IDX_STATUS},
5518 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5519 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5520 {"loopback", no_argument, 0, IDX_LOOPBACK},
5521 {"weak-hash-threshold",
5522 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5523 {"session", required_argument, 0, IDX_SESSION},
5524 {"runtime", required_argument, 0, IDX_RUNTIME},
5525 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5526 {"generate-rules-func-min",
5527 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5528 {"generate-rules-func-max",
5529 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5530 {"generate-rules-seed",
5531 required_argument, 0, IDX_RP_GEN_SEED},
5532 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5533 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5534 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5535 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5536 {"rules-file", required_argument, 0, IDX_RP_FILE},
5537 {"outfile", required_argument, 0, IDX_OUTFILE},
5538 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5539 {"outfile-autohex-disable",
5540 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5541 {"outfile-check-timer",
5542 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5543 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5544 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5545 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5546 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5547 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5548 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5549 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5550 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5551 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5552 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5553 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5554 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5555 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5556 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5557 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5558 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5559 #ifdef HAVE_HWMON
5560 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5561 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5562 #ifdef HAVE_ADL
5563 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5564 #endif
5565 #endif // HAVE_HWMON
5566 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5567 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5568 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5569 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5570 // deprecated
5571 {"seperator", required_argument, 0, IDX_SEPARATOR},
5572 {"separator", required_argument, 0, IDX_SEPARATOR},
5573 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5574 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5575 {"increment", no_argument, 0, IDX_INCREMENT},
5576 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5577 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5578 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5579 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5580 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5581 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5582
5583 {0, 0, 0, 0}
5584 };
5585
5586 uint rp_files_cnt = 0;
5587
5588 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5589
5590 int option_index = 0;
5591 int c = -1;
5592
5593 optind = 1;
5594 optopt = 0;
5595
5596 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5597 {
5598 switch (c)
5599 {
5600 case IDX_HELP: usage = 1; break;
5601 case IDX_VERSION:
5602 case IDX_VERSION_LOWER: version = 1; break;
5603 case IDX_RESTORE: restore = 1; break;
5604 case IDX_SESSION: session = optarg; break;
5605 case IDX_SHOW: show = 1; break;
5606 case IDX_LEFT: left = 1; break;
5607 case '?': return (-1);
5608 }
5609 }
5610
5611 if (optopt != 0)
5612 {
5613 log_error ("ERROR: Invalid argument specified");
5614
5615 return (-1);
5616 }
5617
5618 /**
5619 * exit functions
5620 */
5621
5622 if (version)
5623 {
5624 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5625
5626 return (0);
5627 }
5628
5629 if (usage)
5630 {
5631 usage_big_print (PROGNAME);
5632
5633 return (0);
5634 }
5635
5636 /**
5637 * session needs to be set, always!
5638 */
5639
5640 if (session == NULL) session = (char *) PROGNAME;
5641
5642 /**
5643 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5644 */
5645
5646 char *exec_path = get_exec_path ();
5647
5648 #ifdef LINUX
5649
5650 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5651 char *resolved_exec_path = realpath (exec_path, NULL);
5652
5653 char *install_dir = get_install_dir (resolved_exec_path);
5654 char *profile_dir = NULL;
5655 char *session_dir = NULL;
5656 char *shared_dir = NULL;
5657
5658 if (strcmp (install_dir, resolved_install_folder) == 0)
5659 {
5660 struct passwd *pw = getpwuid (getuid ());
5661
5662 const char *homedir = pw->pw_dir;
5663
5664 profile_dir = get_profile_dir (homedir);
5665 session_dir = get_session_dir (profile_dir);
5666 shared_dir = strdup (SHARED_FOLDER);
5667
5668 mkdir (profile_dir, 0700);
5669 mkdir (session_dir, 0700);
5670 }
5671 else
5672 {
5673 profile_dir = install_dir;
5674 session_dir = install_dir;
5675 shared_dir = install_dir;
5676 }
5677
5678 myfree (resolved_install_folder);
5679 myfree (resolved_exec_path);
5680
5681 #else
5682
5683 char *install_dir = get_install_dir (exec_path);
5684 char *profile_dir = install_dir;
5685 char *session_dir = install_dir;
5686 char *shared_dir = install_dir;
5687
5688 #endif
5689
5690 data.install_dir = install_dir;
5691 data.profile_dir = profile_dir;
5692 data.session_dir = session_dir;
5693 data.shared_dir = shared_dir;
5694
5695 myfree (exec_path);
5696
5697 /**
5698 * kernel cache, we need to make sure folder exist
5699 */
5700
5701 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5702
5703 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5704
5705 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5706
5707 mkdir (kernels_folder, 0700);
5708
5709 myfree (kernels_folder);
5710
5711 /**
5712 * session
5713 */
5714
5715 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5716
5717 data.session = session;
5718
5719 char *eff_restore_file = (char *) mymalloc (session_size);
5720 char *new_restore_file = (char *) mymalloc (session_size);
5721
5722 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5723 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5724
5725 data.eff_restore_file = eff_restore_file;
5726 data.new_restore_file = new_restore_file;
5727
5728 if (((show == 1) || (left == 1)) && (restore == 1))
5729 {
5730 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5731 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5732
5733 return (-1);
5734 }
5735
5736 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5737 if ((show == 1) || (left == 1))
5738 {
5739 restore_disable = 1;
5740
5741 restore = 0;
5742 }
5743
5744 data.restore_disable = restore_disable;
5745
5746 restore_data_t *rd = init_restore (argc, argv);
5747
5748 data.rd = rd;
5749
5750 /**
5751 * restore file
5752 */
5753
5754 if (restore == 1)
5755 {
5756 read_restore (eff_restore_file, rd);
5757
5758 if (rd->version_bin < RESTORE_MIN)
5759 {
5760 log_error ("ERROR: Incompatible restore-file version");
5761
5762 return (-1);
5763 }
5764
5765 myargc = rd->argc;
5766 myargv = rd->argv;
5767
5768 #ifdef _POSIX
5769 rd->pid = getpid ();
5770 #elif _WIN
5771 rd->pid = GetCurrentProcessId ();
5772 #endif
5773 }
5774
5775 uint hash_mode_chgd = 0;
5776 uint runtime_chgd = 0;
5777 uint kernel_loops_chgd = 0;
5778 uint kernel_accel_chgd = 0;
5779 uint attack_mode_chgd = 0;
5780 uint outfile_format_chgd = 0;
5781 uint rp_gen_seed_chgd = 0;
5782 uint remove_timer_chgd = 0;
5783 uint increment_min_chgd = 0;
5784 uint increment_max_chgd = 0;
5785 uint workload_profile_chgd = 0;
5786 uint opencl_vector_width_chgd = 0;
5787
5788 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5789 uint gpu_temp_retain_chgd = 0;
5790 uint gpu_temp_abort_chgd = 0;
5791 #endif
5792
5793 optind = 1;
5794 optopt = 0;
5795 option_index = 0;
5796
5797 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5798 {
5799 switch (c)
5800 {
5801 //case IDX_HELP: usage = 1; break;
5802 //case IDX_VERSION: version = 1; break;
5803 //case IDX_RESTORE: restore = 1; break;
5804 case IDX_QUIET: quiet = 1; break;
5805 //case IDX_SHOW: show = 1; break;
5806 case IDX_SHOW: break;
5807 //case IDX_LEFT: left = 1; break;
5808 case IDX_LEFT: break;
5809 case IDX_USERNAME: username = 1; break;
5810 case IDX_REMOVE: remove = 1; break;
5811 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5812 remove_timer_chgd = 1; break;
5813 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5814 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5815 case IDX_DEBUG_FILE: debug_file = optarg; break;
5816 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5817 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5818 case IDX_FORCE: force = 1; break;
5819 case IDX_SKIP: skip = atoll (optarg); break;
5820 case IDX_LIMIT: limit = atoll (optarg); break;
5821 case IDX_KEYSPACE: keyspace = 1; break;
5822 case IDX_BENCHMARK: benchmark = 1; break;
5823 case IDX_BENCHMARK_REPEATS: benchmark_repeats = atoi (optarg); break;
5824 case IDX_RESTORE: break;
5825 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5826 case IDX_STATUS: status = 1; break;
5827 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5828 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5829 case IDX_LOOPBACK: loopback = 1; break;
5830 case IDX_WEAK_HASH_THRESHOLD:
5831 weak_hash_threshold = atoi (optarg); break;
5832 //case IDX_SESSION: session = optarg; break;
5833 case IDX_SESSION: break;
5834 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5835 hash_mode_chgd = 1; break;
5836 case IDX_RUNTIME: runtime = atoi (optarg);
5837 runtime_chgd = 1; break;
5838 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5839 attack_mode_chgd = 1; break;
5840 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5841 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5842 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5843 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5844 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5845 rp_gen_seed_chgd = 1; break;
5846 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5847 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5848 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5849 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5850 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5851 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5852 case IDX_OUTFILE: outfile = optarg; break;
5853 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5854 outfile_format_chgd = 1; break;
5855 case IDX_OUTFILE_AUTOHEX_DISABLE:
5856 outfile_autohex = 0; break;
5857 case IDX_OUTFILE_CHECK_TIMER:
5858 outfile_check_timer = atoi (optarg); break;
5859 case IDX_HEX_CHARSET: hex_charset = 1; break;
5860 case IDX_HEX_SALT: hex_salt = 1; break;
5861 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5862 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5863 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5864 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5865 case IDX_OPENCL_DEVICE_TYPES:
5866 opencl_device_types = optarg; break;
5867 case IDX_OPENCL_VECTOR_WIDTH:
5868 opencl_vector_width = atoi (optarg);
5869 opencl_vector_width_chgd = 1; break;
5870 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5871 workload_profile_chgd = 1; break;
5872 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5873 kernel_accel_chgd = 1; break;
5874 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5875 kernel_loops_chgd = 1; break;
5876 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5877 #ifdef HAVE_HWMON
5878 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5879 #ifdef HAVE_ADL
5880 gpu_temp_abort_chgd = 1;
5881 #endif
5882 break;
5883 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5884 #ifdef HAVE_ADL
5885 gpu_temp_retain_chgd = 1;
5886 #endif
5887 break;
5888 #ifdef HAVE_ADL
5889 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5890 #endif
5891 #endif // HAVE_HWMON
5892 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5893 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5894 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5895 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5896 case IDX_SEPARATOR: separator = optarg[0]; break;
5897 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5898 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5899 case IDX_INCREMENT: increment = 1; break;
5900 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5901 increment_min_chgd = 1; break;
5902 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5903 increment_max_chgd = 1; break;
5904 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5905 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5906 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5907 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5908
5909 default:
5910 log_error ("ERROR: Invalid argument specified");
5911 return (-1);
5912 }
5913 }
5914
5915 if (optopt != 0)
5916 {
5917 log_error ("ERROR: Invalid argument specified");
5918
5919 return (-1);
5920 }
5921
5922 /**
5923 * Inform user things getting started,
5924 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5925 * - we do not need to check algorithm_pos
5926 */
5927
5928 if (quiet == 0)
5929 {
5930 if (benchmark == 1)
5931 {
5932 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5933
5934 log_info ("");
5935 }
5936 else if (restore == 1)
5937 {
5938 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5939
5940 log_info ("");
5941 }
5942 else
5943 {
5944 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5945
5946 log_info ("");
5947 }
5948 }
5949
5950 /**
5951 * sanity check
5952 */
5953
5954 if (attack_mode > 7)
5955 {
5956 log_error ("ERROR: Invalid attack-mode specified");
5957
5958 return (-1);
5959 }
5960
5961 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5962 {
5963 log_error ("ERROR: Invalid runtime specified");
5964
5965 return (-1);
5966 }
5967
5968 if (hash_mode_chgd && hash_mode > 13100) // just added to remove compiler warnings for hash_mode_chgd
5969 {
5970 log_error ("ERROR: Invalid hash-type specified");
5971
5972 return (-1);
5973 }
5974
5975 // renamed hash modes
5976
5977 if (hash_mode_chgd)
5978 {
5979 int n = -1;
5980
5981 switch (hash_mode)
5982 {
5983 case 123: n = 124;
5984 break;
5985 }
5986
5987 if (n >= 0)
5988 {
5989 log_error ("Old -m specified, use -m %d instead", n);
5990
5991 return (-1);
5992 }
5993 }
5994
5995 if (username == 1)
5996 {
5997 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5998 {
5999 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6000
6001 return (-1);
6002 }
6003 }
6004
6005 if (outfile_format > 16)
6006 {
6007 log_error ("ERROR: Invalid outfile-format specified");
6008
6009 return (-1);
6010 }
6011
6012 if (left == 1)
6013 {
6014 if (outfile_format_chgd == 1)
6015 {
6016 if (outfile_format > 1)
6017 {
6018 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6019
6020 return (-1);
6021 }
6022 }
6023 else
6024 {
6025 outfile_format = OUTFILE_FMT_HASH;
6026 }
6027 }
6028
6029 if (show == 1)
6030 {
6031 if (outfile_format_chgd == 1)
6032 {
6033 if ((outfile_format > 7) && (outfile_format < 16))
6034 {
6035 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6036
6037 return (-1);
6038 }
6039 }
6040 }
6041
6042 if (increment_min < INCREMENT_MIN)
6043 {
6044 log_error ("ERROR: Invalid increment-min specified");
6045
6046 return (-1);
6047 }
6048
6049 if (increment_max > INCREMENT_MAX)
6050 {
6051 log_error ("ERROR: Invalid increment-max specified");
6052
6053 return (-1);
6054 }
6055
6056 if (increment_min > increment_max)
6057 {
6058 log_error ("ERROR: Invalid increment-min specified");
6059
6060 return (-1);
6061 }
6062
6063 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6064 {
6065 log_error ("ERROR: increment is not allowed in attack-mode 0");
6066
6067 return (-1);
6068 }
6069
6070 if ((increment == 0) && (increment_min_chgd == 1))
6071 {
6072 log_error ("ERROR: increment-min is only supported together with increment switch");
6073
6074 return (-1);
6075 }
6076
6077 if ((increment == 0) && (increment_max_chgd == 1))
6078 {
6079 log_error ("ERROR: increment-max is only supported together with increment switch");
6080
6081 return (-1);
6082 }
6083
6084 if (rp_files_cnt && rp_gen)
6085 {
6086 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6087
6088 return (-1);
6089 }
6090
6091 if (rp_files_cnt || rp_gen)
6092 {
6093 if (attack_mode != ATTACK_MODE_STRAIGHT)
6094 {
6095 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6096
6097 return (-1);
6098 }
6099 }
6100
6101 if (rp_gen_func_min > rp_gen_func_max)
6102 {
6103 log_error ("ERROR: Invalid rp-gen-func-min specified");
6104
6105 return (-1);
6106 }
6107
6108 if (kernel_accel_chgd == 1)
6109 {
6110 if (kernel_accel < 1)
6111 {
6112 log_error ("ERROR: Invalid kernel-accel specified");
6113
6114 return (-1);
6115 }
6116
6117 if (kernel_accel > 1024)
6118 {
6119 log_error ("ERROR: Invalid kernel-accel specified");
6120
6121 return (-1);
6122 }
6123 }
6124
6125 if (kernel_loops_chgd == 1)
6126 {
6127 if (kernel_loops < 1)
6128 {
6129 log_error ("ERROR: Invalid kernel-loops specified");
6130
6131 return (-1);
6132 }
6133
6134 if (kernel_loops > 1024)
6135 {
6136 log_error ("ERROR: Invalid kernel-loops specified");
6137
6138 return (-1);
6139 }
6140 }
6141
6142 if ((workload_profile < 1) || (workload_profile > 3))
6143 {
6144 log_error ("ERROR: workload-profile %i not available", workload_profile);
6145
6146 return (-1);
6147 }
6148
6149 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6150 {
6151 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6152
6153 return (-1);
6154 }
6155
6156 if (show == 1 || left == 1)
6157 {
6158 attack_mode = ATTACK_MODE_NONE;
6159
6160 if (remove == 1)
6161 {
6162 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6163
6164 return (-1);
6165 }
6166
6167 if (potfile_disable == 1)
6168 {
6169 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6170
6171 return (-1);
6172 }
6173 }
6174
6175 uint attack_kern = ATTACK_KERN_NONE;
6176
6177 switch (attack_mode)
6178 {
6179 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6180 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6181 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6182 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6183 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6184 }
6185
6186 if (benchmark == 0)
6187 {
6188 if (keyspace == 1)
6189 {
6190 int num_additional_params = 1;
6191
6192 if (attack_kern == ATTACK_KERN_COMBI)
6193 {
6194 num_additional_params = 2;
6195 }
6196
6197 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6198
6199 if (keyspace_wordlist_specified == 0) optind--;
6200 }
6201
6202 if (attack_kern == ATTACK_KERN_NONE)
6203 {
6204 if ((optind + 1) != myargc)
6205 {
6206 usage_mini_print (myargv[0]);
6207
6208 return (-1);
6209 }
6210 }
6211 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6212 {
6213 if ((optind + 1) > myargc)
6214 {
6215 usage_mini_print (myargv[0]);
6216
6217 return (-1);
6218 }
6219 }
6220 else if (attack_kern == ATTACK_KERN_COMBI)
6221 {
6222 if ((optind + 3) != myargc)
6223 {
6224 usage_mini_print (myargv[0]);
6225
6226 return (-1);
6227 }
6228 }
6229 else if (attack_kern == ATTACK_KERN_BF)
6230 {
6231 if ((optind + 1) > myargc)
6232 {
6233 usage_mini_print (myargv[0]);
6234
6235 return (-1);
6236 }
6237 }
6238 else
6239 {
6240 usage_mini_print (myargv[0]);
6241
6242 return (-1);
6243 }
6244 }
6245 else
6246 {
6247 if (myargv[optind] != 0)
6248 {
6249 log_error ("ERROR: Invalid argument for benchmark mode specified");
6250
6251 return (-1);
6252 }
6253
6254 if (attack_mode_chgd == 1)
6255 {
6256 if (attack_mode != ATTACK_MODE_BF)
6257 {
6258 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6259
6260 return (-1);
6261 }
6262 }
6263 }
6264
6265 if (skip != 0 && limit != 0)
6266 {
6267 limit += skip;
6268 }
6269
6270 if (keyspace == 1)
6271 {
6272 if (show == 1)
6273 {
6274 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6275
6276 return (-1);
6277 }
6278 else if (left == 1)
6279 {
6280 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6281
6282 return (-1);
6283 }
6284
6285 potfile_disable = 1;
6286
6287 restore_disable = 1;
6288
6289 restore = 0;
6290
6291 weak_hash_threshold = 0;
6292
6293 quiet = 1;
6294 }
6295
6296 if (remove_timer_chgd == 1)
6297 {
6298 if (remove == 0)
6299 {
6300 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6301
6302 return (-1);
6303 }
6304
6305 if (remove_timer < 1)
6306 {
6307 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6308
6309 return (-1);
6310 }
6311 }
6312
6313 if (loopback == 1)
6314 {
6315 if (attack_mode == ATTACK_MODE_BF)
6316 {
6317 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6318
6319 return (-1);
6320 }
6321 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6322 {
6323 if ((rp_files_cnt == 0) && (rp_gen == 0))
6324 {
6325 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6326
6327 return (-1);
6328 }
6329 }
6330 }
6331
6332 if (debug_mode > 0)
6333 {
6334 if (attack_mode != ATTACK_MODE_STRAIGHT)
6335 {
6336 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6337
6338 return (-1);
6339 }
6340
6341 if ((rp_files_cnt == 0) && (rp_gen == 0))
6342 {
6343 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6344
6345 return (-1);
6346 }
6347 }
6348
6349 if (debug_mode > 4)
6350 {
6351 log_error ("ERROR: Invalid debug-mode specified");
6352
6353 return (-1);
6354 }
6355
6356 if (debug_file != NULL)
6357 {
6358 if (debug_mode < 1)
6359 {
6360 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6361
6362 return (-1);
6363 }
6364 }
6365
6366 if (induction_dir != NULL)
6367 {
6368 if (attack_mode == ATTACK_MODE_BF)
6369 {
6370 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6371
6372 return (-1);
6373 }
6374 }
6375
6376 if (attack_mode != ATTACK_MODE_STRAIGHT)
6377 {
6378 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6379 {
6380 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6381
6382 return (-1);
6383 }
6384
6385 weak_hash_threshold = 0;
6386 }
6387
6388 /**
6389 * induction directory
6390 */
6391
6392 char *induction_directory = NULL;
6393
6394 if (attack_mode != ATTACK_MODE_BF)
6395 {
6396 if (induction_dir == NULL)
6397 {
6398 induction_directory = (char *) mymalloc (session_size);
6399
6400 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6401
6402 // create induction folder if it does not already exist
6403
6404 if (keyspace == 0)
6405 {
6406 if (rmdir (induction_directory) == -1)
6407 {
6408 if (errno == ENOENT)
6409 {
6410 // good, we can ignore
6411 }
6412 else if (errno == ENOTEMPTY)
6413 {
6414 char *induction_directory_mv = (char *) mymalloc (session_size);
6415
6416 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6417
6418 if (rename (induction_directory, induction_directory_mv) != 0)
6419 {
6420 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6421
6422 return (-1);
6423 }
6424 }
6425 else
6426 {
6427 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6428
6429 return (-1);
6430 }
6431 }
6432
6433 if (mkdir (induction_directory, 0700) == -1)
6434 {
6435 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6436
6437 return (-1);
6438 }
6439 }
6440 }
6441 else
6442 {
6443 induction_directory = induction_dir;
6444 }
6445 }
6446
6447 data.induction_directory = induction_directory;
6448
6449 /**
6450 * loopback
6451 */
6452
6453 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6454
6455 char *loopback_file = (char *) mymalloc (loopback_size);
6456
6457 /**
6458 * tuning db
6459 */
6460
6461 char tuning_db_file[256] = { 0 };
6462
6463 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6464
6465 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6466
6467 /**
6468 * outfile-check directory
6469 */
6470
6471 char *outfile_check_directory = NULL;
6472
6473 if (outfile_check_dir == NULL)
6474 {
6475 outfile_check_directory = (char *) mymalloc (session_size);
6476
6477 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6478 }
6479 else
6480 {
6481 outfile_check_directory = outfile_check_dir;
6482 }
6483
6484 data.outfile_check_directory = outfile_check_directory;
6485
6486 if (keyspace == 0)
6487 {
6488 struct stat outfile_check_stat;
6489
6490 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6491 {
6492 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6493
6494 if (is_dir == 0)
6495 {
6496 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6497
6498 return (-1);
6499 }
6500 }
6501 else if (outfile_check_dir == NULL)
6502 {
6503 if (mkdir (outfile_check_directory, 0700) == -1)
6504 {
6505 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6506
6507 return (-1);
6508 }
6509 }
6510 }
6511
6512 /**
6513 * special other stuff
6514 */
6515
6516 if (hash_mode == 9710)
6517 {
6518 outfile_format = 5;
6519 outfile_format_chgd = 1;
6520 }
6521
6522 if (hash_mode == 9810)
6523 {
6524 outfile_format = 5;
6525 outfile_format_chgd = 1;
6526 }
6527
6528 if (hash_mode == 10410)
6529 {
6530 outfile_format = 5;
6531 outfile_format_chgd = 1;
6532 }
6533
6534 /**
6535 * store stuff
6536 */
6537
6538 data.hash_mode = hash_mode;
6539 data.restore = restore;
6540 data.restore_timer = restore_timer;
6541 data.restore_disable = restore_disable;
6542 data.status = status;
6543 data.status_timer = status_timer;
6544 data.status_automat = status_automat;
6545 data.loopback = loopback;
6546 data.runtime = runtime;
6547 data.remove = remove;
6548 data.remove_timer = remove_timer;
6549 data.debug_mode = debug_mode;
6550 data.debug_file = debug_file;
6551 data.username = username;
6552 data.quiet = quiet;
6553 data.outfile = outfile;
6554 data.outfile_format = outfile_format;
6555 data.outfile_autohex = outfile_autohex;
6556 data.hex_charset = hex_charset;
6557 data.hex_salt = hex_salt;
6558 data.hex_wordlist = hex_wordlist;
6559 data.separator = separator;
6560 data.rp_files = rp_files;
6561 data.rp_files_cnt = rp_files_cnt;
6562 data.rp_gen = rp_gen;
6563 data.rp_gen_seed = rp_gen_seed;
6564 data.force = force;
6565 data.benchmark = benchmark;
6566 data.benchmark_repeats = benchmark_repeats;
6567 data.skip = skip;
6568 data.limit = limit;
6569 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6570 data.powertune_enable = powertune_enable;
6571 #endif
6572 data.logfile_disable = logfile_disable;
6573 data.truecrypt_keyfiles = truecrypt_keyfiles;
6574 data.scrypt_tmto = scrypt_tmto;
6575 data.workload_profile = workload_profile;
6576
6577 /**
6578 * cpu affinity
6579 */
6580
6581 if (cpu_affinity)
6582 {
6583 set_cpu_affinity (cpu_affinity);
6584 }
6585
6586 if (rp_gen_seed_chgd == 0)
6587 {
6588 srand (proc_start);
6589 }
6590 else
6591 {
6592 srand (rp_gen_seed);
6593 }
6594
6595 /**
6596 * logfile init
6597 */
6598
6599 if (logfile_disable == 0)
6600 {
6601 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6602
6603 char *logfile = (char *) mymalloc (logfile_size);
6604
6605 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6606
6607 data.logfile = logfile;
6608
6609 char *topid = logfile_generate_topid ();
6610
6611 data.topid = topid;
6612 }
6613
6614 // logfile_append() checks for logfile_disable internally to make it easier from here
6615
6616 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6617 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6618 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6619 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6620 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6621 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6622 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6623 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6624 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6625 #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));
6626
6627 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6628 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6629 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6630 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6631 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6632 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6633 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6634 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6635
6636 logfile_top_msg ("START");
6637
6638 logfile_top_uint (attack_mode);
6639 logfile_top_uint (attack_kern);
6640 logfile_top_uint (benchmark);
6641 logfile_top_uint (benchmark_repeats);
6642 logfile_top_uint (bitmap_min);
6643 logfile_top_uint (bitmap_max);
6644 logfile_top_uint (debug_mode);
6645 logfile_top_uint (force);
6646 logfile_top_uint (kernel_accel);
6647 logfile_top_uint (kernel_loops);
6648 logfile_top_uint (gpu_temp_disable);
6649 #ifdef HAVE_HWMON
6650 logfile_top_uint (gpu_temp_abort);
6651 logfile_top_uint (gpu_temp_retain);
6652 #endif
6653 logfile_top_uint (hash_mode);
6654 logfile_top_uint (hex_charset);
6655 logfile_top_uint (hex_salt);
6656 logfile_top_uint (hex_wordlist);
6657 logfile_top_uint (increment);
6658 logfile_top_uint (increment_max);
6659 logfile_top_uint (increment_min);
6660 logfile_top_uint (keyspace);
6661 logfile_top_uint (left);
6662 logfile_top_uint (logfile_disable);
6663 logfile_top_uint (loopback);
6664 logfile_top_uint (markov_classic);
6665 logfile_top_uint (markov_disable);
6666 logfile_top_uint (markov_threshold);
6667 logfile_top_uint (outfile_autohex);
6668 logfile_top_uint (outfile_check_timer);
6669 logfile_top_uint (outfile_format);
6670 logfile_top_uint (potfile_disable);
6671 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6672 logfile_top_uint (powertune_enable);
6673 #endif
6674 logfile_top_uint (scrypt_tmto);
6675 logfile_top_uint (quiet);
6676 logfile_top_uint (remove);
6677 logfile_top_uint (remove_timer);
6678 logfile_top_uint (restore);
6679 logfile_top_uint (restore_disable);
6680 logfile_top_uint (restore_timer);
6681 logfile_top_uint (rp_gen);
6682 logfile_top_uint (rp_gen_func_max);
6683 logfile_top_uint (rp_gen_func_min);
6684 logfile_top_uint (rp_gen_seed);
6685 logfile_top_uint (runtime);
6686 logfile_top_uint (segment_size);
6687 logfile_top_uint (show);
6688 logfile_top_uint (status);
6689 logfile_top_uint (status_automat);
6690 logfile_top_uint (status_timer);
6691 logfile_top_uint (usage);
6692 logfile_top_uint (username);
6693 logfile_top_uint (version);
6694 logfile_top_uint (weak_hash_threshold);
6695 logfile_top_uint (workload_profile);
6696 logfile_top_uint64 (limit);
6697 logfile_top_uint64 (skip);
6698 logfile_top_char (separator);
6699 logfile_top_string (cpu_affinity);
6700 logfile_top_string (custom_charset_1);
6701 logfile_top_string (custom_charset_2);
6702 logfile_top_string (custom_charset_3);
6703 logfile_top_string (custom_charset_4);
6704 logfile_top_string (debug_file);
6705 logfile_top_string (opencl_devices);
6706 logfile_top_string (opencl_platforms);
6707 logfile_top_string (opencl_device_types);
6708 logfile_top_uint (opencl_vector_width);
6709 logfile_top_string (induction_dir);
6710 logfile_top_string (markov_hcstat);
6711 logfile_top_string (outfile);
6712 logfile_top_string (outfile_check_dir);
6713 logfile_top_string (rule_buf_l);
6714 logfile_top_string (rule_buf_r);
6715 logfile_top_string (session);
6716 logfile_top_string (truecrypt_keyfiles);
6717
6718 /**
6719 * Init OpenCL library loader
6720 */
6721
6722 if (keyspace == 0)
6723 {
6724 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6725
6726 ocl_init (ocl);
6727
6728 data.ocl = ocl;
6729 }
6730
6731 /**
6732 * OpenCL platform selection
6733 */
6734
6735 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6736
6737 /**
6738 * OpenCL device selection
6739 */
6740
6741 u32 devices_filter = setup_devices_filter (opencl_devices);
6742
6743 /**
6744 * OpenCL device type selection
6745 */
6746
6747 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6748
6749 /**
6750 * benchmark
6751 */
6752
6753 if (benchmark == 1)
6754 {
6755 /**
6756 * disable useless stuff for benchmark
6757 */
6758
6759 status_timer = 0;
6760 restore_timer = 0;
6761 restore_disable = 1;
6762 potfile_disable = 1;
6763 weak_hash_threshold = 0;
6764 gpu_temp_disable = 1;
6765
6766 data.status_timer = status_timer;
6767 data.restore_timer = restore_timer;
6768 data.restore_disable = restore_disable;
6769
6770 /**
6771 * force attack mode to be bruteforce
6772 */
6773
6774 attack_mode = ATTACK_MODE_BF;
6775 attack_kern = ATTACK_KERN_BF;
6776
6777 if (workload_profile_chgd == 0)
6778 {
6779 workload_profile = 3;
6780
6781 data.workload_profile = workload_profile;
6782 }
6783 }
6784
6785 /**
6786 * config
6787 */
6788
6789 uint hash_type = 0;
6790 uint salt_type = 0;
6791 uint attack_exec = 0;
6792 uint opts_type = 0;
6793 uint kern_type = 0;
6794 uint dgst_size = 0;
6795 uint esalt_size = 0;
6796 uint opti_type = 0;
6797 uint dgst_pos0 = -1;
6798 uint dgst_pos1 = -1;
6799 uint dgst_pos2 = -1;
6800 uint dgst_pos3 = -1;
6801
6802 int (*parse_func) (char *, uint, hash_t *);
6803 int (*sort_by_digest) (const void *, const void *);
6804
6805 uint algorithm_pos = 0;
6806 uint algorithm_max = 1;
6807
6808 uint *algorithms = default_benchmark_algorithms;
6809
6810 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6811
6812 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6813 {
6814 /*
6815 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6816 * the following algos are skipped entirely
6817 */
6818
6819 if (algorithm_pos > 0)
6820 {
6821 local_free (rd);
6822
6823 rd = init_restore (argc, argv);
6824
6825 data.rd = rd;
6826 }
6827
6828 /**
6829 * update hash_mode in case of multihash benchmark
6830 */
6831
6832 if (benchmark == 1)
6833 {
6834 if (hash_mode_chgd == 0)
6835 {
6836 hash_mode = algorithms[algorithm_pos];
6837
6838 data.hash_mode = hash_mode;
6839 }
6840
6841 quiet = 1;
6842
6843 data.quiet = quiet;
6844 }
6845
6846 switch (hash_mode)
6847 {
6848 case 0: hash_type = HASH_TYPE_MD5;
6849 salt_type = SALT_TYPE_NONE;
6850 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6851 opts_type = OPTS_TYPE_PT_GENERATE_LE
6852 | OPTS_TYPE_PT_ADD80
6853 | OPTS_TYPE_PT_ADDBITS14;
6854 kern_type = KERN_TYPE_MD5;
6855 dgst_size = DGST_SIZE_4_4;
6856 parse_func = md5_parse_hash;
6857 sort_by_digest = sort_by_digest_4_4;
6858 opti_type = OPTI_TYPE_ZERO_BYTE
6859 | OPTI_TYPE_PRECOMPUTE_INIT
6860 | OPTI_TYPE_PRECOMPUTE_MERKLE
6861 | OPTI_TYPE_MEET_IN_MIDDLE
6862 | OPTI_TYPE_EARLY_SKIP
6863 | OPTI_TYPE_NOT_ITERATED
6864 | OPTI_TYPE_NOT_SALTED
6865 | OPTI_TYPE_RAW_HASH;
6866 dgst_pos0 = 0;
6867 dgst_pos1 = 3;
6868 dgst_pos2 = 2;
6869 dgst_pos3 = 1;
6870 break;
6871
6872 case 10: hash_type = HASH_TYPE_MD5;
6873 salt_type = SALT_TYPE_INTERN;
6874 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6875 opts_type = OPTS_TYPE_PT_GENERATE_LE
6876 | OPTS_TYPE_ST_ADD80
6877 | OPTS_TYPE_ST_ADDBITS14;
6878 kern_type = KERN_TYPE_MD5_PWSLT;
6879 dgst_size = DGST_SIZE_4_4;
6880 parse_func = md5s_parse_hash;
6881 sort_by_digest = sort_by_digest_4_4;
6882 opti_type = OPTI_TYPE_ZERO_BYTE
6883 | OPTI_TYPE_PRECOMPUTE_INIT
6884 | OPTI_TYPE_PRECOMPUTE_MERKLE
6885 | OPTI_TYPE_MEET_IN_MIDDLE
6886 | OPTI_TYPE_EARLY_SKIP
6887 | OPTI_TYPE_NOT_ITERATED
6888 | OPTI_TYPE_APPENDED_SALT
6889 | OPTI_TYPE_RAW_HASH;
6890 dgst_pos0 = 0;
6891 dgst_pos1 = 3;
6892 dgst_pos2 = 2;
6893 dgst_pos3 = 1;
6894 break;
6895
6896 case 11: hash_type = HASH_TYPE_MD5;
6897 salt_type = SALT_TYPE_INTERN;
6898 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6899 opts_type = OPTS_TYPE_PT_GENERATE_LE
6900 | OPTS_TYPE_ST_ADD80
6901 | OPTS_TYPE_ST_ADDBITS14;
6902 kern_type = KERN_TYPE_MD5_PWSLT;
6903 dgst_size = DGST_SIZE_4_4;
6904 parse_func = joomla_parse_hash;
6905 sort_by_digest = sort_by_digest_4_4;
6906 opti_type = OPTI_TYPE_ZERO_BYTE
6907 | OPTI_TYPE_PRECOMPUTE_INIT
6908 | OPTI_TYPE_PRECOMPUTE_MERKLE
6909 | OPTI_TYPE_MEET_IN_MIDDLE
6910 | OPTI_TYPE_EARLY_SKIP
6911 | OPTI_TYPE_NOT_ITERATED
6912 | OPTI_TYPE_APPENDED_SALT
6913 | OPTI_TYPE_RAW_HASH;
6914 dgst_pos0 = 0;
6915 dgst_pos1 = 3;
6916 dgst_pos2 = 2;
6917 dgst_pos3 = 1;
6918 break;
6919
6920 case 12: hash_type = HASH_TYPE_MD5;
6921 salt_type = SALT_TYPE_INTERN;
6922 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6923 opts_type = OPTS_TYPE_PT_GENERATE_LE
6924 | OPTS_TYPE_ST_ADD80
6925 | OPTS_TYPE_ST_ADDBITS14;
6926 kern_type = KERN_TYPE_MD5_PWSLT;
6927 dgst_size = DGST_SIZE_4_4;
6928 parse_func = postgresql_parse_hash;
6929 sort_by_digest = sort_by_digest_4_4;
6930 opti_type = OPTI_TYPE_ZERO_BYTE
6931 | OPTI_TYPE_PRECOMPUTE_INIT
6932 | OPTI_TYPE_PRECOMPUTE_MERKLE
6933 | OPTI_TYPE_MEET_IN_MIDDLE
6934 | OPTI_TYPE_EARLY_SKIP
6935 | OPTI_TYPE_NOT_ITERATED
6936 | OPTI_TYPE_APPENDED_SALT
6937 | OPTI_TYPE_RAW_HASH;
6938 dgst_pos0 = 0;
6939 dgst_pos1 = 3;
6940 dgst_pos2 = 2;
6941 dgst_pos3 = 1;
6942 break;
6943
6944 case 20: hash_type = HASH_TYPE_MD5;
6945 salt_type = SALT_TYPE_INTERN;
6946 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6947 opts_type = OPTS_TYPE_PT_GENERATE_LE
6948 | OPTS_TYPE_PT_ADD80
6949 | OPTS_TYPE_PT_ADDBITS14;
6950 kern_type = KERN_TYPE_MD5_SLTPW;
6951 dgst_size = DGST_SIZE_4_4;
6952 parse_func = md5s_parse_hash;
6953 sort_by_digest = sort_by_digest_4_4;
6954 opti_type = OPTI_TYPE_ZERO_BYTE
6955 | OPTI_TYPE_PRECOMPUTE_INIT
6956 | OPTI_TYPE_PRECOMPUTE_MERKLE
6957 | OPTI_TYPE_EARLY_SKIP
6958 | OPTI_TYPE_NOT_ITERATED
6959 | OPTI_TYPE_PREPENDED_SALT
6960 | OPTI_TYPE_RAW_HASH;
6961 dgst_pos0 = 0;
6962 dgst_pos1 = 3;
6963 dgst_pos2 = 2;
6964 dgst_pos3 = 1;
6965 break;
6966
6967 case 21: hash_type = HASH_TYPE_MD5;
6968 salt_type = SALT_TYPE_INTERN;
6969 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6970 opts_type = OPTS_TYPE_PT_GENERATE_LE
6971 | OPTS_TYPE_PT_ADD80
6972 | OPTS_TYPE_PT_ADDBITS14;
6973 kern_type = KERN_TYPE_MD5_SLTPW;
6974 dgst_size = DGST_SIZE_4_4;
6975 parse_func = osc_parse_hash;
6976 sort_by_digest = sort_by_digest_4_4;
6977 opti_type = OPTI_TYPE_ZERO_BYTE
6978 | OPTI_TYPE_PRECOMPUTE_INIT
6979 | OPTI_TYPE_PRECOMPUTE_MERKLE
6980 | OPTI_TYPE_EARLY_SKIP
6981 | OPTI_TYPE_NOT_ITERATED
6982 | OPTI_TYPE_PREPENDED_SALT
6983 | OPTI_TYPE_RAW_HASH;
6984 dgst_pos0 = 0;
6985 dgst_pos1 = 3;
6986 dgst_pos2 = 2;
6987 dgst_pos3 = 1;
6988 break;
6989
6990 case 22: hash_type = HASH_TYPE_MD5;
6991 salt_type = SALT_TYPE_EMBEDDED;
6992 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6993 opts_type = OPTS_TYPE_PT_GENERATE_LE
6994 | OPTS_TYPE_PT_ADD80
6995 | OPTS_TYPE_PT_ADDBITS14;
6996 kern_type = KERN_TYPE_MD5_SLTPW;
6997 dgst_size = DGST_SIZE_4_4;
6998 parse_func = netscreen_parse_hash;
6999 sort_by_digest = sort_by_digest_4_4;
7000 opti_type = OPTI_TYPE_ZERO_BYTE
7001 | OPTI_TYPE_PRECOMPUTE_INIT
7002 | OPTI_TYPE_PRECOMPUTE_MERKLE
7003 | OPTI_TYPE_EARLY_SKIP
7004 | OPTI_TYPE_NOT_ITERATED
7005 | OPTI_TYPE_PREPENDED_SALT
7006 | OPTI_TYPE_RAW_HASH;
7007 dgst_pos0 = 0;
7008 dgst_pos1 = 3;
7009 dgst_pos2 = 2;
7010 dgst_pos3 = 1;
7011 break;
7012
7013 case 23: hash_type = HASH_TYPE_MD5;
7014 salt_type = SALT_TYPE_EMBEDDED;
7015 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7016 opts_type = OPTS_TYPE_PT_GENERATE_LE
7017 | OPTS_TYPE_PT_ADD80
7018 | OPTS_TYPE_PT_ADDBITS14;
7019 kern_type = KERN_TYPE_MD5_SLTPW;
7020 dgst_size = DGST_SIZE_4_4;
7021 parse_func = skype_parse_hash;
7022 sort_by_digest = sort_by_digest_4_4;
7023 opti_type = OPTI_TYPE_ZERO_BYTE
7024 | OPTI_TYPE_PRECOMPUTE_INIT
7025 | OPTI_TYPE_PRECOMPUTE_MERKLE
7026 | OPTI_TYPE_EARLY_SKIP
7027 | OPTI_TYPE_NOT_ITERATED
7028 | OPTI_TYPE_PREPENDED_SALT
7029 | OPTI_TYPE_RAW_HASH;
7030 dgst_pos0 = 0;
7031 dgst_pos1 = 3;
7032 dgst_pos2 = 2;
7033 dgst_pos3 = 1;
7034 break;
7035
7036 case 30: hash_type = HASH_TYPE_MD5;
7037 salt_type = SALT_TYPE_INTERN;
7038 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7039 opts_type = OPTS_TYPE_PT_GENERATE_LE
7040 | OPTS_TYPE_PT_UNICODE
7041 | OPTS_TYPE_ST_ADD80
7042 | OPTS_TYPE_ST_ADDBITS14;
7043 kern_type = KERN_TYPE_MD5_PWUSLT;
7044 dgst_size = DGST_SIZE_4_4;
7045 parse_func = md5s_parse_hash;
7046 sort_by_digest = sort_by_digest_4_4;
7047 opti_type = OPTI_TYPE_ZERO_BYTE
7048 | OPTI_TYPE_PRECOMPUTE_INIT
7049 | OPTI_TYPE_PRECOMPUTE_MERKLE
7050 | OPTI_TYPE_MEET_IN_MIDDLE
7051 | OPTI_TYPE_EARLY_SKIP
7052 | OPTI_TYPE_NOT_ITERATED
7053 | OPTI_TYPE_APPENDED_SALT
7054 | OPTI_TYPE_RAW_HASH;
7055 dgst_pos0 = 0;
7056 dgst_pos1 = 3;
7057 dgst_pos2 = 2;
7058 dgst_pos3 = 1;
7059 break;
7060
7061 case 40: hash_type = HASH_TYPE_MD5;
7062 salt_type = SALT_TYPE_INTERN;
7063 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7064 opts_type = OPTS_TYPE_PT_GENERATE_LE
7065 | OPTS_TYPE_PT_ADD80
7066 | OPTS_TYPE_PT_ADDBITS14
7067 | OPTS_TYPE_PT_UNICODE;
7068 kern_type = KERN_TYPE_MD5_SLTPWU;
7069 dgst_size = DGST_SIZE_4_4;
7070 parse_func = md5s_parse_hash;
7071 sort_by_digest = sort_by_digest_4_4;
7072 opti_type = OPTI_TYPE_ZERO_BYTE
7073 | OPTI_TYPE_PRECOMPUTE_INIT
7074 | OPTI_TYPE_PRECOMPUTE_MERKLE
7075 | OPTI_TYPE_EARLY_SKIP
7076 | OPTI_TYPE_NOT_ITERATED
7077 | OPTI_TYPE_PREPENDED_SALT
7078 | OPTI_TYPE_RAW_HASH;
7079 dgst_pos0 = 0;
7080 dgst_pos1 = 3;
7081 dgst_pos2 = 2;
7082 dgst_pos3 = 1;
7083 break;
7084
7085 case 50: hash_type = HASH_TYPE_MD5;
7086 salt_type = SALT_TYPE_INTERN;
7087 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7088 opts_type = OPTS_TYPE_PT_GENERATE_LE
7089 | OPTS_TYPE_ST_ADD80
7090 | OPTS_TYPE_ST_ADDBITS14;
7091 kern_type = KERN_TYPE_HMACMD5_PW;
7092 dgst_size = DGST_SIZE_4_4;
7093 parse_func = hmacmd5_parse_hash;
7094 sort_by_digest = sort_by_digest_4_4;
7095 opti_type = OPTI_TYPE_ZERO_BYTE
7096 | OPTI_TYPE_NOT_ITERATED;
7097 dgst_pos0 = 0;
7098 dgst_pos1 = 3;
7099 dgst_pos2 = 2;
7100 dgst_pos3 = 1;
7101 break;
7102
7103 case 60: hash_type = HASH_TYPE_MD5;
7104 salt_type = SALT_TYPE_INTERN;
7105 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7106 opts_type = OPTS_TYPE_PT_GENERATE_LE
7107 | OPTS_TYPE_PT_ADD80
7108 | OPTS_TYPE_PT_ADDBITS14;
7109 kern_type = KERN_TYPE_HMACMD5_SLT;
7110 dgst_size = DGST_SIZE_4_4;
7111 parse_func = hmacmd5_parse_hash;
7112 sort_by_digest = sort_by_digest_4_4;
7113 opti_type = OPTI_TYPE_ZERO_BYTE
7114 | OPTI_TYPE_NOT_ITERATED;
7115 dgst_pos0 = 0;
7116 dgst_pos1 = 3;
7117 dgst_pos2 = 2;
7118 dgst_pos3 = 1;
7119 break;
7120
7121 case 100: hash_type = HASH_TYPE_SHA1;
7122 salt_type = SALT_TYPE_NONE;
7123 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7124 opts_type = OPTS_TYPE_PT_GENERATE_BE
7125 | OPTS_TYPE_PT_ADD80
7126 | OPTS_TYPE_PT_ADDBITS15;
7127 kern_type = KERN_TYPE_SHA1;
7128 dgst_size = DGST_SIZE_4_5;
7129 parse_func = sha1_parse_hash;
7130 sort_by_digest = sort_by_digest_4_5;
7131 opti_type = OPTI_TYPE_ZERO_BYTE
7132 | OPTI_TYPE_PRECOMPUTE_INIT
7133 | OPTI_TYPE_PRECOMPUTE_MERKLE
7134 | OPTI_TYPE_EARLY_SKIP
7135 | OPTI_TYPE_NOT_ITERATED
7136 | OPTI_TYPE_NOT_SALTED
7137 | OPTI_TYPE_RAW_HASH;
7138 dgst_pos0 = 3;
7139 dgst_pos1 = 4;
7140 dgst_pos2 = 2;
7141 dgst_pos3 = 1;
7142 break;
7143
7144 case 101: hash_type = HASH_TYPE_SHA1;
7145 salt_type = SALT_TYPE_NONE;
7146 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7147 opts_type = OPTS_TYPE_PT_GENERATE_BE
7148 | OPTS_TYPE_PT_ADD80
7149 | OPTS_TYPE_PT_ADDBITS15;
7150 kern_type = KERN_TYPE_SHA1;
7151 dgst_size = DGST_SIZE_4_5;
7152 parse_func = sha1b64_parse_hash;
7153 sort_by_digest = sort_by_digest_4_5;
7154 opti_type = OPTI_TYPE_ZERO_BYTE
7155 | OPTI_TYPE_PRECOMPUTE_INIT
7156 | OPTI_TYPE_PRECOMPUTE_MERKLE
7157 | OPTI_TYPE_EARLY_SKIP
7158 | OPTI_TYPE_NOT_ITERATED
7159 | OPTI_TYPE_NOT_SALTED
7160 | OPTI_TYPE_RAW_HASH;
7161 dgst_pos0 = 3;
7162 dgst_pos1 = 4;
7163 dgst_pos2 = 2;
7164 dgst_pos3 = 1;
7165 break;
7166
7167 case 110: hash_type = HASH_TYPE_SHA1;
7168 salt_type = SALT_TYPE_INTERN;
7169 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7170 opts_type = OPTS_TYPE_PT_GENERATE_BE
7171 | OPTS_TYPE_ST_ADD80
7172 | OPTS_TYPE_ST_ADDBITS15;
7173 kern_type = KERN_TYPE_SHA1_PWSLT;
7174 dgst_size = DGST_SIZE_4_5;
7175 parse_func = sha1s_parse_hash;
7176 sort_by_digest = sort_by_digest_4_5;
7177 opti_type = OPTI_TYPE_ZERO_BYTE
7178 | OPTI_TYPE_PRECOMPUTE_INIT
7179 | OPTI_TYPE_PRECOMPUTE_MERKLE
7180 | OPTI_TYPE_EARLY_SKIP
7181 | OPTI_TYPE_NOT_ITERATED
7182 | OPTI_TYPE_APPENDED_SALT
7183 | OPTI_TYPE_RAW_HASH;
7184 dgst_pos0 = 3;
7185 dgst_pos1 = 4;
7186 dgst_pos2 = 2;
7187 dgst_pos3 = 1;
7188 break;
7189
7190 case 111: hash_type = HASH_TYPE_SHA1;
7191 salt_type = SALT_TYPE_EMBEDDED;
7192 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7193 opts_type = OPTS_TYPE_PT_GENERATE_BE
7194 | OPTS_TYPE_ST_ADD80
7195 | OPTS_TYPE_ST_ADDBITS15;
7196 kern_type = KERN_TYPE_SHA1_PWSLT;
7197 dgst_size = DGST_SIZE_4_5;
7198 parse_func = sha1b64s_parse_hash;
7199 sort_by_digest = sort_by_digest_4_5;
7200 opti_type = OPTI_TYPE_ZERO_BYTE
7201 | OPTI_TYPE_PRECOMPUTE_INIT
7202 | OPTI_TYPE_PRECOMPUTE_MERKLE
7203 | OPTI_TYPE_EARLY_SKIP
7204 | OPTI_TYPE_NOT_ITERATED
7205 | OPTI_TYPE_APPENDED_SALT
7206 | OPTI_TYPE_RAW_HASH;
7207 dgst_pos0 = 3;
7208 dgst_pos1 = 4;
7209 dgst_pos2 = 2;
7210 dgst_pos3 = 1;
7211 break;
7212
7213 case 112: hash_type = HASH_TYPE_SHA1;
7214 salt_type = SALT_TYPE_INTERN;
7215 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7216 opts_type = OPTS_TYPE_PT_GENERATE_BE
7217 | OPTS_TYPE_ST_ADD80
7218 | OPTS_TYPE_ST_ADDBITS15
7219 | OPTS_TYPE_ST_HEX;
7220 kern_type = KERN_TYPE_SHA1_PWSLT;
7221 dgst_size = DGST_SIZE_4_5;
7222 parse_func = oracles_parse_hash;
7223 sort_by_digest = sort_by_digest_4_5;
7224 opti_type = OPTI_TYPE_ZERO_BYTE
7225 | OPTI_TYPE_PRECOMPUTE_INIT
7226 | OPTI_TYPE_PRECOMPUTE_MERKLE
7227 | OPTI_TYPE_EARLY_SKIP
7228 | OPTI_TYPE_NOT_ITERATED
7229 | OPTI_TYPE_APPENDED_SALT
7230 | OPTI_TYPE_RAW_HASH;
7231 dgst_pos0 = 3;
7232 dgst_pos1 = 4;
7233 dgst_pos2 = 2;
7234 dgst_pos3 = 1;
7235 break;
7236
7237 case 120: hash_type = HASH_TYPE_SHA1;
7238 salt_type = SALT_TYPE_INTERN;
7239 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7240 opts_type = OPTS_TYPE_PT_GENERATE_BE
7241 | OPTS_TYPE_PT_ADD80
7242 | OPTS_TYPE_PT_ADDBITS15;
7243 kern_type = KERN_TYPE_SHA1_SLTPW;
7244 dgst_size = DGST_SIZE_4_5;
7245 parse_func = sha1s_parse_hash;
7246 sort_by_digest = sort_by_digest_4_5;
7247 opti_type = OPTI_TYPE_ZERO_BYTE
7248 | OPTI_TYPE_PRECOMPUTE_INIT
7249 | OPTI_TYPE_PRECOMPUTE_MERKLE
7250 | OPTI_TYPE_EARLY_SKIP
7251 | OPTI_TYPE_NOT_ITERATED
7252 | OPTI_TYPE_PREPENDED_SALT
7253 | OPTI_TYPE_RAW_HASH;
7254 dgst_pos0 = 3;
7255 dgst_pos1 = 4;
7256 dgst_pos2 = 2;
7257 dgst_pos3 = 1;
7258 break;
7259
7260 case 121: hash_type = HASH_TYPE_SHA1;
7261 salt_type = SALT_TYPE_INTERN;
7262 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7263 opts_type = OPTS_TYPE_PT_GENERATE_BE
7264 | OPTS_TYPE_PT_ADD80
7265 | OPTS_TYPE_PT_ADDBITS15
7266 | OPTS_TYPE_ST_LOWER;
7267 kern_type = KERN_TYPE_SHA1_SLTPW;
7268 dgst_size = DGST_SIZE_4_5;
7269 parse_func = smf_parse_hash;
7270 sort_by_digest = sort_by_digest_4_5;
7271 opti_type = OPTI_TYPE_ZERO_BYTE
7272 | OPTI_TYPE_PRECOMPUTE_INIT
7273 | OPTI_TYPE_PRECOMPUTE_MERKLE
7274 | OPTI_TYPE_EARLY_SKIP
7275 | OPTI_TYPE_NOT_ITERATED
7276 | OPTI_TYPE_PREPENDED_SALT
7277 | OPTI_TYPE_RAW_HASH;
7278 dgst_pos0 = 3;
7279 dgst_pos1 = 4;
7280 dgst_pos2 = 2;
7281 dgst_pos3 = 1;
7282 break;
7283
7284 case 122: hash_type = HASH_TYPE_SHA1;
7285 salt_type = SALT_TYPE_EMBEDDED;
7286 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7287 opts_type = OPTS_TYPE_PT_GENERATE_BE
7288 | OPTS_TYPE_PT_ADD80
7289 | OPTS_TYPE_PT_ADDBITS15
7290 | OPTS_TYPE_ST_HEX;
7291 kern_type = KERN_TYPE_SHA1_SLTPW;
7292 dgst_size = DGST_SIZE_4_5;
7293 parse_func = osx1_parse_hash;
7294 sort_by_digest = sort_by_digest_4_5;
7295 opti_type = OPTI_TYPE_ZERO_BYTE
7296 | OPTI_TYPE_PRECOMPUTE_INIT
7297 | OPTI_TYPE_PRECOMPUTE_MERKLE
7298 | OPTI_TYPE_EARLY_SKIP
7299 | OPTI_TYPE_NOT_ITERATED
7300 | OPTI_TYPE_PREPENDED_SALT
7301 | OPTI_TYPE_RAW_HASH;
7302 dgst_pos0 = 3;
7303 dgst_pos1 = 4;
7304 dgst_pos2 = 2;
7305 dgst_pos3 = 1;
7306 break;
7307
7308 case 124: hash_type = HASH_TYPE_SHA1;
7309 salt_type = SALT_TYPE_EMBEDDED;
7310 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7311 opts_type = OPTS_TYPE_PT_GENERATE_BE
7312 | OPTS_TYPE_PT_ADD80
7313 | OPTS_TYPE_PT_ADDBITS15;
7314 kern_type = KERN_TYPE_SHA1_SLTPW;
7315 dgst_size = DGST_SIZE_4_5;
7316 parse_func = djangosha1_parse_hash;
7317 sort_by_digest = sort_by_digest_4_5;
7318 opti_type = OPTI_TYPE_ZERO_BYTE
7319 | OPTI_TYPE_PRECOMPUTE_INIT
7320 | OPTI_TYPE_PRECOMPUTE_MERKLE
7321 | OPTI_TYPE_EARLY_SKIP
7322 | OPTI_TYPE_NOT_ITERATED
7323 | OPTI_TYPE_PREPENDED_SALT
7324 | OPTI_TYPE_RAW_HASH;
7325 dgst_pos0 = 3;
7326 dgst_pos1 = 4;
7327 dgst_pos2 = 2;
7328 dgst_pos3 = 1;
7329 break;
7330
7331 case 130: hash_type = HASH_TYPE_SHA1;
7332 salt_type = SALT_TYPE_INTERN;
7333 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7334 opts_type = OPTS_TYPE_PT_GENERATE_BE
7335 | OPTS_TYPE_PT_UNICODE
7336 | OPTS_TYPE_ST_ADD80
7337 | OPTS_TYPE_ST_ADDBITS15;
7338 kern_type = KERN_TYPE_SHA1_PWUSLT;
7339 dgst_size = DGST_SIZE_4_5;
7340 parse_func = sha1s_parse_hash;
7341 sort_by_digest = sort_by_digest_4_5;
7342 opti_type = OPTI_TYPE_ZERO_BYTE
7343 | OPTI_TYPE_PRECOMPUTE_INIT
7344 | OPTI_TYPE_PRECOMPUTE_MERKLE
7345 | OPTI_TYPE_EARLY_SKIP
7346 | OPTI_TYPE_NOT_ITERATED
7347 | OPTI_TYPE_APPENDED_SALT
7348 | OPTI_TYPE_RAW_HASH;
7349 dgst_pos0 = 3;
7350 dgst_pos1 = 4;
7351 dgst_pos2 = 2;
7352 dgst_pos3 = 1;
7353 break;
7354
7355 case 131: hash_type = HASH_TYPE_SHA1;
7356 salt_type = SALT_TYPE_EMBEDDED;
7357 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7358 opts_type = OPTS_TYPE_PT_GENERATE_BE
7359 | OPTS_TYPE_PT_UNICODE
7360 | OPTS_TYPE_PT_UPPER
7361 | OPTS_TYPE_ST_ADD80
7362 | OPTS_TYPE_ST_ADDBITS15
7363 | OPTS_TYPE_ST_HEX;
7364 kern_type = KERN_TYPE_SHA1_PWUSLT;
7365 dgst_size = DGST_SIZE_4_5;
7366 parse_func = mssql2000_parse_hash;
7367 sort_by_digest = sort_by_digest_4_5;
7368 opti_type = OPTI_TYPE_ZERO_BYTE
7369 | OPTI_TYPE_PRECOMPUTE_INIT
7370 | OPTI_TYPE_PRECOMPUTE_MERKLE
7371 | OPTI_TYPE_EARLY_SKIP
7372 | OPTI_TYPE_NOT_ITERATED
7373 | OPTI_TYPE_APPENDED_SALT
7374 | OPTI_TYPE_RAW_HASH;
7375 dgst_pos0 = 3;
7376 dgst_pos1 = 4;
7377 dgst_pos2 = 2;
7378 dgst_pos3 = 1;
7379 break;
7380
7381 case 132: hash_type = HASH_TYPE_SHA1;
7382 salt_type = SALT_TYPE_EMBEDDED;
7383 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7384 opts_type = OPTS_TYPE_PT_GENERATE_BE
7385 | OPTS_TYPE_PT_UNICODE
7386 | OPTS_TYPE_ST_ADD80
7387 | OPTS_TYPE_ST_ADDBITS15
7388 | OPTS_TYPE_ST_HEX;
7389 kern_type = KERN_TYPE_SHA1_PWUSLT;
7390 dgst_size = DGST_SIZE_4_5;
7391 parse_func = mssql2005_parse_hash;
7392 sort_by_digest = sort_by_digest_4_5;
7393 opti_type = OPTI_TYPE_ZERO_BYTE
7394 | OPTI_TYPE_PRECOMPUTE_INIT
7395 | OPTI_TYPE_PRECOMPUTE_MERKLE
7396 | OPTI_TYPE_EARLY_SKIP
7397 | OPTI_TYPE_NOT_ITERATED
7398 | OPTI_TYPE_APPENDED_SALT
7399 | OPTI_TYPE_RAW_HASH;
7400 dgst_pos0 = 3;
7401 dgst_pos1 = 4;
7402 dgst_pos2 = 2;
7403 dgst_pos3 = 1;
7404 break;
7405
7406 case 133: hash_type = HASH_TYPE_SHA1;
7407 salt_type = SALT_TYPE_EMBEDDED;
7408 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7409 opts_type = OPTS_TYPE_PT_GENERATE_BE
7410 | OPTS_TYPE_PT_UNICODE
7411 | OPTS_TYPE_ST_ADD80
7412 | OPTS_TYPE_ST_ADDBITS15;
7413 kern_type = KERN_TYPE_SHA1_PWUSLT;
7414 dgst_size = DGST_SIZE_4_5;
7415 parse_func = peoplesoft_parse_hash;
7416 sort_by_digest = sort_by_digest_4_5;
7417 opti_type = OPTI_TYPE_ZERO_BYTE
7418 | OPTI_TYPE_PRECOMPUTE_INIT
7419 | OPTI_TYPE_PRECOMPUTE_MERKLE
7420 | OPTI_TYPE_EARLY_SKIP
7421 | OPTI_TYPE_NOT_ITERATED
7422 | OPTI_TYPE_APPENDED_SALT
7423 | OPTI_TYPE_RAW_HASH;
7424 dgst_pos0 = 3;
7425 dgst_pos1 = 4;
7426 dgst_pos2 = 2;
7427 dgst_pos3 = 1;
7428 break;
7429
7430 case 140: hash_type = HASH_TYPE_SHA1;
7431 salt_type = SALT_TYPE_INTERN;
7432 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7433 opts_type = OPTS_TYPE_PT_GENERATE_BE
7434 | OPTS_TYPE_PT_ADD80
7435 | OPTS_TYPE_PT_ADDBITS15
7436 | OPTS_TYPE_PT_UNICODE;
7437 kern_type = KERN_TYPE_SHA1_SLTPWU;
7438 dgst_size = DGST_SIZE_4_5;
7439 parse_func = sha1s_parse_hash;
7440 sort_by_digest = sort_by_digest_4_5;
7441 opti_type = OPTI_TYPE_ZERO_BYTE
7442 | OPTI_TYPE_PRECOMPUTE_INIT
7443 | OPTI_TYPE_PRECOMPUTE_MERKLE
7444 | OPTI_TYPE_EARLY_SKIP
7445 | OPTI_TYPE_NOT_ITERATED
7446 | OPTI_TYPE_PREPENDED_SALT
7447 | OPTI_TYPE_RAW_HASH;
7448 dgst_pos0 = 3;
7449 dgst_pos1 = 4;
7450 dgst_pos2 = 2;
7451 dgst_pos3 = 1;
7452 break;
7453
7454 case 141: hash_type = HASH_TYPE_SHA1;
7455 salt_type = SALT_TYPE_EMBEDDED;
7456 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7457 opts_type = OPTS_TYPE_PT_GENERATE_BE
7458 | OPTS_TYPE_PT_ADD80
7459 | OPTS_TYPE_PT_ADDBITS15
7460 | OPTS_TYPE_PT_UNICODE
7461 | OPTS_TYPE_ST_BASE64;
7462 kern_type = KERN_TYPE_SHA1_SLTPWU;
7463 dgst_size = DGST_SIZE_4_5;
7464 parse_func = episerver_parse_hash;
7465 sort_by_digest = sort_by_digest_4_5;
7466 opti_type = OPTI_TYPE_ZERO_BYTE
7467 | OPTI_TYPE_PRECOMPUTE_INIT
7468 | OPTI_TYPE_PRECOMPUTE_MERKLE
7469 | OPTI_TYPE_EARLY_SKIP
7470 | OPTI_TYPE_NOT_ITERATED
7471 | OPTI_TYPE_PREPENDED_SALT
7472 | OPTI_TYPE_RAW_HASH;
7473 dgst_pos0 = 3;
7474 dgst_pos1 = 4;
7475 dgst_pos2 = 2;
7476 dgst_pos3 = 1;
7477 break;
7478
7479 case 150: hash_type = HASH_TYPE_SHA1;
7480 salt_type = SALT_TYPE_INTERN;
7481 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7482 opts_type = OPTS_TYPE_PT_GENERATE_BE
7483 | OPTS_TYPE_ST_ADD80
7484 | OPTS_TYPE_ST_ADDBITS15;
7485 kern_type = KERN_TYPE_HMACSHA1_PW;
7486 dgst_size = DGST_SIZE_4_5;
7487 parse_func = hmacsha1_parse_hash;
7488 sort_by_digest = sort_by_digest_4_5;
7489 opti_type = OPTI_TYPE_ZERO_BYTE
7490 | OPTI_TYPE_NOT_ITERATED;
7491 dgst_pos0 = 3;
7492 dgst_pos1 = 4;
7493 dgst_pos2 = 2;
7494 dgst_pos3 = 1;
7495 break;
7496
7497 case 160: hash_type = HASH_TYPE_SHA1;
7498 salt_type = SALT_TYPE_INTERN;
7499 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7500 opts_type = OPTS_TYPE_PT_GENERATE_BE
7501 | OPTS_TYPE_PT_ADD80
7502 | OPTS_TYPE_PT_ADDBITS15;
7503 kern_type = KERN_TYPE_HMACSHA1_SLT;
7504 dgst_size = DGST_SIZE_4_5;
7505 parse_func = hmacsha1_parse_hash;
7506 sort_by_digest = sort_by_digest_4_5;
7507 opti_type = OPTI_TYPE_ZERO_BYTE
7508 | OPTI_TYPE_NOT_ITERATED;
7509 dgst_pos0 = 3;
7510 dgst_pos1 = 4;
7511 dgst_pos2 = 2;
7512 dgst_pos3 = 1;
7513 break;
7514
7515 case 190: hash_type = HASH_TYPE_SHA1;
7516 salt_type = SALT_TYPE_NONE;
7517 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7518 opts_type = OPTS_TYPE_PT_GENERATE_BE
7519 | OPTS_TYPE_PT_ADD80
7520 | OPTS_TYPE_PT_ADDBITS15;
7521 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7522 dgst_size = DGST_SIZE_4_5;
7523 parse_func = sha1linkedin_parse_hash;
7524 sort_by_digest = sort_by_digest_4_5;
7525 opti_type = OPTI_TYPE_ZERO_BYTE
7526 | OPTI_TYPE_PRECOMPUTE_INIT
7527 | OPTI_TYPE_EARLY_SKIP
7528 | OPTI_TYPE_NOT_ITERATED
7529 | OPTI_TYPE_NOT_SALTED;
7530 dgst_pos0 = 0;
7531 dgst_pos1 = 4;
7532 dgst_pos2 = 3;
7533 dgst_pos3 = 2;
7534 break;
7535
7536 case 200: hash_type = HASH_TYPE_MYSQL;
7537 salt_type = SALT_TYPE_NONE;
7538 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7539 opts_type = 0;
7540 kern_type = KERN_TYPE_MYSQL;
7541 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7542 parse_func = mysql323_parse_hash;
7543 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7544 opti_type = OPTI_TYPE_ZERO_BYTE;
7545 dgst_pos0 = 0;
7546 dgst_pos1 = 1;
7547 dgst_pos2 = 2;
7548 dgst_pos3 = 3;
7549 break;
7550
7551 case 300: hash_type = HASH_TYPE_SHA1;
7552 salt_type = SALT_TYPE_NONE;
7553 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7554 opts_type = OPTS_TYPE_PT_GENERATE_BE
7555 | OPTS_TYPE_PT_ADD80
7556 | OPTS_TYPE_PT_ADDBITS15;
7557 kern_type = KERN_TYPE_MYSQL41;
7558 dgst_size = DGST_SIZE_4_5;
7559 parse_func = sha1_parse_hash;
7560 sort_by_digest = sort_by_digest_4_5;
7561 opti_type = OPTI_TYPE_ZERO_BYTE
7562 | OPTI_TYPE_PRECOMPUTE_INIT
7563 | OPTI_TYPE_PRECOMPUTE_MERKLE
7564 | OPTI_TYPE_EARLY_SKIP
7565 | OPTI_TYPE_NOT_ITERATED
7566 | OPTI_TYPE_NOT_SALTED;
7567 dgst_pos0 = 3;
7568 dgst_pos1 = 4;
7569 dgst_pos2 = 2;
7570 dgst_pos3 = 1;
7571 break;
7572
7573 case 400: 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 kern_type = KERN_TYPE_PHPASS;
7578 dgst_size = DGST_SIZE_4_4;
7579 parse_func = phpass_parse_hash;
7580 sort_by_digest = sort_by_digest_4_4;
7581 opti_type = OPTI_TYPE_ZERO_BYTE;
7582 dgst_pos0 = 0;
7583 dgst_pos1 = 1;
7584 dgst_pos2 = 2;
7585 dgst_pos3 = 3;
7586 break;
7587
7588 case 500: hash_type = HASH_TYPE_MD5;
7589 salt_type = SALT_TYPE_EMBEDDED;
7590 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7591 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7592 kern_type = KERN_TYPE_MD5CRYPT;
7593 dgst_size = DGST_SIZE_4_4;
7594 parse_func = md5crypt_parse_hash;
7595 sort_by_digest = sort_by_digest_4_4;
7596 opti_type = OPTI_TYPE_ZERO_BYTE;
7597 dgst_pos0 = 0;
7598 dgst_pos1 = 1;
7599 dgst_pos2 = 2;
7600 dgst_pos3 = 3;
7601 break;
7602
7603 case 501: hash_type = HASH_TYPE_MD5;
7604 salt_type = SALT_TYPE_EMBEDDED;
7605 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7606 opts_type = OPTS_TYPE_PT_GENERATE_LE
7607 | OPTS_TYPE_HASH_COPY;
7608 kern_type = KERN_TYPE_MD5CRYPT;
7609 dgst_size = DGST_SIZE_4_4;
7610 parse_func = juniper_parse_hash;
7611 sort_by_digest = sort_by_digest_4_4;
7612 opti_type = OPTI_TYPE_ZERO_BYTE;
7613 dgst_pos0 = 0;
7614 dgst_pos1 = 1;
7615 dgst_pos2 = 2;
7616 dgst_pos3 = 3;
7617 break;
7618
7619 case 900: hash_type = HASH_TYPE_MD4;
7620 salt_type = SALT_TYPE_NONE;
7621 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7622 opts_type = OPTS_TYPE_PT_GENERATE_LE
7623 | OPTS_TYPE_PT_ADD80
7624 | OPTS_TYPE_PT_ADDBITS14;
7625 kern_type = KERN_TYPE_MD4;
7626 dgst_size = DGST_SIZE_4_4;
7627 parse_func = md4_parse_hash;
7628 sort_by_digest = sort_by_digest_4_4;
7629 opti_type = OPTI_TYPE_ZERO_BYTE
7630 | OPTI_TYPE_PRECOMPUTE_INIT
7631 | OPTI_TYPE_PRECOMPUTE_MERKLE
7632 | OPTI_TYPE_MEET_IN_MIDDLE
7633 | OPTI_TYPE_EARLY_SKIP
7634 | OPTI_TYPE_NOT_ITERATED
7635 | OPTI_TYPE_NOT_SALTED
7636 | OPTI_TYPE_RAW_HASH;
7637 dgst_pos0 = 0;
7638 dgst_pos1 = 3;
7639 dgst_pos2 = 2;
7640 dgst_pos3 = 1;
7641 break;
7642
7643 case 1000: hash_type = HASH_TYPE_MD4;
7644 salt_type = SALT_TYPE_NONE;
7645 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7646 opts_type = OPTS_TYPE_PT_GENERATE_LE
7647 | OPTS_TYPE_PT_ADD80
7648 | OPTS_TYPE_PT_ADDBITS14
7649 | OPTS_TYPE_PT_UNICODE;
7650 kern_type = KERN_TYPE_MD4_PWU;
7651 dgst_size = DGST_SIZE_4_4;
7652 parse_func = md4_parse_hash;
7653 sort_by_digest = sort_by_digest_4_4;
7654 opti_type = OPTI_TYPE_ZERO_BYTE
7655 | OPTI_TYPE_PRECOMPUTE_INIT
7656 | OPTI_TYPE_PRECOMPUTE_MERKLE
7657 | OPTI_TYPE_MEET_IN_MIDDLE
7658 | OPTI_TYPE_EARLY_SKIP
7659 | OPTI_TYPE_NOT_ITERATED
7660 | OPTI_TYPE_NOT_SALTED
7661 | OPTI_TYPE_RAW_HASH;
7662 dgst_pos0 = 0;
7663 dgst_pos1 = 3;
7664 dgst_pos2 = 2;
7665 dgst_pos3 = 1;
7666 break;
7667
7668 case 1100: hash_type = HASH_TYPE_MD4;
7669 salt_type = SALT_TYPE_INTERN;
7670 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7671 opts_type = OPTS_TYPE_PT_GENERATE_LE
7672 | OPTS_TYPE_PT_ADD80
7673 | OPTS_TYPE_PT_ADDBITS14
7674 | OPTS_TYPE_PT_UNICODE
7675 | OPTS_TYPE_ST_ADD80
7676 | OPTS_TYPE_ST_UNICODE
7677 | OPTS_TYPE_ST_LOWER;
7678 kern_type = KERN_TYPE_MD44_PWUSLT;
7679 dgst_size = DGST_SIZE_4_4;
7680 parse_func = dcc_parse_hash;
7681 sort_by_digest = sort_by_digest_4_4;
7682 opti_type = OPTI_TYPE_ZERO_BYTE
7683 | OPTI_TYPE_PRECOMPUTE_INIT
7684 | OPTI_TYPE_PRECOMPUTE_MERKLE
7685 | OPTI_TYPE_EARLY_SKIP
7686 | OPTI_TYPE_NOT_ITERATED;
7687 dgst_pos0 = 0;
7688 dgst_pos1 = 3;
7689 dgst_pos2 = 2;
7690 dgst_pos3 = 1;
7691 break;
7692
7693 case 1400: hash_type = HASH_TYPE_SHA256;
7694 salt_type = SALT_TYPE_NONE;
7695 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7696 opts_type = OPTS_TYPE_PT_GENERATE_BE
7697 | OPTS_TYPE_PT_ADD80
7698 | OPTS_TYPE_PT_ADDBITS15;
7699 kern_type = KERN_TYPE_SHA256;
7700 dgst_size = DGST_SIZE_4_8;
7701 parse_func = sha256_parse_hash;
7702 sort_by_digest = sort_by_digest_4_8;
7703 opti_type = OPTI_TYPE_ZERO_BYTE
7704 | OPTI_TYPE_PRECOMPUTE_INIT
7705 | OPTI_TYPE_PRECOMPUTE_MERKLE
7706 | OPTI_TYPE_EARLY_SKIP
7707 | OPTI_TYPE_NOT_ITERATED
7708 | OPTI_TYPE_NOT_SALTED
7709 | OPTI_TYPE_RAW_HASH;
7710 dgst_pos0 = 3;
7711 dgst_pos1 = 7;
7712 dgst_pos2 = 2;
7713 dgst_pos3 = 6;
7714 break;
7715
7716 case 1410: hash_type = HASH_TYPE_SHA256;
7717 salt_type = SALT_TYPE_INTERN;
7718 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7719 opts_type = OPTS_TYPE_PT_GENERATE_BE
7720 | OPTS_TYPE_ST_ADD80
7721 | OPTS_TYPE_ST_ADDBITS15;
7722 kern_type = KERN_TYPE_SHA256_PWSLT;
7723 dgst_size = DGST_SIZE_4_8;
7724 parse_func = sha256s_parse_hash;
7725 sort_by_digest = sort_by_digest_4_8;
7726 opti_type = OPTI_TYPE_ZERO_BYTE
7727 | OPTI_TYPE_PRECOMPUTE_INIT
7728 | OPTI_TYPE_PRECOMPUTE_MERKLE
7729 | OPTI_TYPE_EARLY_SKIP
7730 | OPTI_TYPE_NOT_ITERATED
7731 | OPTI_TYPE_APPENDED_SALT
7732 | OPTI_TYPE_RAW_HASH;
7733 dgst_pos0 = 3;
7734 dgst_pos1 = 7;
7735 dgst_pos2 = 2;
7736 dgst_pos3 = 6;
7737 break;
7738
7739 case 1420: hash_type = HASH_TYPE_SHA256;
7740 salt_type = SALT_TYPE_INTERN;
7741 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7742 opts_type = OPTS_TYPE_PT_GENERATE_BE
7743 | OPTS_TYPE_PT_ADD80
7744 | OPTS_TYPE_PT_ADDBITS15;
7745 kern_type = KERN_TYPE_SHA256_SLTPW;
7746 dgst_size = DGST_SIZE_4_8;
7747 parse_func = sha256s_parse_hash;
7748 sort_by_digest = sort_by_digest_4_8;
7749 opti_type = OPTI_TYPE_ZERO_BYTE
7750 | OPTI_TYPE_PRECOMPUTE_INIT
7751 | OPTI_TYPE_PRECOMPUTE_MERKLE
7752 | OPTI_TYPE_EARLY_SKIP
7753 | OPTI_TYPE_NOT_ITERATED
7754 | OPTI_TYPE_PREPENDED_SALT
7755 | OPTI_TYPE_RAW_HASH;
7756 dgst_pos0 = 3;
7757 dgst_pos1 = 7;
7758 dgst_pos2 = 2;
7759 dgst_pos3 = 6;
7760 break;
7761
7762 case 1421: hash_type = HASH_TYPE_SHA256;
7763 salt_type = SALT_TYPE_EMBEDDED;
7764 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7765 opts_type = OPTS_TYPE_PT_GENERATE_BE
7766 | OPTS_TYPE_PT_ADD80
7767 | OPTS_TYPE_PT_ADDBITS15;
7768 kern_type = KERN_TYPE_SHA256_SLTPW;
7769 dgst_size = DGST_SIZE_4_8;
7770 parse_func = hmailserver_parse_hash;
7771 sort_by_digest = sort_by_digest_4_8;
7772 opti_type = OPTI_TYPE_ZERO_BYTE
7773 | OPTI_TYPE_PRECOMPUTE_INIT
7774 | OPTI_TYPE_PRECOMPUTE_MERKLE
7775 | OPTI_TYPE_EARLY_SKIP
7776 | OPTI_TYPE_NOT_ITERATED
7777 | OPTI_TYPE_PREPENDED_SALT
7778 | OPTI_TYPE_RAW_HASH;
7779 dgst_pos0 = 3;
7780 dgst_pos1 = 7;
7781 dgst_pos2 = 2;
7782 dgst_pos3 = 6;
7783 break;
7784
7785 case 1430: hash_type = HASH_TYPE_SHA256;
7786 salt_type = SALT_TYPE_INTERN;
7787 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7788 opts_type = OPTS_TYPE_PT_GENERATE_BE
7789 | OPTS_TYPE_PT_UNICODE
7790 | OPTS_TYPE_ST_ADD80
7791 | OPTS_TYPE_ST_ADDBITS15;
7792 kern_type = KERN_TYPE_SHA256_PWUSLT;
7793 dgst_size = DGST_SIZE_4_8;
7794 parse_func = sha256s_parse_hash;
7795 sort_by_digest = sort_by_digest_4_8;
7796 opti_type = OPTI_TYPE_ZERO_BYTE
7797 | OPTI_TYPE_PRECOMPUTE_INIT
7798 | OPTI_TYPE_PRECOMPUTE_MERKLE
7799 | OPTI_TYPE_EARLY_SKIP
7800 | OPTI_TYPE_NOT_ITERATED
7801 | OPTI_TYPE_APPENDED_SALT
7802 | OPTI_TYPE_RAW_HASH;
7803 dgst_pos0 = 3;
7804 dgst_pos1 = 7;
7805 dgst_pos2 = 2;
7806 dgst_pos3 = 6;
7807 break;
7808
7809 case 1440: hash_type = HASH_TYPE_SHA256;
7810 salt_type = SALT_TYPE_INTERN;
7811 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7812 opts_type = OPTS_TYPE_PT_GENERATE_BE
7813 | OPTS_TYPE_PT_ADD80
7814 | OPTS_TYPE_PT_ADDBITS15
7815 | OPTS_TYPE_PT_UNICODE;
7816 kern_type = KERN_TYPE_SHA256_SLTPWU;
7817 dgst_size = DGST_SIZE_4_8;
7818 parse_func = sha256s_parse_hash;
7819 sort_by_digest = sort_by_digest_4_8;
7820 opti_type = OPTI_TYPE_ZERO_BYTE
7821 | OPTI_TYPE_PRECOMPUTE_INIT
7822 | OPTI_TYPE_PRECOMPUTE_MERKLE
7823 | OPTI_TYPE_EARLY_SKIP
7824 | OPTI_TYPE_NOT_ITERATED
7825 | OPTI_TYPE_PREPENDED_SALT
7826 | OPTI_TYPE_RAW_HASH;
7827 dgst_pos0 = 3;
7828 dgst_pos1 = 7;
7829 dgst_pos2 = 2;
7830 dgst_pos3 = 6;
7831 break;
7832
7833 case 1441: hash_type = HASH_TYPE_SHA256;
7834 salt_type = SALT_TYPE_EMBEDDED;
7835 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7836 opts_type = OPTS_TYPE_PT_GENERATE_BE
7837 | OPTS_TYPE_PT_ADD80
7838 | OPTS_TYPE_PT_ADDBITS15
7839 | OPTS_TYPE_PT_UNICODE
7840 | OPTS_TYPE_ST_BASE64;
7841 kern_type = KERN_TYPE_SHA256_SLTPWU;
7842 dgst_size = DGST_SIZE_4_8;
7843 parse_func = episerver4_parse_hash;
7844 sort_by_digest = sort_by_digest_4_8;
7845 opti_type = OPTI_TYPE_ZERO_BYTE
7846 | OPTI_TYPE_PRECOMPUTE_INIT
7847 | OPTI_TYPE_PRECOMPUTE_MERKLE
7848 | OPTI_TYPE_EARLY_SKIP
7849 | OPTI_TYPE_NOT_ITERATED
7850 | OPTI_TYPE_PREPENDED_SALT
7851 | OPTI_TYPE_RAW_HASH;
7852 dgst_pos0 = 3;
7853 dgst_pos1 = 7;
7854 dgst_pos2 = 2;
7855 dgst_pos3 = 6;
7856 break;
7857
7858 case 1450: hash_type = HASH_TYPE_SHA256;
7859 salt_type = SALT_TYPE_INTERN;
7860 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7861 opts_type = OPTS_TYPE_PT_GENERATE_BE
7862 | OPTS_TYPE_ST_ADD80;
7863 kern_type = KERN_TYPE_HMACSHA256_PW;
7864 dgst_size = DGST_SIZE_4_8;
7865 parse_func = hmacsha256_parse_hash;
7866 sort_by_digest = sort_by_digest_4_8;
7867 opti_type = OPTI_TYPE_ZERO_BYTE
7868 | OPTI_TYPE_NOT_ITERATED;
7869 dgst_pos0 = 3;
7870 dgst_pos1 = 7;
7871 dgst_pos2 = 2;
7872 dgst_pos3 = 6;
7873 break;
7874
7875 case 1460: hash_type = HASH_TYPE_SHA256;
7876 salt_type = SALT_TYPE_INTERN;
7877 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7878 opts_type = OPTS_TYPE_PT_GENERATE_BE
7879 | OPTS_TYPE_PT_ADD80
7880 | OPTS_TYPE_PT_ADDBITS15;
7881 kern_type = KERN_TYPE_HMACSHA256_SLT;
7882 dgst_size = DGST_SIZE_4_8;
7883 parse_func = hmacsha256_parse_hash;
7884 sort_by_digest = sort_by_digest_4_8;
7885 opti_type = OPTI_TYPE_ZERO_BYTE
7886 | OPTI_TYPE_NOT_ITERATED;
7887 dgst_pos0 = 3;
7888 dgst_pos1 = 7;
7889 dgst_pos2 = 2;
7890 dgst_pos3 = 6;
7891 break;
7892
7893 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7894 salt_type = SALT_TYPE_EMBEDDED;
7895 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7896 opts_type = OPTS_TYPE_PT_GENERATE_LE
7897 | OPTS_TYPE_PT_BITSLICE;
7898 kern_type = KERN_TYPE_DESCRYPT;
7899 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7900 parse_func = descrypt_parse_hash;
7901 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7902 opti_type = OPTI_TYPE_ZERO_BYTE
7903 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7904 dgst_pos0 = 0;
7905 dgst_pos1 = 1;
7906 dgst_pos2 = 2;
7907 dgst_pos3 = 3;
7908 break;
7909
7910 case 1600: hash_type = HASH_TYPE_MD5;
7911 salt_type = SALT_TYPE_EMBEDDED;
7912 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7913 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7914 kern_type = KERN_TYPE_APR1CRYPT;
7915 dgst_size = DGST_SIZE_4_4;
7916 parse_func = md5apr1_parse_hash;
7917 sort_by_digest = sort_by_digest_4_4;
7918 opti_type = OPTI_TYPE_ZERO_BYTE;
7919 dgst_pos0 = 0;
7920 dgst_pos1 = 1;
7921 dgst_pos2 = 2;
7922 dgst_pos3 = 3;
7923 break;
7924
7925 case 1700: hash_type = HASH_TYPE_SHA512;
7926 salt_type = SALT_TYPE_NONE;
7927 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7928 opts_type = OPTS_TYPE_PT_GENERATE_BE
7929 | OPTS_TYPE_PT_ADD80
7930 | OPTS_TYPE_PT_ADDBITS15;
7931 kern_type = KERN_TYPE_SHA512;
7932 dgst_size = DGST_SIZE_8_8;
7933 parse_func = sha512_parse_hash;
7934 sort_by_digest = sort_by_digest_8_8;
7935 opti_type = OPTI_TYPE_ZERO_BYTE
7936 | OPTI_TYPE_PRECOMPUTE_INIT
7937 | OPTI_TYPE_PRECOMPUTE_MERKLE
7938 | OPTI_TYPE_EARLY_SKIP
7939 | OPTI_TYPE_NOT_ITERATED
7940 | OPTI_TYPE_NOT_SALTED
7941 | OPTI_TYPE_USES_BITS_64
7942 | OPTI_TYPE_RAW_HASH;
7943 dgst_pos0 = 14;
7944 dgst_pos1 = 15;
7945 dgst_pos2 = 6;
7946 dgst_pos3 = 7;
7947 break;
7948
7949 case 1710: hash_type = HASH_TYPE_SHA512;
7950 salt_type = SALT_TYPE_INTERN;
7951 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7952 opts_type = OPTS_TYPE_PT_GENERATE_BE
7953 | OPTS_TYPE_ST_ADD80
7954 | OPTS_TYPE_ST_ADDBITS15;
7955 kern_type = KERN_TYPE_SHA512_PWSLT;
7956 dgst_size = DGST_SIZE_8_8;
7957 parse_func = sha512s_parse_hash;
7958 sort_by_digest = sort_by_digest_8_8;
7959 opti_type = OPTI_TYPE_ZERO_BYTE
7960 | OPTI_TYPE_PRECOMPUTE_INIT
7961 | OPTI_TYPE_PRECOMPUTE_MERKLE
7962 | OPTI_TYPE_EARLY_SKIP
7963 | OPTI_TYPE_NOT_ITERATED
7964 | OPTI_TYPE_APPENDED_SALT
7965 | OPTI_TYPE_USES_BITS_64
7966 | OPTI_TYPE_RAW_HASH;
7967 dgst_pos0 = 14;
7968 dgst_pos1 = 15;
7969 dgst_pos2 = 6;
7970 dgst_pos3 = 7;
7971 break;
7972
7973 case 1711: hash_type = HASH_TYPE_SHA512;
7974 salt_type = SALT_TYPE_EMBEDDED;
7975 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7976 opts_type = OPTS_TYPE_PT_GENERATE_BE
7977 | OPTS_TYPE_ST_ADD80
7978 | OPTS_TYPE_ST_ADDBITS15;
7979 kern_type = KERN_TYPE_SHA512_PWSLT;
7980 dgst_size = DGST_SIZE_8_8;
7981 parse_func = sha512b64s_parse_hash;
7982 sort_by_digest = sort_by_digest_8_8;
7983 opti_type = OPTI_TYPE_ZERO_BYTE
7984 | OPTI_TYPE_PRECOMPUTE_INIT
7985 | OPTI_TYPE_PRECOMPUTE_MERKLE
7986 | OPTI_TYPE_EARLY_SKIP
7987 | OPTI_TYPE_NOT_ITERATED
7988 | OPTI_TYPE_APPENDED_SALT
7989 | OPTI_TYPE_USES_BITS_64
7990 | OPTI_TYPE_RAW_HASH;
7991 dgst_pos0 = 14;
7992 dgst_pos1 = 15;
7993 dgst_pos2 = 6;
7994 dgst_pos3 = 7;
7995 break;
7996
7997 case 1720: hash_type = HASH_TYPE_SHA512;
7998 salt_type = SALT_TYPE_INTERN;
7999 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8000 opts_type = OPTS_TYPE_PT_GENERATE_BE
8001 | OPTS_TYPE_PT_ADD80
8002 | OPTS_TYPE_PT_ADDBITS15;
8003 kern_type = KERN_TYPE_SHA512_SLTPW;
8004 dgst_size = DGST_SIZE_8_8;
8005 parse_func = sha512s_parse_hash;
8006 sort_by_digest = sort_by_digest_8_8;
8007 opti_type = OPTI_TYPE_ZERO_BYTE
8008 | OPTI_TYPE_PRECOMPUTE_INIT
8009 | OPTI_TYPE_PRECOMPUTE_MERKLE
8010 | OPTI_TYPE_EARLY_SKIP
8011 | OPTI_TYPE_NOT_ITERATED
8012 | OPTI_TYPE_PREPENDED_SALT
8013 | OPTI_TYPE_USES_BITS_64
8014 | OPTI_TYPE_RAW_HASH;
8015 dgst_pos0 = 14;
8016 dgst_pos1 = 15;
8017 dgst_pos2 = 6;
8018 dgst_pos3 = 7;
8019 break;
8020
8021 case 1722: hash_type = HASH_TYPE_SHA512;
8022 salt_type = SALT_TYPE_EMBEDDED;
8023 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8024 opts_type = OPTS_TYPE_PT_GENERATE_BE
8025 | OPTS_TYPE_PT_ADD80
8026 | OPTS_TYPE_PT_ADDBITS15
8027 | OPTS_TYPE_ST_HEX;
8028 kern_type = KERN_TYPE_SHA512_SLTPW;
8029 dgst_size = DGST_SIZE_8_8;
8030 parse_func = osx512_parse_hash;
8031 sort_by_digest = sort_by_digest_8_8;
8032 opti_type = OPTI_TYPE_ZERO_BYTE
8033 | OPTI_TYPE_PRECOMPUTE_INIT
8034 | OPTI_TYPE_PRECOMPUTE_MERKLE
8035 | OPTI_TYPE_EARLY_SKIP
8036 | OPTI_TYPE_NOT_ITERATED
8037 | OPTI_TYPE_PREPENDED_SALT
8038 | OPTI_TYPE_USES_BITS_64
8039 | OPTI_TYPE_RAW_HASH;
8040 dgst_pos0 = 14;
8041 dgst_pos1 = 15;
8042 dgst_pos2 = 6;
8043 dgst_pos3 = 7;
8044 break;
8045
8046 case 1730: hash_type = HASH_TYPE_SHA512;
8047 salt_type = SALT_TYPE_INTERN;
8048 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8049 opts_type = OPTS_TYPE_PT_GENERATE_BE
8050 | OPTS_TYPE_PT_UNICODE
8051 | OPTS_TYPE_ST_ADD80
8052 | OPTS_TYPE_ST_ADDBITS15;
8053 kern_type = KERN_TYPE_SHA512_PWSLTU;
8054 dgst_size = DGST_SIZE_8_8;
8055 parse_func = sha512s_parse_hash;
8056 sort_by_digest = sort_by_digest_8_8;
8057 opti_type = OPTI_TYPE_ZERO_BYTE
8058 | OPTI_TYPE_PRECOMPUTE_INIT
8059 | OPTI_TYPE_PRECOMPUTE_MERKLE
8060 | OPTI_TYPE_EARLY_SKIP
8061 | OPTI_TYPE_NOT_ITERATED
8062 | OPTI_TYPE_APPENDED_SALT
8063 | OPTI_TYPE_USES_BITS_64
8064 | OPTI_TYPE_RAW_HASH;
8065 dgst_pos0 = 14;
8066 dgst_pos1 = 15;
8067 dgst_pos2 = 6;
8068 dgst_pos3 = 7;
8069 break;
8070
8071 case 1731: hash_type = HASH_TYPE_SHA512;
8072 salt_type = SALT_TYPE_EMBEDDED;
8073 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8074 opts_type = OPTS_TYPE_PT_GENERATE_BE
8075 | OPTS_TYPE_PT_UNICODE
8076 | OPTS_TYPE_ST_ADD80
8077 | OPTS_TYPE_ST_ADDBITS15
8078 | OPTS_TYPE_ST_HEX;
8079 kern_type = KERN_TYPE_SHA512_PWSLTU;
8080 dgst_size = DGST_SIZE_8_8;
8081 parse_func = mssql2012_parse_hash;
8082 sort_by_digest = sort_by_digest_8_8;
8083 opti_type = OPTI_TYPE_ZERO_BYTE
8084 | OPTI_TYPE_PRECOMPUTE_INIT
8085 | OPTI_TYPE_PRECOMPUTE_MERKLE
8086 | OPTI_TYPE_EARLY_SKIP
8087 | OPTI_TYPE_NOT_ITERATED
8088 | OPTI_TYPE_APPENDED_SALT
8089 | OPTI_TYPE_USES_BITS_64
8090 | OPTI_TYPE_RAW_HASH;
8091 dgst_pos0 = 14;
8092 dgst_pos1 = 15;
8093 dgst_pos2 = 6;
8094 dgst_pos3 = 7;
8095 break;
8096
8097 case 1740: hash_type = HASH_TYPE_SHA512;
8098 salt_type = SALT_TYPE_INTERN;
8099 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8100 opts_type = OPTS_TYPE_PT_GENERATE_BE
8101 | OPTS_TYPE_PT_ADD80
8102 | OPTS_TYPE_PT_ADDBITS15
8103 | OPTS_TYPE_PT_UNICODE;
8104 kern_type = KERN_TYPE_SHA512_SLTPWU;
8105 dgst_size = DGST_SIZE_8_8;
8106 parse_func = sha512s_parse_hash;
8107 sort_by_digest = sort_by_digest_8_8;
8108 opti_type = OPTI_TYPE_ZERO_BYTE
8109 | OPTI_TYPE_PRECOMPUTE_INIT
8110 | OPTI_TYPE_PRECOMPUTE_MERKLE
8111 | OPTI_TYPE_EARLY_SKIP
8112 | OPTI_TYPE_NOT_ITERATED
8113 | OPTI_TYPE_PREPENDED_SALT
8114 | OPTI_TYPE_USES_BITS_64
8115 | OPTI_TYPE_RAW_HASH;
8116 dgst_pos0 = 14;
8117 dgst_pos1 = 15;
8118 dgst_pos2 = 6;
8119 dgst_pos3 = 7;
8120 break;
8121
8122 case 1750: hash_type = HASH_TYPE_SHA512;
8123 salt_type = SALT_TYPE_INTERN;
8124 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8125 opts_type = OPTS_TYPE_PT_GENERATE_BE
8126 | OPTS_TYPE_ST_ADD80;
8127 kern_type = KERN_TYPE_HMACSHA512_PW;
8128 dgst_size = DGST_SIZE_8_8;
8129 parse_func = hmacsha512_parse_hash;
8130 sort_by_digest = sort_by_digest_8_8;
8131 opti_type = OPTI_TYPE_ZERO_BYTE
8132 | OPTI_TYPE_USES_BITS_64
8133 | OPTI_TYPE_NOT_ITERATED;
8134 dgst_pos0 = 14;
8135 dgst_pos1 = 15;
8136 dgst_pos2 = 6;
8137 dgst_pos3 = 7;
8138 break;
8139
8140 case 1760: hash_type = HASH_TYPE_SHA512;
8141 salt_type = SALT_TYPE_INTERN;
8142 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8143 opts_type = OPTS_TYPE_PT_GENERATE_BE
8144 | OPTS_TYPE_PT_ADD80
8145 | OPTS_TYPE_PT_ADDBITS15;
8146 kern_type = KERN_TYPE_HMACSHA512_SLT;
8147 dgst_size = DGST_SIZE_8_8;
8148 parse_func = hmacsha512_parse_hash;
8149 sort_by_digest = sort_by_digest_8_8;
8150 opti_type = OPTI_TYPE_ZERO_BYTE
8151 | OPTI_TYPE_USES_BITS_64
8152 | OPTI_TYPE_NOT_ITERATED;
8153 dgst_pos0 = 14;
8154 dgst_pos1 = 15;
8155 dgst_pos2 = 6;
8156 dgst_pos3 = 7;
8157 break;
8158
8159 case 1800: hash_type = HASH_TYPE_SHA512;
8160 salt_type = SALT_TYPE_EMBEDDED;
8161 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8162 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8163 kern_type = KERN_TYPE_SHA512CRYPT;
8164 dgst_size = DGST_SIZE_8_8;
8165 parse_func = sha512crypt_parse_hash;
8166 sort_by_digest = sort_by_digest_8_8;
8167 opti_type = OPTI_TYPE_ZERO_BYTE
8168 | OPTI_TYPE_USES_BITS_64;
8169 dgst_pos0 = 0;
8170 dgst_pos1 = 1;
8171 dgst_pos2 = 2;
8172 dgst_pos3 = 3;
8173 break;
8174
8175 case 2100: hash_type = HASH_TYPE_DCC2;
8176 salt_type = SALT_TYPE_EMBEDDED;
8177 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8178 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8179 | OPTS_TYPE_ST_LOWER
8180 | OPTS_TYPE_ST_UNICODE;
8181 kern_type = KERN_TYPE_DCC2;
8182 dgst_size = DGST_SIZE_4_4;
8183 parse_func = dcc2_parse_hash;
8184 sort_by_digest = sort_by_digest_4_4;
8185 opti_type = OPTI_TYPE_ZERO_BYTE;
8186 dgst_pos0 = 0;
8187 dgst_pos1 = 1;
8188 dgst_pos2 = 2;
8189 dgst_pos3 = 3;
8190 break;
8191
8192 case 2400: hash_type = HASH_TYPE_MD5;
8193 salt_type = SALT_TYPE_NONE;
8194 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8195 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8196 kern_type = KERN_TYPE_MD5PIX;
8197 dgst_size = DGST_SIZE_4_4;
8198 parse_func = md5pix_parse_hash;
8199 sort_by_digest = sort_by_digest_4_4;
8200 opti_type = OPTI_TYPE_ZERO_BYTE
8201 | OPTI_TYPE_PRECOMPUTE_INIT
8202 | OPTI_TYPE_PRECOMPUTE_MERKLE
8203 | OPTI_TYPE_EARLY_SKIP
8204 | OPTI_TYPE_NOT_ITERATED
8205 | OPTI_TYPE_NOT_SALTED;
8206 dgst_pos0 = 0;
8207 dgst_pos1 = 3;
8208 dgst_pos2 = 2;
8209 dgst_pos3 = 1;
8210 break;
8211
8212 case 2410: hash_type = HASH_TYPE_MD5;
8213 salt_type = SALT_TYPE_INTERN;
8214 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8215 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8216 kern_type = KERN_TYPE_MD5ASA;
8217 dgst_size = DGST_SIZE_4_4;
8218 parse_func = md5asa_parse_hash;
8219 sort_by_digest = sort_by_digest_4_4;
8220 opti_type = OPTI_TYPE_ZERO_BYTE
8221 | OPTI_TYPE_PRECOMPUTE_INIT
8222 | OPTI_TYPE_PRECOMPUTE_MERKLE
8223 | OPTI_TYPE_EARLY_SKIP
8224 | OPTI_TYPE_NOT_ITERATED;
8225 dgst_pos0 = 0;
8226 dgst_pos1 = 3;
8227 dgst_pos2 = 2;
8228 dgst_pos3 = 1;
8229 break;
8230
8231 case 2500: hash_type = HASH_TYPE_WPA;
8232 salt_type = SALT_TYPE_EMBEDDED;
8233 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8234 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8235 kern_type = KERN_TYPE_WPA;
8236 dgst_size = DGST_SIZE_4_4;
8237 parse_func = wpa_parse_hash;
8238 sort_by_digest = sort_by_digest_4_4;
8239 opti_type = OPTI_TYPE_ZERO_BYTE;
8240 dgst_pos0 = 0;
8241 dgst_pos1 = 1;
8242 dgst_pos2 = 2;
8243 dgst_pos3 = 3;
8244 break;
8245
8246 case 2600: hash_type = HASH_TYPE_MD5;
8247 salt_type = SALT_TYPE_VIRTUAL;
8248 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8249 opts_type = OPTS_TYPE_PT_GENERATE_LE
8250 | OPTS_TYPE_PT_ADD80
8251 | OPTS_TYPE_PT_ADDBITS14
8252 | OPTS_TYPE_ST_ADD80;
8253 kern_type = KERN_TYPE_MD55_PWSLT1;
8254 dgst_size = DGST_SIZE_4_4;
8255 parse_func = md5md5_parse_hash;
8256 sort_by_digest = sort_by_digest_4_4;
8257 opti_type = OPTI_TYPE_ZERO_BYTE
8258 | OPTI_TYPE_PRECOMPUTE_INIT
8259 | OPTI_TYPE_PRECOMPUTE_MERKLE
8260 | OPTI_TYPE_EARLY_SKIP;
8261 dgst_pos0 = 0;
8262 dgst_pos1 = 3;
8263 dgst_pos2 = 2;
8264 dgst_pos3 = 1;
8265 break;
8266
8267 case 2611: hash_type = HASH_TYPE_MD5;
8268 salt_type = SALT_TYPE_INTERN;
8269 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8270 opts_type = OPTS_TYPE_PT_GENERATE_LE
8271 | OPTS_TYPE_PT_ADD80
8272 | OPTS_TYPE_PT_ADDBITS14
8273 | OPTS_TYPE_ST_ADD80;
8274 kern_type = KERN_TYPE_MD55_PWSLT1;
8275 dgst_size = DGST_SIZE_4_4;
8276 parse_func = vb3_parse_hash;
8277 sort_by_digest = sort_by_digest_4_4;
8278 opti_type = OPTI_TYPE_ZERO_BYTE
8279 | OPTI_TYPE_PRECOMPUTE_INIT
8280 | OPTI_TYPE_PRECOMPUTE_MERKLE
8281 | OPTI_TYPE_EARLY_SKIP;
8282 dgst_pos0 = 0;
8283 dgst_pos1 = 3;
8284 dgst_pos2 = 2;
8285 dgst_pos3 = 1;
8286 break;
8287
8288 case 2612: hash_type = HASH_TYPE_MD5;
8289 salt_type = SALT_TYPE_EMBEDDED;
8290 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8291 opts_type = OPTS_TYPE_PT_GENERATE_LE
8292 | OPTS_TYPE_PT_ADD80
8293 | OPTS_TYPE_PT_ADDBITS14
8294 | OPTS_TYPE_ST_ADD80
8295 | OPTS_TYPE_ST_HEX;
8296 kern_type = KERN_TYPE_MD55_PWSLT1;
8297 dgst_size = DGST_SIZE_4_4;
8298 parse_func = phps_parse_hash;
8299 sort_by_digest = sort_by_digest_4_4;
8300 opti_type = OPTI_TYPE_ZERO_BYTE
8301 | OPTI_TYPE_PRECOMPUTE_INIT
8302 | OPTI_TYPE_PRECOMPUTE_MERKLE
8303 | OPTI_TYPE_EARLY_SKIP;
8304 dgst_pos0 = 0;
8305 dgst_pos1 = 3;
8306 dgst_pos2 = 2;
8307 dgst_pos3 = 1;
8308 break;
8309
8310 case 2711: hash_type = HASH_TYPE_MD5;
8311 salt_type = SALT_TYPE_INTERN;
8312 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8313 opts_type = OPTS_TYPE_PT_GENERATE_LE
8314 | OPTS_TYPE_PT_ADD80
8315 | OPTS_TYPE_PT_ADDBITS14
8316 | OPTS_TYPE_ST_ADD80;
8317 kern_type = KERN_TYPE_MD55_PWSLT2;
8318 dgst_size = DGST_SIZE_4_4;
8319 parse_func = vb30_parse_hash;
8320 sort_by_digest = sort_by_digest_4_4;
8321 opti_type = OPTI_TYPE_ZERO_BYTE
8322 | OPTI_TYPE_PRECOMPUTE_INIT
8323 | OPTI_TYPE_EARLY_SKIP;
8324 dgst_pos0 = 0;
8325 dgst_pos1 = 3;
8326 dgst_pos2 = 2;
8327 dgst_pos3 = 1;
8328 break;
8329
8330 case 2811: hash_type = HASH_TYPE_MD5;
8331 salt_type = SALT_TYPE_INTERN;
8332 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8333 opts_type = OPTS_TYPE_PT_GENERATE_LE
8334 | OPTS_TYPE_PT_ADD80
8335 | OPTS_TYPE_PT_ADDBITS14;
8336 kern_type = KERN_TYPE_MD55_SLTPW;
8337 dgst_size = DGST_SIZE_4_4;
8338 parse_func = ipb2_parse_hash;
8339 sort_by_digest = sort_by_digest_4_4;
8340 opti_type = OPTI_TYPE_ZERO_BYTE
8341 | OPTI_TYPE_PRECOMPUTE_INIT
8342 | OPTI_TYPE_EARLY_SKIP;
8343 dgst_pos0 = 0;
8344 dgst_pos1 = 3;
8345 dgst_pos2 = 2;
8346 dgst_pos3 = 1;
8347 break;
8348
8349 case 3000: hash_type = HASH_TYPE_LM;
8350 salt_type = SALT_TYPE_NONE;
8351 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8352 opts_type = OPTS_TYPE_PT_GENERATE_LE
8353 | OPTS_TYPE_PT_UPPER
8354 | OPTS_TYPE_PT_BITSLICE;
8355 kern_type = KERN_TYPE_LM;
8356 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8357 parse_func = lm_parse_hash;
8358 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8359 opti_type = OPTI_TYPE_ZERO_BYTE
8360 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8361 dgst_pos0 = 0;
8362 dgst_pos1 = 1;
8363 dgst_pos2 = 2;
8364 dgst_pos3 = 3;
8365 break;
8366
8367 case 3100: hash_type = HASH_TYPE_ORACLEH;
8368 salt_type = SALT_TYPE_INTERN;
8369 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8370 opts_type = OPTS_TYPE_PT_GENERATE_LE
8371 | OPTS_TYPE_PT_UPPER
8372 | OPTS_TYPE_ST_UPPER;
8373 kern_type = KERN_TYPE_ORACLEH;
8374 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8375 parse_func = oracleh_parse_hash;
8376 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8377 opti_type = OPTI_TYPE_ZERO_BYTE;
8378 dgst_pos0 = 0;
8379 dgst_pos1 = 1;
8380 dgst_pos2 = 2;
8381 dgst_pos3 = 3;
8382 break;
8383
8384 case 3200: hash_type = HASH_TYPE_BCRYPT;
8385 salt_type = SALT_TYPE_EMBEDDED;
8386 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8387 opts_type = OPTS_TYPE_PT_GENERATE_LE
8388 | OPTS_TYPE_ST_GENERATE_LE;
8389 kern_type = KERN_TYPE_BCRYPT;
8390 dgst_size = DGST_SIZE_4_6;
8391 parse_func = bcrypt_parse_hash;
8392 sort_by_digest = sort_by_digest_4_6;
8393 opti_type = OPTI_TYPE_ZERO_BYTE;
8394 dgst_pos0 = 0;
8395 dgst_pos1 = 1;
8396 dgst_pos2 = 2;
8397 dgst_pos3 = 3;
8398 break;
8399
8400 case 3710: hash_type = HASH_TYPE_MD5;
8401 salt_type = SALT_TYPE_INTERN;
8402 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8403 opts_type = OPTS_TYPE_PT_GENERATE_LE
8404 | OPTS_TYPE_PT_ADD80
8405 | OPTS_TYPE_PT_ADDBITS14;
8406 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8407 dgst_size = DGST_SIZE_4_4;
8408 parse_func = md5s_parse_hash;
8409 sort_by_digest = sort_by_digest_4_4;
8410 opti_type = OPTI_TYPE_ZERO_BYTE
8411 | OPTI_TYPE_PRECOMPUTE_INIT
8412 | OPTI_TYPE_PRECOMPUTE_MERKLE
8413 | OPTI_TYPE_EARLY_SKIP;
8414 dgst_pos0 = 0;
8415 dgst_pos1 = 3;
8416 dgst_pos2 = 2;
8417 dgst_pos3 = 1;
8418 break;
8419
8420 case 3711: hash_type = HASH_TYPE_MD5;
8421 salt_type = SALT_TYPE_EMBEDDED;
8422 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8423 opts_type = OPTS_TYPE_PT_GENERATE_LE
8424 | OPTS_TYPE_PT_ADD80
8425 | OPTS_TYPE_PT_ADDBITS14;
8426 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8427 dgst_size = DGST_SIZE_4_4;
8428 parse_func = mediawiki_b_parse_hash;
8429 sort_by_digest = sort_by_digest_4_4;
8430 opti_type = OPTI_TYPE_ZERO_BYTE
8431 | OPTI_TYPE_PRECOMPUTE_INIT
8432 | OPTI_TYPE_PRECOMPUTE_MERKLE
8433 | OPTI_TYPE_EARLY_SKIP;
8434 dgst_pos0 = 0;
8435 dgst_pos1 = 3;
8436 dgst_pos2 = 2;
8437 dgst_pos3 = 1;
8438 break;
8439
8440 case 3800: hash_type = HASH_TYPE_MD5;
8441 salt_type = SALT_TYPE_INTERN;
8442 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8443 opts_type = OPTS_TYPE_PT_GENERATE_LE
8444 | OPTS_TYPE_ST_ADDBITS14;
8445 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8446 dgst_size = DGST_SIZE_4_4;
8447 parse_func = md5s_parse_hash;
8448 sort_by_digest = sort_by_digest_4_4;
8449 opti_type = OPTI_TYPE_ZERO_BYTE
8450 | OPTI_TYPE_PRECOMPUTE_INIT
8451 | OPTI_TYPE_PRECOMPUTE_MERKLE
8452 | OPTI_TYPE_EARLY_SKIP
8453 | OPTI_TYPE_NOT_ITERATED
8454 | OPTI_TYPE_RAW_HASH;
8455 dgst_pos0 = 0;
8456 dgst_pos1 = 3;
8457 dgst_pos2 = 2;
8458 dgst_pos3 = 1;
8459 break;
8460
8461 case 4300: hash_type = HASH_TYPE_MD5;
8462 salt_type = SALT_TYPE_VIRTUAL;
8463 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8464 opts_type = OPTS_TYPE_PT_GENERATE_LE
8465 | OPTS_TYPE_PT_ADD80
8466 | OPTS_TYPE_PT_ADDBITS14
8467 | OPTS_TYPE_ST_ADD80;
8468 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8469 dgst_size = DGST_SIZE_4_4;
8470 parse_func = md5md5_parse_hash;
8471 sort_by_digest = sort_by_digest_4_4;
8472 opti_type = OPTI_TYPE_ZERO_BYTE
8473 | OPTI_TYPE_PRECOMPUTE_INIT
8474 | OPTI_TYPE_PRECOMPUTE_MERKLE
8475 | OPTI_TYPE_EARLY_SKIP;
8476 dgst_pos0 = 0;
8477 dgst_pos1 = 3;
8478 dgst_pos2 = 2;
8479 dgst_pos3 = 1;
8480 break;
8481
8482
8483 case 4400: hash_type = HASH_TYPE_MD5;
8484 salt_type = SALT_TYPE_NONE;
8485 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8486 opts_type = OPTS_TYPE_PT_GENERATE_BE
8487 | OPTS_TYPE_PT_ADD80
8488 | OPTS_TYPE_PT_ADDBITS15;
8489 kern_type = KERN_TYPE_MD5_SHA1;
8490 dgst_size = DGST_SIZE_4_4;
8491 parse_func = md5_parse_hash;
8492 sort_by_digest = sort_by_digest_4_4;
8493 opti_type = OPTI_TYPE_ZERO_BYTE
8494 | OPTI_TYPE_PRECOMPUTE_INIT
8495 | OPTI_TYPE_PRECOMPUTE_MERKLE
8496 | OPTI_TYPE_EARLY_SKIP
8497 | OPTI_TYPE_NOT_ITERATED
8498 | OPTI_TYPE_NOT_SALTED
8499 | OPTI_TYPE_RAW_HASH;
8500 dgst_pos0 = 0;
8501 dgst_pos1 = 3;
8502 dgst_pos2 = 2;
8503 dgst_pos3 = 1;
8504 break;
8505
8506 case 4500: hash_type = HASH_TYPE_SHA1;
8507 salt_type = SALT_TYPE_NONE;
8508 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8509 opts_type = OPTS_TYPE_PT_GENERATE_BE
8510 | OPTS_TYPE_PT_ADD80
8511 | OPTS_TYPE_PT_ADDBITS15;
8512 kern_type = KERN_TYPE_SHA11;
8513 dgst_size = DGST_SIZE_4_5;
8514 parse_func = sha1_parse_hash;
8515 sort_by_digest = sort_by_digest_4_5;
8516 opti_type = OPTI_TYPE_ZERO_BYTE
8517 | OPTI_TYPE_PRECOMPUTE_INIT
8518 | OPTI_TYPE_PRECOMPUTE_MERKLE
8519 | OPTI_TYPE_EARLY_SKIP
8520 | OPTI_TYPE_NOT_SALTED;
8521 dgst_pos0 = 3;
8522 dgst_pos1 = 4;
8523 dgst_pos2 = 2;
8524 dgst_pos3 = 1;
8525 break;
8526
8527 case 4700: hash_type = HASH_TYPE_SHA1;
8528 salt_type = SALT_TYPE_NONE;
8529 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8530 opts_type = OPTS_TYPE_PT_GENERATE_LE
8531 | OPTS_TYPE_PT_ADD80
8532 | OPTS_TYPE_PT_ADDBITS14;
8533 kern_type = KERN_TYPE_SHA1_MD5;
8534 dgst_size = DGST_SIZE_4_5;
8535 parse_func = sha1_parse_hash;
8536 sort_by_digest = sort_by_digest_4_5;
8537 opti_type = OPTI_TYPE_ZERO_BYTE
8538 | OPTI_TYPE_PRECOMPUTE_INIT
8539 | OPTI_TYPE_PRECOMPUTE_MERKLE
8540 | OPTI_TYPE_EARLY_SKIP
8541 | OPTI_TYPE_NOT_ITERATED
8542 | OPTI_TYPE_NOT_SALTED
8543 | OPTI_TYPE_RAW_HASH;
8544 dgst_pos0 = 3;
8545 dgst_pos1 = 4;
8546 dgst_pos2 = 2;
8547 dgst_pos3 = 1;
8548 break;
8549
8550 case 4800: hash_type = HASH_TYPE_MD5;
8551 salt_type = SALT_TYPE_EMBEDDED;
8552 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8553 opts_type = OPTS_TYPE_PT_GENERATE_LE
8554 | OPTS_TYPE_PT_ADDBITS14;
8555 kern_type = KERN_TYPE_MD5_CHAP;
8556 dgst_size = DGST_SIZE_4_4;
8557 parse_func = chap_parse_hash;
8558 sort_by_digest = sort_by_digest_4_4;
8559 opti_type = OPTI_TYPE_ZERO_BYTE
8560 | OPTI_TYPE_PRECOMPUTE_INIT
8561 | OPTI_TYPE_PRECOMPUTE_MERKLE
8562 | OPTI_TYPE_MEET_IN_MIDDLE
8563 | OPTI_TYPE_EARLY_SKIP
8564 | OPTI_TYPE_NOT_ITERATED
8565 | OPTI_TYPE_RAW_HASH;
8566 dgst_pos0 = 0;
8567 dgst_pos1 = 3;
8568 dgst_pos2 = 2;
8569 dgst_pos3 = 1;
8570 break;
8571
8572 case 4900: hash_type = HASH_TYPE_SHA1;
8573 salt_type = SALT_TYPE_INTERN;
8574 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8575 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8576 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8577 dgst_size = DGST_SIZE_4_5;
8578 parse_func = sha1s_parse_hash;
8579 sort_by_digest = sort_by_digest_4_5;
8580 opti_type = OPTI_TYPE_ZERO_BYTE
8581 | OPTI_TYPE_PRECOMPUTE_INIT
8582 | OPTI_TYPE_PRECOMPUTE_MERKLE
8583 | OPTI_TYPE_EARLY_SKIP;
8584 dgst_pos0 = 3;
8585 dgst_pos1 = 4;
8586 dgst_pos2 = 2;
8587 dgst_pos3 = 1;
8588 break;
8589
8590 case 5000: hash_type = HASH_TYPE_KECCAK;
8591 salt_type = SALT_TYPE_EMBEDDED;
8592 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8593 opts_type = OPTS_TYPE_PT_GENERATE_LE
8594 | OPTS_TYPE_PT_ADD01;
8595 kern_type = KERN_TYPE_KECCAK;
8596 dgst_size = DGST_SIZE_8_25;
8597 parse_func = keccak_parse_hash;
8598 sort_by_digest = sort_by_digest_8_25;
8599 opti_type = OPTI_TYPE_ZERO_BYTE
8600 | OPTI_TYPE_USES_BITS_64
8601 | OPTI_TYPE_RAW_HASH;
8602 dgst_pos0 = 2;
8603 dgst_pos1 = 3;
8604 dgst_pos2 = 4;
8605 dgst_pos3 = 5;
8606 break;
8607
8608 case 5100: hash_type = HASH_TYPE_MD5H;
8609 salt_type = SALT_TYPE_NONE;
8610 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8611 opts_type = OPTS_TYPE_PT_GENERATE_LE
8612 | OPTS_TYPE_PT_ADD80
8613 | OPTS_TYPE_PT_ADDBITS14;
8614 kern_type = KERN_TYPE_MD5H;
8615 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8616 parse_func = md5half_parse_hash;
8617 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8618 opti_type = OPTI_TYPE_ZERO_BYTE
8619 | OPTI_TYPE_RAW_HASH;
8620 dgst_pos0 = 0;
8621 dgst_pos1 = 1;
8622 dgst_pos2 = 2;
8623 dgst_pos3 = 3;
8624 break;
8625
8626 case 5200: hash_type = HASH_TYPE_SHA256;
8627 salt_type = SALT_TYPE_EMBEDDED;
8628 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8629 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8630 kern_type = KERN_TYPE_PSAFE3;
8631 dgst_size = DGST_SIZE_4_8;
8632 parse_func = psafe3_parse_hash;
8633 sort_by_digest = sort_by_digest_4_8;
8634 opti_type = OPTI_TYPE_ZERO_BYTE;
8635 dgst_pos0 = 0;
8636 dgst_pos1 = 1;
8637 dgst_pos2 = 2;
8638 dgst_pos3 = 3;
8639 break;
8640
8641 case 5300: hash_type = HASH_TYPE_MD5;
8642 salt_type = SALT_TYPE_EMBEDDED;
8643 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8644 opts_type = OPTS_TYPE_PT_GENERATE_LE
8645 | OPTS_TYPE_ST_ADD80;
8646 kern_type = KERN_TYPE_IKEPSK_MD5;
8647 dgst_size = DGST_SIZE_4_4;
8648 parse_func = ikepsk_md5_parse_hash;
8649 sort_by_digest = sort_by_digest_4_4;
8650 opti_type = OPTI_TYPE_ZERO_BYTE;
8651 dgst_pos0 = 0;
8652 dgst_pos1 = 3;
8653 dgst_pos2 = 2;
8654 dgst_pos3 = 1;
8655 break;
8656
8657 case 5400: hash_type = HASH_TYPE_SHA1;
8658 salt_type = SALT_TYPE_EMBEDDED;
8659 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8660 opts_type = OPTS_TYPE_PT_GENERATE_BE
8661 | OPTS_TYPE_ST_ADD80;
8662 kern_type = KERN_TYPE_IKEPSK_SHA1;
8663 dgst_size = DGST_SIZE_4_5;
8664 parse_func = ikepsk_sha1_parse_hash;
8665 sort_by_digest = sort_by_digest_4_5;
8666 opti_type = OPTI_TYPE_ZERO_BYTE;
8667 dgst_pos0 = 3;
8668 dgst_pos1 = 4;
8669 dgst_pos2 = 2;
8670 dgst_pos3 = 1;
8671 break;
8672
8673 case 5500: hash_type = HASH_TYPE_NETNTLM;
8674 salt_type = SALT_TYPE_EMBEDDED;
8675 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8676 opts_type = OPTS_TYPE_PT_GENERATE_LE
8677 | OPTS_TYPE_PT_ADD80
8678 | OPTS_TYPE_PT_ADDBITS14
8679 | OPTS_TYPE_PT_UNICODE
8680 | OPTS_TYPE_ST_HEX;
8681 kern_type = KERN_TYPE_NETNTLMv1;
8682 dgst_size = DGST_SIZE_4_4;
8683 parse_func = netntlmv1_parse_hash;
8684 sort_by_digest = sort_by_digest_4_4;
8685 opti_type = OPTI_TYPE_ZERO_BYTE
8686 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8687 dgst_pos0 = 0;
8688 dgst_pos1 = 1;
8689 dgst_pos2 = 2;
8690 dgst_pos3 = 3;
8691 break;
8692
8693 case 5600: hash_type = HASH_TYPE_MD5;
8694 salt_type = SALT_TYPE_EMBEDDED;
8695 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8696 opts_type = OPTS_TYPE_PT_GENERATE_LE
8697 | OPTS_TYPE_PT_ADD80
8698 | OPTS_TYPE_PT_ADDBITS14
8699 | OPTS_TYPE_PT_UNICODE;
8700 kern_type = KERN_TYPE_NETNTLMv2;
8701 dgst_size = DGST_SIZE_4_4;
8702 parse_func = netntlmv2_parse_hash;
8703 sort_by_digest = sort_by_digest_4_4;
8704 opti_type = OPTI_TYPE_ZERO_BYTE;
8705 dgst_pos0 = 0;
8706 dgst_pos1 = 3;
8707 dgst_pos2 = 2;
8708 dgst_pos3 = 1;
8709 break;
8710
8711 case 5700: hash_type = HASH_TYPE_SHA256;
8712 salt_type = SALT_TYPE_NONE;
8713 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8714 opts_type = OPTS_TYPE_PT_GENERATE_BE
8715 | OPTS_TYPE_PT_ADD80
8716 | OPTS_TYPE_PT_ADDBITS15;
8717 kern_type = KERN_TYPE_SHA256;
8718 dgst_size = DGST_SIZE_4_8;
8719 parse_func = cisco4_parse_hash;
8720 sort_by_digest = sort_by_digest_4_8;
8721 opti_type = OPTI_TYPE_ZERO_BYTE
8722 | OPTI_TYPE_PRECOMPUTE_INIT
8723 | OPTI_TYPE_PRECOMPUTE_MERKLE
8724 | OPTI_TYPE_EARLY_SKIP
8725 | OPTI_TYPE_NOT_ITERATED
8726 | OPTI_TYPE_NOT_SALTED
8727 | OPTI_TYPE_RAW_HASH;
8728 dgst_pos0 = 3;
8729 dgst_pos1 = 7;
8730 dgst_pos2 = 2;
8731 dgst_pos3 = 6;
8732 break;
8733
8734 case 5800: hash_type = HASH_TYPE_SHA1;
8735 salt_type = SALT_TYPE_INTERN;
8736 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8737 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8738 | OPTS_TYPE_ST_ADD80;
8739 kern_type = KERN_TYPE_ANDROIDPIN;
8740 dgst_size = DGST_SIZE_4_5;
8741 parse_func = androidpin_parse_hash;
8742 sort_by_digest = sort_by_digest_4_5;
8743 opti_type = OPTI_TYPE_ZERO_BYTE;
8744 dgst_pos0 = 0;
8745 dgst_pos1 = 1;
8746 dgst_pos2 = 2;
8747 dgst_pos3 = 3;
8748 break;
8749
8750 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8751 salt_type = SALT_TYPE_NONE;
8752 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8753 opts_type = OPTS_TYPE_PT_GENERATE_LE
8754 | OPTS_TYPE_PT_ADD80;
8755 kern_type = KERN_TYPE_RIPEMD160;
8756 dgst_size = DGST_SIZE_4_5;
8757 parse_func = ripemd160_parse_hash;
8758 sort_by_digest = sort_by_digest_4_5;
8759 opti_type = OPTI_TYPE_ZERO_BYTE;
8760 dgst_pos0 = 0;
8761 dgst_pos1 = 1;
8762 dgst_pos2 = 2;
8763 dgst_pos3 = 3;
8764 break;
8765
8766 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8767 salt_type = SALT_TYPE_NONE;
8768 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8769 opts_type = OPTS_TYPE_PT_GENERATE_BE
8770 | OPTS_TYPE_PT_ADD80;
8771 kern_type = KERN_TYPE_WHIRLPOOL;
8772 dgst_size = DGST_SIZE_4_16;
8773 parse_func = whirlpool_parse_hash;
8774 sort_by_digest = sort_by_digest_4_16;
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 6211: 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_XTS512;
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 6212: hash_type = HASH_TYPE_RIPEMD160;
8798 salt_type = SALT_TYPE_EMBEDDED;
8799 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8800 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8801 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8802 dgst_size = DGST_SIZE_4_5;
8803 parse_func = truecrypt_parse_hash_2k;
8804 sort_by_digest = sort_by_digest_4_5;
8805 opti_type = OPTI_TYPE_ZERO_BYTE;
8806 dgst_pos0 = 0;
8807 dgst_pos1 = 1;
8808 dgst_pos2 = 2;
8809 dgst_pos3 = 3;
8810 break;
8811
8812 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8813 salt_type = SALT_TYPE_EMBEDDED;
8814 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8815 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8816 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8817 dgst_size = DGST_SIZE_4_5;
8818 parse_func = truecrypt_parse_hash_2k;
8819 sort_by_digest = sort_by_digest_4_5;
8820 opti_type = OPTI_TYPE_ZERO_BYTE;
8821 dgst_pos0 = 0;
8822 dgst_pos1 = 1;
8823 dgst_pos2 = 2;
8824 dgst_pos3 = 3;
8825 break;
8826
8827 case 6221: hash_type = HASH_TYPE_SHA512;
8828 salt_type = SALT_TYPE_EMBEDDED;
8829 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8830 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8831 kern_type = KERN_TYPE_TCSHA512_XTS512;
8832 dgst_size = DGST_SIZE_8_8;
8833 parse_func = truecrypt_parse_hash_1k;
8834 sort_by_digest = sort_by_digest_8_8;
8835 opti_type = OPTI_TYPE_ZERO_BYTE
8836 | OPTI_TYPE_USES_BITS_64;
8837 dgst_pos0 = 0;
8838 dgst_pos1 = 1;
8839 dgst_pos2 = 2;
8840 dgst_pos3 = 3;
8841 break;
8842
8843 case 6222: hash_type = HASH_TYPE_SHA512;
8844 salt_type = SALT_TYPE_EMBEDDED;
8845 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8846 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8847 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8848 dgst_size = DGST_SIZE_8_8;
8849 parse_func = truecrypt_parse_hash_1k;
8850 sort_by_digest = sort_by_digest_8_8;
8851 opti_type = OPTI_TYPE_ZERO_BYTE
8852 | OPTI_TYPE_USES_BITS_64;
8853 dgst_pos0 = 0;
8854 dgst_pos1 = 1;
8855 dgst_pos2 = 2;
8856 dgst_pos3 = 3;
8857 break;
8858
8859 case 6223: hash_type = HASH_TYPE_SHA512;
8860 salt_type = SALT_TYPE_EMBEDDED;
8861 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8862 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8863 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8864 dgst_size = DGST_SIZE_8_8;
8865 parse_func = truecrypt_parse_hash_1k;
8866 sort_by_digest = sort_by_digest_8_8;
8867 opti_type = OPTI_TYPE_ZERO_BYTE
8868 | OPTI_TYPE_USES_BITS_64;
8869 dgst_pos0 = 0;
8870 dgst_pos1 = 1;
8871 dgst_pos2 = 2;
8872 dgst_pos3 = 3;
8873 break;
8874
8875 case 6231: 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_XTS512;
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 6232: hash_type = HASH_TYPE_WHIRLPOOL;
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_TCWHIRLPOOL_XTS1024;
8895 dgst_size = DGST_SIZE_4_8;
8896 parse_func = truecrypt_parse_hash_1k;
8897 sort_by_digest = sort_by_digest_4_8;
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 6233: hash_type = HASH_TYPE_WHIRLPOOL;
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_TCWHIRLPOOL_XTS1536;
8910 dgst_size = DGST_SIZE_4_8;
8911 parse_func = truecrypt_parse_hash_1k;
8912 sort_by_digest = sort_by_digest_4_8;
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 6241: 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_XTS512;
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 6242: hash_type = HASH_TYPE_RIPEMD160;
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_TCRIPEMD160_XTS1024;
8940 dgst_size = DGST_SIZE_4_5;
8941 parse_func = truecrypt_parse_hash_1k;
8942 sort_by_digest = sort_by_digest_4_5;
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 6243: hash_type = HASH_TYPE_RIPEMD160;
8951 salt_type = SALT_TYPE_EMBEDDED;
8952 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8953 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8954 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8955 dgst_size = DGST_SIZE_4_5;
8956 parse_func = truecrypt_parse_hash_1k;
8957 sort_by_digest = sort_by_digest_4_5;
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 6300: hash_type = HASH_TYPE_MD5;
8966 salt_type = SALT_TYPE_EMBEDDED;
8967 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8968 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8969 kern_type = KERN_TYPE_MD5AIX;
8970 dgst_size = DGST_SIZE_4_4;
8971 parse_func = md5aix_parse_hash;
8972 sort_by_digest = sort_by_digest_4_4;
8973 opti_type = OPTI_TYPE_ZERO_BYTE;
8974 dgst_pos0 = 0;
8975 dgst_pos1 = 1;
8976 dgst_pos2 = 2;
8977 dgst_pos3 = 3;
8978 break;
8979
8980 case 6400: hash_type = HASH_TYPE_SHA256;
8981 salt_type = SALT_TYPE_EMBEDDED;
8982 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8983 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8984 kern_type = KERN_TYPE_SHA256AIX;
8985 dgst_size = DGST_SIZE_4_8;
8986 parse_func = sha256aix_parse_hash;
8987 sort_by_digest = sort_by_digest_4_8;
8988 opti_type = OPTI_TYPE_ZERO_BYTE;
8989 dgst_pos0 = 0;
8990 dgst_pos1 = 1;
8991 dgst_pos2 = 2;
8992 dgst_pos3 = 3;
8993 break;
8994
8995 case 6500: hash_type = HASH_TYPE_SHA512;
8996 salt_type = SALT_TYPE_EMBEDDED;
8997 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8998 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8999 kern_type = KERN_TYPE_SHA512AIX;
9000 dgst_size = DGST_SIZE_8_8;
9001 parse_func = sha512aix_parse_hash;
9002 sort_by_digest = sort_by_digest_8_8;
9003 opti_type = OPTI_TYPE_ZERO_BYTE
9004 | OPTI_TYPE_USES_BITS_64;
9005 dgst_pos0 = 0;
9006 dgst_pos1 = 1;
9007 dgst_pos2 = 2;
9008 dgst_pos3 = 3;
9009 break;
9010
9011 case 6600: 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_AGILEKEY;
9016 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9017 parse_func = agilekey_parse_hash;
9018 sort_by_digest = sort_by_digest_4_5;
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 6700: hash_type = HASH_TYPE_SHA1;
9027 salt_type = SALT_TYPE_EMBEDDED;
9028 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9029 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9030 kern_type = KERN_TYPE_SHA1AIX;
9031 dgst_size = DGST_SIZE_4_5;
9032 parse_func = sha1aix_parse_hash;
9033 sort_by_digest = sort_by_digest_4_5;
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 6800: hash_type = HASH_TYPE_AES;
9042 salt_type = SALT_TYPE_EMBEDDED;
9043 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9044 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9045 kern_type = KERN_TYPE_LASTPASS;
9046 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9047 parse_func = lastpass_parse_hash;
9048 sort_by_digest = sort_by_digest_4_8;
9049 opti_type = OPTI_TYPE_ZERO_BYTE;
9050 dgst_pos0 = 0;
9051 dgst_pos1 = 1;
9052 dgst_pos2 = 2;
9053 dgst_pos3 = 3;
9054 break;
9055
9056 case 6900: hash_type = HASH_TYPE_GOST;
9057 salt_type = SALT_TYPE_NONE;
9058 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9059 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9060 kern_type = KERN_TYPE_GOST;
9061 dgst_size = DGST_SIZE_4_8;
9062 parse_func = gost_parse_hash;
9063 sort_by_digest = sort_by_digest_4_8;
9064 opti_type = OPTI_TYPE_ZERO_BYTE;
9065 dgst_pos0 = 0;
9066 dgst_pos1 = 1;
9067 dgst_pos2 = 2;
9068 dgst_pos3 = 3;
9069 break;
9070
9071 case 7100: hash_type = HASH_TYPE_SHA512;
9072 salt_type = SALT_TYPE_EMBEDDED;
9073 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9074 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9075 kern_type = KERN_TYPE_PBKDF2_SHA512;
9076 dgst_size = DGST_SIZE_8_16;
9077 parse_func = sha512osx_parse_hash;
9078 sort_by_digest = sort_by_digest_8_16;
9079 opti_type = OPTI_TYPE_ZERO_BYTE
9080 | OPTI_TYPE_USES_BITS_64;
9081 dgst_pos0 = 0;
9082 dgst_pos1 = 1;
9083 dgst_pos2 = 2;
9084 dgst_pos3 = 3;
9085 break;
9086
9087 case 7200: hash_type = HASH_TYPE_SHA512;
9088 salt_type = SALT_TYPE_EMBEDDED;
9089 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9090 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9091 kern_type = KERN_TYPE_PBKDF2_SHA512;
9092 dgst_size = DGST_SIZE_8_16;
9093 parse_func = sha512grub_parse_hash;
9094 sort_by_digest = sort_by_digest_8_16;
9095 opti_type = OPTI_TYPE_ZERO_BYTE
9096 | OPTI_TYPE_USES_BITS_64;
9097 dgst_pos0 = 0;
9098 dgst_pos1 = 1;
9099 dgst_pos2 = 2;
9100 dgst_pos3 = 3;
9101 break;
9102
9103 case 7300: hash_type = HASH_TYPE_SHA1;
9104 salt_type = SALT_TYPE_EMBEDDED;
9105 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9106 opts_type = OPTS_TYPE_PT_GENERATE_BE
9107 | OPTS_TYPE_ST_ADD80
9108 | OPTS_TYPE_ST_ADDBITS15;
9109 kern_type = KERN_TYPE_RAKP;
9110 dgst_size = DGST_SIZE_4_5;
9111 parse_func = rakp_parse_hash;
9112 sort_by_digest = sort_by_digest_4_5;
9113 opti_type = OPTI_TYPE_ZERO_BYTE
9114 | OPTI_TYPE_NOT_ITERATED;
9115 dgst_pos0 = 3;
9116 dgst_pos1 = 4;
9117 dgst_pos2 = 2;
9118 dgst_pos3 = 1;
9119 break;
9120
9121 case 7400: hash_type = HASH_TYPE_SHA256;
9122 salt_type = SALT_TYPE_EMBEDDED;
9123 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9124 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9125 kern_type = KERN_TYPE_SHA256CRYPT;
9126 dgst_size = DGST_SIZE_4_8;
9127 parse_func = sha256crypt_parse_hash;
9128 sort_by_digest = sort_by_digest_4_8;
9129 opti_type = OPTI_TYPE_ZERO_BYTE;
9130 dgst_pos0 = 0;
9131 dgst_pos1 = 1;
9132 dgst_pos2 = 2;
9133 dgst_pos3 = 3;
9134 break;
9135
9136 case 7500: hash_type = HASH_TYPE_KRB5PA;
9137 salt_type = SALT_TYPE_EMBEDDED;
9138 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9139 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9140 kern_type = KERN_TYPE_KRB5PA;
9141 dgst_size = DGST_SIZE_4_4;
9142 parse_func = krb5pa_parse_hash;
9143 sort_by_digest = sort_by_digest_4_4;
9144 opti_type = OPTI_TYPE_ZERO_BYTE
9145 | OPTI_TYPE_NOT_ITERATED;
9146 dgst_pos0 = 0;
9147 dgst_pos1 = 1;
9148 dgst_pos2 = 2;
9149 dgst_pos3 = 3;
9150 break;
9151
9152 case 7600: hash_type = HASH_TYPE_SHA1;
9153 salt_type = SALT_TYPE_INTERN;
9154 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9155 opts_type = OPTS_TYPE_PT_GENERATE_BE
9156 | OPTS_TYPE_PT_ADD80
9157 | OPTS_TYPE_PT_ADDBITS15;
9158 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9159 dgst_size = DGST_SIZE_4_5;
9160 parse_func = redmine_parse_hash;
9161 sort_by_digest = sort_by_digest_4_5;
9162 opti_type = OPTI_TYPE_ZERO_BYTE
9163 | OPTI_TYPE_PRECOMPUTE_INIT
9164 | OPTI_TYPE_EARLY_SKIP
9165 | OPTI_TYPE_NOT_ITERATED
9166 | OPTI_TYPE_PREPENDED_SALT;
9167 dgst_pos0 = 3;
9168 dgst_pos1 = 4;
9169 dgst_pos2 = 2;
9170 dgst_pos3 = 1;
9171 break;
9172
9173 case 7700: hash_type = HASH_TYPE_SAPB;
9174 salt_type = SALT_TYPE_EMBEDDED;
9175 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9176 opts_type = OPTS_TYPE_PT_GENERATE_LE
9177 | OPTS_TYPE_PT_UPPER
9178 | OPTS_TYPE_ST_UPPER;
9179 kern_type = KERN_TYPE_SAPB;
9180 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9181 parse_func = sapb_parse_hash;
9182 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9183 opti_type = OPTI_TYPE_ZERO_BYTE
9184 | OPTI_TYPE_PRECOMPUTE_INIT
9185 | OPTI_TYPE_NOT_ITERATED;
9186 dgst_pos0 = 0;
9187 dgst_pos1 = 1;
9188 dgst_pos2 = 2;
9189 dgst_pos3 = 3;
9190 break;
9191
9192 case 7800: hash_type = HASH_TYPE_SAPG;
9193 salt_type = SALT_TYPE_EMBEDDED;
9194 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9195 opts_type = OPTS_TYPE_PT_GENERATE_BE
9196 | OPTS_TYPE_ST_ADD80
9197 | OPTS_TYPE_ST_UPPER;
9198 kern_type = KERN_TYPE_SAPG;
9199 dgst_size = DGST_SIZE_4_5;
9200 parse_func = sapg_parse_hash;
9201 sort_by_digest = sort_by_digest_4_5;
9202 opti_type = OPTI_TYPE_ZERO_BYTE
9203 | OPTI_TYPE_PRECOMPUTE_INIT
9204 | OPTI_TYPE_NOT_ITERATED;
9205 dgst_pos0 = 3;
9206 dgst_pos1 = 4;
9207 dgst_pos2 = 2;
9208 dgst_pos3 = 1;
9209 break;
9210
9211 case 7900: hash_type = HASH_TYPE_SHA512;
9212 salt_type = SALT_TYPE_EMBEDDED;
9213 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9214 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9215 kern_type = KERN_TYPE_DRUPAL7;
9216 dgst_size = DGST_SIZE_8_8;
9217 parse_func = drupal7_parse_hash;
9218 sort_by_digest = sort_by_digest_8_8;
9219 opti_type = OPTI_TYPE_ZERO_BYTE
9220 | OPTI_TYPE_USES_BITS_64;
9221 dgst_pos0 = 0;
9222 dgst_pos1 = 1;
9223 dgst_pos2 = 2;
9224 dgst_pos3 = 3;
9225 break;
9226
9227 case 8000: hash_type = HASH_TYPE_SHA256;
9228 salt_type = SALT_TYPE_EMBEDDED;
9229 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9230 opts_type = OPTS_TYPE_PT_GENERATE_BE
9231 | OPTS_TYPE_PT_UNICODE
9232 | OPTS_TYPE_ST_ADD80
9233 | OPTS_TYPE_ST_HEX;
9234 kern_type = KERN_TYPE_SYBASEASE;
9235 dgst_size = DGST_SIZE_4_8;
9236 parse_func = sybasease_parse_hash;
9237 sort_by_digest = sort_by_digest_4_8;
9238 opti_type = OPTI_TYPE_ZERO_BYTE
9239 | OPTI_TYPE_PRECOMPUTE_INIT
9240 | OPTI_TYPE_EARLY_SKIP
9241 | OPTI_TYPE_NOT_ITERATED
9242 | OPTI_TYPE_RAW_HASH;
9243 dgst_pos0 = 3;
9244 dgst_pos1 = 7;
9245 dgst_pos2 = 2;
9246 dgst_pos3 = 6;
9247 break;
9248
9249 case 8100: hash_type = HASH_TYPE_SHA1;
9250 salt_type = SALT_TYPE_EMBEDDED;
9251 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9252 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9253 kern_type = KERN_TYPE_NETSCALER;
9254 dgst_size = DGST_SIZE_4_5;
9255 parse_func = netscaler_parse_hash;
9256 sort_by_digest = sort_by_digest_4_5;
9257 opti_type = OPTI_TYPE_ZERO_BYTE
9258 | OPTI_TYPE_PRECOMPUTE_INIT
9259 | OPTI_TYPE_PRECOMPUTE_MERKLE
9260 | OPTI_TYPE_EARLY_SKIP
9261 | OPTI_TYPE_NOT_ITERATED
9262 | OPTI_TYPE_PREPENDED_SALT
9263 | OPTI_TYPE_RAW_HASH;
9264 dgst_pos0 = 3;
9265 dgst_pos1 = 4;
9266 dgst_pos2 = 2;
9267 dgst_pos3 = 1;
9268 break;
9269
9270 case 8200: hash_type = HASH_TYPE_SHA256;
9271 salt_type = SALT_TYPE_EMBEDDED;
9272 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9273 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9274 kern_type = KERN_TYPE_CLOUDKEY;
9275 dgst_size = DGST_SIZE_4_8;
9276 parse_func = cloudkey_parse_hash;
9277 sort_by_digest = sort_by_digest_4_8;
9278 opti_type = OPTI_TYPE_ZERO_BYTE;
9279 dgst_pos0 = 0;
9280 dgst_pos1 = 1;
9281 dgst_pos2 = 2;
9282 dgst_pos3 = 3;
9283 break;
9284
9285 case 8300: hash_type = HASH_TYPE_SHA1;
9286 salt_type = SALT_TYPE_EMBEDDED;
9287 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9288 opts_type = OPTS_TYPE_PT_GENERATE_LE
9289 | OPTS_TYPE_ST_HEX
9290 | OPTS_TYPE_ST_ADD80;
9291 kern_type = KERN_TYPE_NSEC3;
9292 dgst_size = DGST_SIZE_4_5;
9293 parse_func = nsec3_parse_hash;
9294 sort_by_digest = sort_by_digest_4_5;
9295 opti_type = OPTI_TYPE_ZERO_BYTE;
9296 dgst_pos0 = 3;
9297 dgst_pos1 = 4;
9298 dgst_pos2 = 2;
9299 dgst_pos3 = 1;
9300 break;
9301
9302 case 8400: hash_type = HASH_TYPE_SHA1;
9303 salt_type = SALT_TYPE_INTERN;
9304 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9305 opts_type = OPTS_TYPE_PT_GENERATE_BE
9306 | OPTS_TYPE_PT_ADD80
9307 | OPTS_TYPE_PT_ADDBITS15;
9308 kern_type = KERN_TYPE_WBB3;
9309 dgst_size = DGST_SIZE_4_5;
9310 parse_func = wbb3_parse_hash;
9311 sort_by_digest = sort_by_digest_4_5;
9312 opti_type = OPTI_TYPE_ZERO_BYTE
9313 | OPTI_TYPE_PRECOMPUTE_INIT
9314 | OPTI_TYPE_NOT_ITERATED;
9315 dgst_pos0 = 3;
9316 dgst_pos1 = 4;
9317 dgst_pos2 = 2;
9318 dgst_pos3 = 1;
9319 break;
9320
9321 case 8500: hash_type = HASH_TYPE_DESRACF;
9322 salt_type = SALT_TYPE_EMBEDDED;
9323 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9324 opts_type = OPTS_TYPE_PT_GENERATE_LE
9325 | OPTS_TYPE_ST_UPPER;
9326 kern_type = KERN_TYPE_RACF;
9327 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9328 parse_func = racf_parse_hash;
9329 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9330 opti_type = OPTI_TYPE_ZERO_BYTE
9331 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9332 dgst_pos0 = 0;
9333 dgst_pos1 = 1;
9334 dgst_pos2 = 2;
9335 dgst_pos3 = 3;
9336 break;
9337
9338 case 8600: hash_type = HASH_TYPE_LOTUS5;
9339 salt_type = SALT_TYPE_NONE;
9340 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9341 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9342 kern_type = KERN_TYPE_LOTUS5;
9343 dgst_size = DGST_SIZE_4_4;
9344 parse_func = lotus5_parse_hash;
9345 sort_by_digest = sort_by_digest_4_4;
9346 opti_type = OPTI_TYPE_EARLY_SKIP
9347 | OPTI_TYPE_NOT_ITERATED
9348 | OPTI_TYPE_NOT_SALTED
9349 | OPTI_TYPE_RAW_HASH;
9350 dgst_pos0 = 0;
9351 dgst_pos1 = 1;
9352 dgst_pos2 = 2;
9353 dgst_pos3 = 3;
9354 break;
9355
9356 case 8700: hash_type = HASH_TYPE_LOTUS6;
9357 salt_type = SALT_TYPE_EMBEDDED;
9358 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9359 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9360 kern_type = KERN_TYPE_LOTUS6;
9361 dgst_size = DGST_SIZE_4_4;
9362 parse_func = lotus6_parse_hash;
9363 sort_by_digest = sort_by_digest_4_4;
9364 opti_type = OPTI_TYPE_EARLY_SKIP
9365 | OPTI_TYPE_NOT_ITERATED
9366 | OPTI_TYPE_RAW_HASH;
9367 dgst_pos0 = 0;
9368 dgst_pos1 = 1;
9369 dgst_pos2 = 2;
9370 dgst_pos3 = 3;
9371 break;
9372
9373 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9374 salt_type = SALT_TYPE_EMBEDDED;
9375 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9376 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9377 kern_type = KERN_TYPE_ANDROIDFDE;
9378 dgst_size = DGST_SIZE_4_4;
9379 parse_func = androidfde_parse_hash;
9380 sort_by_digest = sort_by_digest_4_4;
9381 opti_type = OPTI_TYPE_ZERO_BYTE;
9382 dgst_pos0 = 0;
9383 dgst_pos1 = 1;
9384 dgst_pos2 = 2;
9385 dgst_pos3 = 3;
9386 break;
9387
9388 case 8900: hash_type = HASH_TYPE_SCRYPT;
9389 salt_type = SALT_TYPE_EMBEDDED;
9390 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9391 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9392 kern_type = KERN_TYPE_SCRYPT;
9393 dgst_size = DGST_SIZE_4_8;
9394 parse_func = scrypt_parse_hash;
9395 sort_by_digest = sort_by_digest_4_8;
9396 opti_type = OPTI_TYPE_ZERO_BYTE;
9397 dgst_pos0 = 0;
9398 dgst_pos1 = 1;
9399 dgst_pos2 = 2;
9400 dgst_pos3 = 3;
9401 break;
9402
9403 case 9000: hash_type = HASH_TYPE_SHA1;
9404 salt_type = SALT_TYPE_EMBEDDED;
9405 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9406 opts_type = OPTS_TYPE_PT_GENERATE_LE
9407 | OPTS_TYPE_ST_GENERATE_LE;
9408 kern_type = KERN_TYPE_PSAFE2;
9409 dgst_size = DGST_SIZE_4_5;
9410 parse_func = psafe2_parse_hash;
9411 sort_by_digest = sort_by_digest_4_5;
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 9100: hash_type = HASH_TYPE_LOTUS8;
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_LOTUS8;
9424 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9425 parse_func = lotus8_parse_hash;
9426 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
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 9200: hash_type = HASH_TYPE_SHA256;
9435 salt_type = SALT_TYPE_EMBEDDED;
9436 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9437 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9438 kern_type = KERN_TYPE_PBKDF2_SHA256;
9439 dgst_size = DGST_SIZE_4_32;
9440 parse_func = cisco8_parse_hash;
9441 sort_by_digest = sort_by_digest_4_32;
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 9300: hash_type = HASH_TYPE_SCRYPT;
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_SCRYPT;
9454 dgst_size = DGST_SIZE_4_8;
9455 parse_func = cisco9_parse_hash;
9456 sort_by_digest = sort_by_digest_4_8;
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 9400: hash_type = HASH_TYPE_OFFICE2007;
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_OFFICE2007;
9469 dgst_size = DGST_SIZE_4_4;
9470 parse_func = office2007_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 9500: hash_type = HASH_TYPE_OFFICE2010;
9480 salt_type = SALT_TYPE_EMBEDDED;
9481 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9482 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9483 kern_type = KERN_TYPE_OFFICE2010;
9484 dgst_size = DGST_SIZE_4_4;
9485 parse_func = office2010_parse_hash;
9486 sort_by_digest = sort_by_digest_4_4;
9487 opti_type = OPTI_TYPE_ZERO_BYTE;
9488 dgst_pos0 = 0;
9489 dgst_pos1 = 1;
9490 dgst_pos2 = 2;
9491 dgst_pos3 = 3;
9492 break;
9493
9494 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9495 salt_type = SALT_TYPE_EMBEDDED;
9496 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9497 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9498 kern_type = KERN_TYPE_OFFICE2013;
9499 dgst_size = DGST_SIZE_4_4;
9500 parse_func = office2013_parse_hash;
9501 sort_by_digest = sort_by_digest_4_4;
9502 opti_type = OPTI_TYPE_ZERO_BYTE;
9503 dgst_pos0 = 0;
9504 dgst_pos1 = 1;
9505 dgst_pos2 = 2;
9506 dgst_pos3 = 3;
9507 break;
9508
9509 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9510 salt_type = SALT_TYPE_EMBEDDED;
9511 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9512 opts_type = OPTS_TYPE_PT_GENERATE_LE
9513 | OPTS_TYPE_PT_ADD80
9514 | OPTS_TYPE_PT_UNICODE;
9515 kern_type = KERN_TYPE_OLDOFFICE01;
9516 dgst_size = DGST_SIZE_4_4;
9517 parse_func = oldoffice01_parse_hash;
9518 sort_by_digest = sort_by_digest_4_4;
9519 opti_type = OPTI_TYPE_ZERO_BYTE
9520 | OPTI_TYPE_PRECOMPUTE_INIT
9521 | OPTI_TYPE_NOT_ITERATED;
9522 dgst_pos0 = 0;
9523 dgst_pos1 = 1;
9524 dgst_pos2 = 2;
9525 dgst_pos3 = 3;
9526 break;
9527
9528 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9529 salt_type = SALT_TYPE_EMBEDDED;
9530 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9531 opts_type = OPTS_TYPE_PT_GENERATE_LE
9532 | OPTS_TYPE_PT_ADD80;
9533 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9534 dgst_size = DGST_SIZE_4_4;
9535 parse_func = oldoffice01cm1_parse_hash;
9536 sort_by_digest = sort_by_digest_4_4;
9537 opti_type = OPTI_TYPE_ZERO_BYTE
9538 | OPTI_TYPE_PRECOMPUTE_INIT
9539 | OPTI_TYPE_NOT_ITERATED;
9540 dgst_pos0 = 0;
9541 dgst_pos1 = 1;
9542 dgst_pos2 = 2;
9543 dgst_pos3 = 3;
9544 break;
9545
9546 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9547 salt_type = SALT_TYPE_EMBEDDED;
9548 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9549 opts_type = OPTS_TYPE_PT_GENERATE_LE
9550 | OPTS_TYPE_PT_ADD80
9551 | OPTS_TYPE_PT_UNICODE
9552 | OPTS_TYPE_PT_NEVERCRACK;
9553 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9554 dgst_size = DGST_SIZE_4_4;
9555 parse_func = oldoffice01cm2_parse_hash;
9556 sort_by_digest = sort_by_digest_4_4;
9557 opti_type = OPTI_TYPE_ZERO_BYTE
9558 | OPTI_TYPE_PRECOMPUTE_INIT
9559 | OPTI_TYPE_NOT_ITERATED;
9560 dgst_pos0 = 0;
9561 dgst_pos1 = 1;
9562 dgst_pos2 = 2;
9563 dgst_pos3 = 3;
9564 break;
9565
9566 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9567 salt_type = SALT_TYPE_EMBEDDED;
9568 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9569 opts_type = OPTS_TYPE_PT_GENERATE_BE
9570 | OPTS_TYPE_PT_ADD80
9571 | OPTS_TYPE_PT_UNICODE;
9572 kern_type = KERN_TYPE_OLDOFFICE34;
9573 dgst_size = DGST_SIZE_4_4;
9574 parse_func = oldoffice34_parse_hash;
9575 sort_by_digest = sort_by_digest_4_4;
9576 opti_type = OPTI_TYPE_ZERO_BYTE
9577 | OPTI_TYPE_PRECOMPUTE_INIT
9578 | OPTI_TYPE_NOT_ITERATED;
9579 dgst_pos0 = 0;
9580 dgst_pos1 = 1;
9581 dgst_pos2 = 2;
9582 dgst_pos3 = 3;
9583 break;
9584
9585 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9586 salt_type = SALT_TYPE_EMBEDDED;
9587 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9588 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9589 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9590 dgst_size = DGST_SIZE_4_4;
9591 parse_func = oldoffice34cm1_parse_hash;
9592 sort_by_digest = sort_by_digest_4_4;
9593 opti_type = OPTI_TYPE_ZERO_BYTE
9594 | OPTI_TYPE_PRECOMPUTE_INIT
9595 | OPTI_TYPE_NOT_ITERATED;
9596 dgst_pos0 = 0;
9597 dgst_pos1 = 1;
9598 dgst_pos2 = 2;
9599 dgst_pos3 = 3;
9600 break;
9601
9602 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9603 salt_type = SALT_TYPE_EMBEDDED;
9604 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9605 opts_type = OPTS_TYPE_PT_GENERATE_BE
9606 | OPTS_TYPE_PT_ADD80
9607 | OPTS_TYPE_PT_UNICODE
9608 | OPTS_TYPE_PT_NEVERCRACK;
9609 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9610 dgst_size = DGST_SIZE_4_4;
9611 parse_func = oldoffice34cm2_parse_hash;
9612 sort_by_digest = sort_by_digest_4_4;
9613 opti_type = OPTI_TYPE_ZERO_BYTE
9614 | OPTI_TYPE_PRECOMPUTE_INIT
9615 | OPTI_TYPE_NOT_ITERATED;
9616 dgst_pos0 = 0;
9617 dgst_pos1 = 1;
9618 dgst_pos2 = 2;
9619 dgst_pos3 = 3;
9620 break;
9621
9622 case 9900: hash_type = HASH_TYPE_MD5;
9623 salt_type = SALT_TYPE_NONE;
9624 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9625 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9626 kern_type = KERN_TYPE_RADMIN2;
9627 dgst_size = DGST_SIZE_4_4;
9628 parse_func = radmin2_parse_hash;
9629 sort_by_digest = sort_by_digest_4_4;
9630 opti_type = OPTI_TYPE_ZERO_BYTE
9631 | OPTI_TYPE_PRECOMPUTE_INIT
9632 | OPTI_TYPE_EARLY_SKIP
9633 | OPTI_TYPE_NOT_ITERATED
9634 | OPTI_TYPE_NOT_SALTED;
9635 dgst_pos0 = 0;
9636 dgst_pos1 = 3;
9637 dgst_pos2 = 2;
9638 dgst_pos3 = 1;
9639 break;
9640
9641 case 10000: hash_type = HASH_TYPE_SHA256;
9642 salt_type = SALT_TYPE_EMBEDDED;
9643 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9644 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9645 kern_type = KERN_TYPE_PBKDF2_SHA256;
9646 dgst_size = DGST_SIZE_4_32;
9647 parse_func = djangopbkdf2_parse_hash;
9648 sort_by_digest = sort_by_digest_4_32;
9649 opti_type = OPTI_TYPE_ZERO_BYTE;
9650 dgst_pos0 = 0;
9651 dgst_pos1 = 1;
9652 dgst_pos2 = 2;
9653 dgst_pos3 = 3;
9654 break;
9655
9656 case 10100: hash_type = HASH_TYPE_SIPHASH;
9657 salt_type = SALT_TYPE_EMBEDDED;
9658 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9659 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9660 kern_type = KERN_TYPE_SIPHASH;
9661 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9662 parse_func = siphash_parse_hash;
9663 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9664 opti_type = OPTI_TYPE_ZERO_BYTE
9665 | OPTI_TYPE_NOT_ITERATED
9666 | OPTI_TYPE_RAW_HASH;
9667 dgst_pos0 = 0;
9668 dgst_pos1 = 1;
9669 dgst_pos2 = 2;
9670 dgst_pos3 = 3;
9671 break;
9672
9673 case 10200: hash_type = HASH_TYPE_MD5;
9674 salt_type = SALT_TYPE_EMBEDDED;
9675 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9676 opts_type = OPTS_TYPE_PT_GENERATE_LE
9677 | OPTS_TYPE_ST_ADD80
9678 | OPTS_TYPE_ST_ADDBITS14;
9679 kern_type = KERN_TYPE_HMACMD5_PW;
9680 dgst_size = DGST_SIZE_4_4;
9681 parse_func = crammd5_parse_hash;
9682 sort_by_digest = sort_by_digest_4_4;
9683 opti_type = OPTI_TYPE_ZERO_BYTE
9684 | OPTI_TYPE_NOT_ITERATED;
9685 dgst_pos0 = 0;
9686 dgst_pos1 = 3;
9687 dgst_pos2 = 2;
9688 dgst_pos3 = 1;
9689 break;
9690
9691 case 10300: hash_type = HASH_TYPE_SHA1;
9692 salt_type = SALT_TYPE_EMBEDDED;
9693 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9694 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9695 kern_type = KERN_TYPE_SAPH_SHA1;
9696 dgst_size = DGST_SIZE_4_5;
9697 parse_func = saph_sha1_parse_hash;
9698 sort_by_digest = sort_by_digest_4_5;
9699 opti_type = OPTI_TYPE_ZERO_BYTE;
9700 dgst_pos0 = 0;
9701 dgst_pos1 = 1;
9702 dgst_pos2 = 2;
9703 dgst_pos3 = 3;
9704 break;
9705
9706 case 10400: hash_type = HASH_TYPE_PDFU16;
9707 salt_type = SALT_TYPE_EMBEDDED;
9708 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9709 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9710 kern_type = KERN_TYPE_PDF11;
9711 dgst_size = DGST_SIZE_4_4;
9712 parse_func = pdf11_parse_hash;
9713 sort_by_digest = sort_by_digest_4_4;
9714 opti_type = OPTI_TYPE_ZERO_BYTE
9715 | OPTI_TYPE_NOT_ITERATED;
9716 dgst_pos0 = 0;
9717 dgst_pos1 = 1;
9718 dgst_pos2 = 2;
9719 dgst_pos3 = 3;
9720 break;
9721
9722 case 10410: hash_type = HASH_TYPE_PDFU16;
9723 salt_type = SALT_TYPE_EMBEDDED;
9724 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9725 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9726 kern_type = KERN_TYPE_PDF11CM1;
9727 dgst_size = DGST_SIZE_4_4;
9728 parse_func = pdf11cm1_parse_hash;
9729 sort_by_digest = sort_by_digest_4_4;
9730 opti_type = OPTI_TYPE_ZERO_BYTE
9731 | OPTI_TYPE_NOT_ITERATED;
9732 dgst_pos0 = 0;
9733 dgst_pos1 = 1;
9734 dgst_pos2 = 2;
9735 dgst_pos3 = 3;
9736 break;
9737
9738 case 10420: hash_type = HASH_TYPE_PDFU16;
9739 salt_type = SALT_TYPE_EMBEDDED;
9740 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9741 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9742 kern_type = KERN_TYPE_PDF11CM2;
9743 dgst_size = DGST_SIZE_4_4;
9744 parse_func = pdf11cm2_parse_hash;
9745 sort_by_digest = sort_by_digest_4_4;
9746 opti_type = OPTI_TYPE_ZERO_BYTE
9747 | OPTI_TYPE_NOT_ITERATED;
9748 dgst_pos0 = 0;
9749 dgst_pos1 = 1;
9750 dgst_pos2 = 2;
9751 dgst_pos3 = 3;
9752 break;
9753
9754 case 10500: hash_type = HASH_TYPE_PDFU16;
9755 salt_type = SALT_TYPE_EMBEDDED;
9756 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9757 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9758 kern_type = KERN_TYPE_PDF14;
9759 dgst_size = DGST_SIZE_4_4;
9760 parse_func = pdf14_parse_hash;
9761 sort_by_digest = sort_by_digest_4_4;
9762 opti_type = OPTI_TYPE_ZERO_BYTE
9763 | OPTI_TYPE_NOT_ITERATED;
9764 dgst_pos0 = 0;
9765 dgst_pos1 = 1;
9766 dgst_pos2 = 2;
9767 dgst_pos3 = 3;
9768 break;
9769
9770 case 10600: hash_type = HASH_TYPE_SHA256;
9771 salt_type = SALT_TYPE_EMBEDDED;
9772 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9773 opts_type = OPTS_TYPE_PT_GENERATE_BE
9774 | OPTS_TYPE_ST_ADD80
9775 | OPTS_TYPE_ST_ADDBITS15
9776 | OPTS_TYPE_HASH_COPY;
9777 kern_type = KERN_TYPE_SHA256_PWSLT;
9778 dgst_size = DGST_SIZE_4_8;
9779 parse_func = pdf17l3_parse_hash;
9780 sort_by_digest = sort_by_digest_4_8;
9781 opti_type = OPTI_TYPE_ZERO_BYTE
9782 | OPTI_TYPE_PRECOMPUTE_INIT
9783 | OPTI_TYPE_PRECOMPUTE_MERKLE
9784 | OPTI_TYPE_EARLY_SKIP
9785 | OPTI_TYPE_NOT_ITERATED
9786 | OPTI_TYPE_APPENDED_SALT
9787 | OPTI_TYPE_RAW_HASH;
9788 dgst_pos0 = 3;
9789 dgst_pos1 = 7;
9790 dgst_pos2 = 2;
9791 dgst_pos3 = 6;
9792 break;
9793
9794 case 10700: hash_type = HASH_TYPE_PDFU32;
9795 salt_type = SALT_TYPE_EMBEDDED;
9796 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9797 opts_type = OPTS_TYPE_PT_GENERATE_LE
9798 | OPTS_TYPE_HASH_COPY;
9799 kern_type = KERN_TYPE_PDF17L8;
9800 dgst_size = DGST_SIZE_4_8;
9801 parse_func = pdf17l8_parse_hash;
9802 sort_by_digest = sort_by_digest_4_8;
9803 opti_type = OPTI_TYPE_ZERO_BYTE
9804 | OPTI_TYPE_NOT_ITERATED;
9805 dgst_pos0 = 0;
9806 dgst_pos1 = 1;
9807 dgst_pos2 = 2;
9808 dgst_pos3 = 3;
9809 break;
9810
9811 case 10800: hash_type = HASH_TYPE_SHA384;
9812 salt_type = SALT_TYPE_NONE;
9813 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9814 opts_type = OPTS_TYPE_PT_GENERATE_BE
9815 | OPTS_TYPE_PT_ADD80
9816 | OPTS_TYPE_PT_ADDBITS15;
9817 kern_type = KERN_TYPE_SHA384;
9818 dgst_size = DGST_SIZE_8_8;
9819 parse_func = sha384_parse_hash;
9820 sort_by_digest = sort_by_digest_8_8;
9821 opti_type = OPTI_TYPE_ZERO_BYTE
9822 | OPTI_TYPE_PRECOMPUTE_INIT
9823 | OPTI_TYPE_PRECOMPUTE_MERKLE
9824 | OPTI_TYPE_EARLY_SKIP
9825 | OPTI_TYPE_NOT_ITERATED
9826 | OPTI_TYPE_NOT_SALTED
9827 | OPTI_TYPE_USES_BITS_64
9828 | OPTI_TYPE_RAW_HASH;
9829 dgst_pos0 = 6;
9830 dgst_pos1 = 7;
9831 dgst_pos2 = 4;
9832 dgst_pos3 = 5;
9833 break;
9834
9835 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9836 salt_type = SALT_TYPE_EMBEDDED;
9837 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9838 opts_type = OPTS_TYPE_PT_GENERATE_LE
9839 | OPTS_TYPE_ST_BASE64
9840 | OPTS_TYPE_HASH_COPY;
9841 kern_type = KERN_TYPE_PBKDF2_SHA256;
9842 dgst_size = DGST_SIZE_4_32;
9843 parse_func = pbkdf2_sha256_parse_hash;
9844 sort_by_digest = sort_by_digest_4_32;
9845 opti_type = OPTI_TYPE_ZERO_BYTE;
9846 dgst_pos0 = 0;
9847 dgst_pos1 = 1;
9848 dgst_pos2 = 2;
9849 dgst_pos3 = 3;
9850 break;
9851
9852 case 11000: hash_type = HASH_TYPE_MD5;
9853 salt_type = SALT_TYPE_INTERN;
9854 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9855 opts_type = OPTS_TYPE_PT_GENERATE_LE
9856 | OPTS_TYPE_PT_ADD80;
9857 kern_type = KERN_TYPE_PRESTASHOP;
9858 dgst_size = DGST_SIZE_4_4;
9859 parse_func = prestashop_parse_hash;
9860 sort_by_digest = sort_by_digest_4_4;
9861 opti_type = OPTI_TYPE_ZERO_BYTE
9862 | OPTI_TYPE_PRECOMPUTE_INIT
9863 | OPTI_TYPE_NOT_ITERATED
9864 | OPTI_TYPE_PREPENDED_SALT;
9865 dgst_pos0 = 0;
9866 dgst_pos1 = 3;
9867 dgst_pos2 = 2;
9868 dgst_pos3 = 1;
9869 break;
9870
9871 case 11100: hash_type = HASH_TYPE_MD5;
9872 salt_type = SALT_TYPE_EMBEDDED;
9873 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9874 opts_type = OPTS_TYPE_PT_GENERATE_LE
9875 | OPTS_TYPE_ST_ADD80;
9876 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9877 dgst_size = DGST_SIZE_4_4;
9878 parse_func = postgresql_auth_parse_hash;
9879 sort_by_digest = sort_by_digest_4_4;
9880 opti_type = OPTI_TYPE_ZERO_BYTE
9881 | OPTI_TYPE_PRECOMPUTE_INIT
9882 | OPTI_TYPE_PRECOMPUTE_MERKLE
9883 | OPTI_TYPE_EARLY_SKIP;
9884 dgst_pos0 = 0;
9885 dgst_pos1 = 3;
9886 dgst_pos2 = 2;
9887 dgst_pos3 = 1;
9888 break;
9889
9890 case 11200: hash_type = HASH_TYPE_SHA1;
9891 salt_type = SALT_TYPE_EMBEDDED;
9892 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9893 opts_type = OPTS_TYPE_PT_GENERATE_BE
9894 | OPTS_TYPE_PT_ADD80
9895 | OPTS_TYPE_ST_HEX;
9896 kern_type = KERN_TYPE_MYSQL_AUTH;
9897 dgst_size = DGST_SIZE_4_5;
9898 parse_func = mysql_auth_parse_hash;
9899 sort_by_digest = sort_by_digest_4_5;
9900 opti_type = OPTI_TYPE_ZERO_BYTE
9901 | OPTI_TYPE_EARLY_SKIP;
9902 dgst_pos0 = 3;
9903 dgst_pos1 = 4;
9904 dgst_pos2 = 2;
9905 dgst_pos3 = 1;
9906 break;
9907
9908 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9909 salt_type = SALT_TYPE_EMBEDDED;
9910 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9911 opts_type = OPTS_TYPE_PT_GENERATE_LE
9912 | OPTS_TYPE_ST_HEX
9913 | OPTS_TYPE_ST_ADD80;
9914 kern_type = KERN_TYPE_BITCOIN_WALLET;
9915 dgst_size = DGST_SIZE_4_4;
9916 parse_func = bitcoin_wallet_parse_hash;
9917 sort_by_digest = sort_by_digest_4_4;
9918 opti_type = OPTI_TYPE_ZERO_BYTE;
9919 dgst_pos0 = 0;
9920 dgst_pos1 = 1;
9921 dgst_pos2 = 2;
9922 dgst_pos3 = 3;
9923 break;
9924
9925 case 11400: hash_type = HASH_TYPE_MD5;
9926 salt_type = SALT_TYPE_EMBEDDED;
9927 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9928 opts_type = OPTS_TYPE_PT_GENERATE_LE
9929 | OPTS_TYPE_PT_ADD80
9930 | OPTS_TYPE_HASH_COPY;
9931 kern_type = KERN_TYPE_SIP_AUTH;
9932 dgst_size = DGST_SIZE_4_4;
9933 parse_func = sip_auth_parse_hash;
9934 sort_by_digest = sort_by_digest_4_4;
9935 opti_type = OPTI_TYPE_ZERO_BYTE;
9936 dgst_pos0 = 0;
9937 dgst_pos1 = 3;
9938 dgst_pos2 = 2;
9939 dgst_pos3 = 1;
9940 break;
9941
9942 case 11500: hash_type = HASH_TYPE_CRC32;
9943 salt_type = SALT_TYPE_INTERN;
9944 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9945 opts_type = OPTS_TYPE_PT_GENERATE_LE
9946 | OPTS_TYPE_ST_GENERATE_LE
9947 | OPTS_TYPE_ST_HEX;
9948 kern_type = KERN_TYPE_CRC32;
9949 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9950 parse_func = crc32_parse_hash;
9951 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9952 opti_type = OPTI_TYPE_ZERO_BYTE;
9953 dgst_pos0 = 0;
9954 dgst_pos1 = 1;
9955 dgst_pos2 = 2;
9956 dgst_pos3 = 3;
9957 break;
9958
9959 case 11600: hash_type = HASH_TYPE_AES;
9960 salt_type = SALT_TYPE_EMBEDDED;
9961 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9962 opts_type = OPTS_TYPE_PT_GENERATE_LE
9963 | OPTS_TYPE_PT_NEVERCRACK;
9964 kern_type = KERN_TYPE_SEVEN_ZIP;
9965 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9966 parse_func = seven_zip_parse_hash;
9967 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9968 opti_type = OPTI_TYPE_ZERO_BYTE;
9969 dgst_pos0 = 0;
9970 dgst_pos1 = 1;
9971 dgst_pos2 = 2;
9972 dgst_pos3 = 3;
9973 break;
9974
9975 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9976 salt_type = SALT_TYPE_NONE;
9977 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9978 opts_type = OPTS_TYPE_PT_GENERATE_LE
9979 | OPTS_TYPE_PT_ADD01;
9980 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9981 dgst_size = DGST_SIZE_4_8;
9982 parse_func = gost2012sbog_256_parse_hash;
9983 sort_by_digest = sort_by_digest_4_8;
9984 opti_type = OPTI_TYPE_ZERO_BYTE;
9985 dgst_pos0 = 0;
9986 dgst_pos1 = 1;
9987 dgst_pos2 = 2;
9988 dgst_pos3 = 3;
9989 break;
9990
9991 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9992 salt_type = SALT_TYPE_NONE;
9993 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9994 opts_type = OPTS_TYPE_PT_GENERATE_LE
9995 | OPTS_TYPE_PT_ADD01;
9996 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9997 dgst_size = DGST_SIZE_4_16;
9998 parse_func = gost2012sbog_512_parse_hash;
9999 sort_by_digest = sort_by_digest_4_16;
10000 opti_type = OPTI_TYPE_ZERO_BYTE;
10001 dgst_pos0 = 0;
10002 dgst_pos1 = 1;
10003 dgst_pos2 = 2;
10004 dgst_pos3 = 3;
10005 break;
10006
10007 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10008 salt_type = SALT_TYPE_EMBEDDED;
10009 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10010 opts_type = OPTS_TYPE_PT_GENERATE_LE
10011 | OPTS_TYPE_ST_BASE64
10012 | OPTS_TYPE_HASH_COPY;
10013 kern_type = KERN_TYPE_PBKDF2_MD5;
10014 dgst_size = DGST_SIZE_4_32;
10015 parse_func = pbkdf2_md5_parse_hash;
10016 sort_by_digest = sort_by_digest_4_32;
10017 opti_type = OPTI_TYPE_ZERO_BYTE;
10018 dgst_pos0 = 0;
10019 dgst_pos1 = 1;
10020 dgst_pos2 = 2;
10021 dgst_pos3 = 3;
10022 break;
10023
10024 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10025 salt_type = SALT_TYPE_EMBEDDED;
10026 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10027 opts_type = OPTS_TYPE_PT_GENERATE_LE
10028 | OPTS_TYPE_ST_BASE64
10029 | OPTS_TYPE_HASH_COPY;
10030 kern_type = KERN_TYPE_PBKDF2_SHA1;
10031 dgst_size = DGST_SIZE_4_32;
10032 parse_func = pbkdf2_sha1_parse_hash;
10033 sort_by_digest = sort_by_digest_4_32;
10034 opti_type = OPTI_TYPE_ZERO_BYTE;
10035 dgst_pos0 = 0;
10036 dgst_pos1 = 1;
10037 dgst_pos2 = 2;
10038 dgst_pos3 = 3;
10039 break;
10040
10041 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10042 salt_type = SALT_TYPE_EMBEDDED;
10043 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10044 opts_type = OPTS_TYPE_PT_GENERATE_LE
10045 | OPTS_TYPE_ST_BASE64
10046 | OPTS_TYPE_HASH_COPY;
10047 kern_type = KERN_TYPE_PBKDF2_SHA512;
10048 dgst_size = DGST_SIZE_8_16;
10049 parse_func = pbkdf2_sha512_parse_hash;
10050 sort_by_digest = sort_by_digest_8_16;
10051 opti_type = OPTI_TYPE_ZERO_BYTE
10052 | OPTI_TYPE_USES_BITS_64;
10053 dgst_pos0 = 0;
10054 dgst_pos1 = 1;
10055 dgst_pos2 = 2;
10056 dgst_pos3 = 3;
10057 break;
10058
10059 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10060 salt_type = SALT_TYPE_EMBEDDED;
10061 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10062 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10063 kern_type = KERN_TYPE_ECRYPTFS;
10064 dgst_size = DGST_SIZE_8_8;
10065 parse_func = ecryptfs_parse_hash;
10066 sort_by_digest = sort_by_digest_8_8;
10067 opti_type = OPTI_TYPE_ZERO_BYTE
10068 | OPTI_TYPE_USES_BITS_64;
10069 dgst_pos0 = 0;
10070 dgst_pos1 = 1;
10071 dgst_pos2 = 2;
10072 dgst_pos3 = 3;
10073 break;
10074
10075 case 12300: hash_type = HASH_TYPE_ORACLET;
10076 salt_type = SALT_TYPE_EMBEDDED;
10077 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10078 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10079 kern_type = KERN_TYPE_ORACLET;
10080 dgst_size = DGST_SIZE_8_16;
10081 parse_func = oraclet_parse_hash;
10082 sort_by_digest = sort_by_digest_8_16;
10083 opti_type = OPTI_TYPE_ZERO_BYTE
10084 | OPTI_TYPE_USES_BITS_64;
10085 dgst_pos0 = 0;
10086 dgst_pos1 = 1;
10087 dgst_pos2 = 2;
10088 dgst_pos3 = 3;
10089 break;
10090
10091 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10092 salt_type = SALT_TYPE_EMBEDDED;
10093 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10094 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10095 kern_type = KERN_TYPE_BSDICRYPT;
10096 dgst_size = DGST_SIZE_4_4;
10097 parse_func = bsdicrypt_parse_hash;
10098 sort_by_digest = sort_by_digest_4_4;
10099 opti_type = OPTI_TYPE_ZERO_BYTE
10100 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10101 dgst_pos0 = 0;
10102 dgst_pos1 = 1;
10103 dgst_pos2 = 2;
10104 dgst_pos3 = 3;
10105 break;
10106
10107 case 12500: hash_type = HASH_TYPE_RAR3HP;
10108 salt_type = SALT_TYPE_EMBEDDED;
10109 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10110 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10111 kern_type = KERN_TYPE_RAR3;
10112 dgst_size = DGST_SIZE_4_4;
10113 parse_func = rar3hp_parse_hash;
10114 sort_by_digest = sort_by_digest_4_4;
10115 opti_type = OPTI_TYPE_ZERO_BYTE;
10116 dgst_pos0 = 0;
10117 dgst_pos1 = 1;
10118 dgst_pos2 = 2;
10119 dgst_pos3 = 3;
10120 break;
10121
10122 case 12600: hash_type = HASH_TYPE_SHA256;
10123 salt_type = SALT_TYPE_INTERN;
10124 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10125 opts_type = OPTS_TYPE_PT_GENERATE_BE
10126 | OPTS_TYPE_PT_ADD80;
10127 kern_type = KERN_TYPE_CF10;
10128 dgst_size = DGST_SIZE_4_8;
10129 parse_func = cf10_parse_hash;
10130 sort_by_digest = sort_by_digest_4_8;
10131 opti_type = OPTI_TYPE_ZERO_BYTE
10132 | OPTI_TYPE_PRECOMPUTE_INIT
10133 | OPTI_TYPE_EARLY_SKIP
10134 | OPTI_TYPE_NOT_ITERATED;
10135 dgst_pos0 = 3;
10136 dgst_pos1 = 7;
10137 dgst_pos2 = 2;
10138 dgst_pos3 = 6;
10139 break;
10140
10141 case 12700: hash_type = HASH_TYPE_AES;
10142 salt_type = SALT_TYPE_EMBEDDED;
10143 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10144 opts_type = OPTS_TYPE_PT_GENERATE_LE
10145 | OPTS_TYPE_HASH_COPY;
10146 kern_type = KERN_TYPE_MYWALLET;
10147 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10148 parse_func = mywallet_parse_hash;
10149 sort_by_digest = sort_by_digest_4_5;
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 12800: 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_MS_DRSR;
10162 dgst_size = DGST_SIZE_4_8;
10163 parse_func = ms_drsr_parse_hash;
10164 sort_by_digest = sort_by_digest_4_8;
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 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10173 salt_type = SALT_TYPE_EMBEDDED;
10174 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10175 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10176 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10177 dgst_size = DGST_SIZE_4_8;
10178 parse_func = androidfde_samsung_parse_hash;
10179 sort_by_digest = sort_by_digest_4_8;
10180 opti_type = OPTI_TYPE_ZERO_BYTE;
10181 dgst_pos0 = 0;
10182 dgst_pos1 = 1;
10183 dgst_pos2 = 2;
10184 dgst_pos3 = 3;
10185 break;
10186
10187 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10188 salt_type = SALT_TYPE_EMBEDDED;
10189 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10190 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10191 kern_type = KERN_TYPE_RAR5;
10192 dgst_size = DGST_SIZE_4_4;
10193 parse_func = rar5_parse_hash;
10194 sort_by_digest = sort_by_digest_4_4;
10195 opti_type = OPTI_TYPE_ZERO_BYTE;
10196 dgst_pos0 = 0;
10197 dgst_pos1 = 1;
10198 dgst_pos2 = 2;
10199 dgst_pos3 = 3;
10200 break;
10201
10202 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10203 salt_type = SALT_TYPE_EMBEDDED;
10204 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10205 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10206 kern_type = KERN_TYPE_KRB5TGS;
10207 dgst_size = DGST_SIZE_4_4;
10208 parse_func = krb5tgs_parse_hash;
10209 sort_by_digest = sort_by_digest_4_4;
10210 opti_type = OPTI_TYPE_ZERO_BYTE
10211 | OPTI_TYPE_NOT_ITERATED;
10212 dgst_pos0 = 0;
10213 dgst_pos1 = 1;
10214 dgst_pos2 = 2;
10215 dgst_pos3 = 3;
10216 break;
10217
10218 default: usage_mini_print (PROGNAME); return (-1);
10219 }
10220
10221 /**
10222 * parser
10223 */
10224
10225 data.parse_func = parse_func;
10226
10227 /**
10228 * misc stuff
10229 */
10230
10231 if (hex_salt)
10232 {
10233 if (salt_type == SALT_TYPE_INTERN)
10234 {
10235 opts_type |= OPTS_TYPE_ST_HEX;
10236 }
10237 else
10238 {
10239 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10240
10241 return (-1);
10242 }
10243 }
10244
10245 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10246 | (salt_type == SALT_TYPE_EXTERN)
10247 | (salt_type == SALT_TYPE_EMBEDDED)
10248 | (salt_type == SALT_TYPE_VIRTUAL));
10249
10250 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10251
10252 data.hash_type = hash_type;
10253 data.attack_mode = attack_mode;
10254 data.attack_kern = attack_kern;
10255 data.attack_exec = attack_exec;
10256 data.kern_type = kern_type;
10257 data.opts_type = opts_type;
10258 data.dgst_size = dgst_size;
10259 data.salt_type = salt_type;
10260 data.isSalted = isSalted;
10261 data.sort_by_digest = sort_by_digest;
10262 data.dgst_pos0 = dgst_pos0;
10263 data.dgst_pos1 = dgst_pos1;
10264 data.dgst_pos2 = dgst_pos2;
10265 data.dgst_pos3 = dgst_pos3;
10266
10267 esalt_size = 0;
10268
10269 switch (hash_mode)
10270 {
10271 case 2500: esalt_size = sizeof (wpa_t); break;
10272 case 5300: esalt_size = sizeof (ikepsk_t); break;
10273 case 5400: esalt_size = sizeof (ikepsk_t); break;
10274 case 5500: esalt_size = sizeof (netntlm_t); break;
10275 case 5600: esalt_size = sizeof (netntlm_t); break;
10276 case 6211: esalt_size = sizeof (tc_t); break;
10277 case 6212: esalt_size = sizeof (tc_t); break;
10278 case 6213: esalt_size = sizeof (tc_t); break;
10279 case 6221: esalt_size = sizeof (tc_t); break;
10280 case 6222: esalt_size = sizeof (tc_t); break;
10281 case 6223: esalt_size = sizeof (tc_t); break;
10282 case 6231: esalt_size = sizeof (tc_t); break;
10283 case 6232: esalt_size = sizeof (tc_t); break;
10284 case 6233: esalt_size = sizeof (tc_t); break;
10285 case 6241: esalt_size = sizeof (tc_t); break;
10286 case 6242: esalt_size = sizeof (tc_t); break;
10287 case 6243: esalt_size = sizeof (tc_t); break;
10288 case 6600: esalt_size = sizeof (agilekey_t); break;
10289 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10290 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10291 case 7300: esalt_size = sizeof (rakp_t); break;
10292 case 7500: esalt_size = sizeof (krb5pa_t); break;
10293 case 8200: esalt_size = sizeof (cloudkey_t); break;
10294 case 8800: esalt_size = sizeof (androidfde_t); break;
10295 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10296 case 9400: esalt_size = sizeof (office2007_t); break;
10297 case 9500: esalt_size = sizeof (office2010_t); break;
10298 case 9600: esalt_size = sizeof (office2013_t); break;
10299 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10300 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10301 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10302 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10303 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10304 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10305 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10306 case 10200: esalt_size = sizeof (cram_md5_t); break;
10307 case 10400: esalt_size = sizeof (pdf_t); break;
10308 case 10410: esalt_size = sizeof (pdf_t); break;
10309 case 10420: esalt_size = sizeof (pdf_t); break;
10310 case 10500: esalt_size = sizeof (pdf_t); break;
10311 case 10600: esalt_size = sizeof (pdf_t); break;
10312 case 10700: esalt_size = sizeof (pdf_t); break;
10313 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10314 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10315 case 11400: esalt_size = sizeof (sip_t); break;
10316 case 11600: esalt_size = sizeof (seven_zip_t); break;
10317 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10318 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10319 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10320 case 13000: esalt_size = sizeof (rar5_t); break;
10321 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10322 }
10323
10324 data.esalt_size = esalt_size;
10325
10326 /**
10327 * choose dictionary parser
10328 */
10329
10330 if (hash_type == HASH_TYPE_LM)
10331 {
10332 get_next_word_func = get_next_word_lm;
10333 }
10334 else if (opts_type & OPTS_TYPE_PT_UPPER)
10335 {
10336 get_next_word_func = get_next_word_uc;
10337 }
10338 else
10339 {
10340 get_next_word_func = get_next_word_std;
10341 }
10342
10343 /**
10344 * dictstat
10345 */
10346
10347 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10348
10349 #ifdef _POSIX
10350 size_t dictstat_nmemb = 0;
10351 #endif
10352
10353 #ifdef _WIN
10354 uint dictstat_nmemb = 0;
10355 #endif
10356
10357 char dictstat[256] = { 0 };
10358
10359 FILE *dictstat_fp = NULL;
10360
10361 if (keyspace == 0)
10362 {
10363 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10364
10365 dictstat_fp = fopen (dictstat, "rb");
10366
10367 if (dictstat_fp)
10368 {
10369 #ifdef _POSIX
10370 struct stat tmpstat;
10371
10372 fstat (fileno (dictstat_fp), &tmpstat);
10373 #endif
10374
10375 #ifdef _WIN
10376 struct stat64 tmpstat;
10377
10378 _fstat64 (fileno (dictstat_fp), &tmpstat);
10379 #endif
10380
10381 if (tmpstat.st_mtime < COMPTIME)
10382 {
10383 /* with v0.15 the format changed so we have to ensure user is using a good version
10384 since there is no version-header in the dictstat file */
10385
10386 fclose (dictstat_fp);
10387
10388 unlink (dictstat);
10389 }
10390 else
10391 {
10392 while (!feof (dictstat_fp))
10393 {
10394 dictstat_t d;
10395
10396 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10397
10398 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10399
10400 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10401 {
10402 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10403
10404 return -1;
10405 }
10406 }
10407
10408 fclose (dictstat_fp);
10409 }
10410 }
10411 }
10412
10413 /**
10414 * potfile
10415 */
10416
10417 char potfile[256] = { 0 };
10418
10419 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10420
10421 data.pot_fp = NULL;
10422
10423 FILE *out_fp = NULL;
10424 FILE *pot_fp = NULL;
10425
10426 if (show == 1 || left == 1)
10427 {
10428 pot_fp = fopen (potfile, "rb");
10429
10430 if (pot_fp == NULL)
10431 {
10432 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10433
10434 return (-1);
10435 }
10436
10437 if (outfile != NULL)
10438 {
10439 if ((out_fp = fopen (outfile, "ab")) == NULL)
10440 {
10441 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10442
10443 fclose (pot_fp);
10444
10445 return (-1);
10446 }
10447 }
10448 else
10449 {
10450 out_fp = stdout;
10451 }
10452 }
10453 else
10454 {
10455 if (potfile_disable == 0)
10456 {
10457 pot_fp = fopen (potfile, "ab");
10458
10459 if (pot_fp == NULL)
10460 {
10461 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10462
10463 return (-1);
10464 }
10465
10466 data.pot_fp = pot_fp;
10467 }
10468 }
10469
10470 pot_t *pot = NULL;
10471
10472 uint pot_cnt = 0;
10473 uint pot_avail = 0;
10474
10475 if (show == 1 || left == 1)
10476 {
10477 SUPPRESS_OUTPUT = 1;
10478
10479 pot_avail = count_lines (pot_fp);
10480
10481 rewind (pot_fp);
10482
10483 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10484
10485 uint pot_hashes_avail = 0;
10486
10487 uint line_num = 0;
10488
10489 while (!feof (pot_fp))
10490 {
10491 line_num++;
10492
10493 char line_buf[BUFSIZ] = { 0 };
10494
10495 int line_len = fgetl (pot_fp, line_buf);
10496
10497 if (line_len == 0) continue;
10498
10499 char *plain_buf = line_buf + line_len;
10500
10501 pot_t *pot_ptr = &pot[pot_cnt];
10502
10503 hash_t *hashes_buf = &pot_ptr->hash;
10504
10505 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10506 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10507
10508 if (pot_cnt == pot_hashes_avail)
10509 {
10510 uint pos = 0;
10511
10512 for (pos = 0; pos < INCR_POT; pos++)
10513 {
10514 if ((pot_cnt + pos) >= pot_avail) break;
10515
10516 pot_t *tmp_pot = &pot[pot_cnt + pos];
10517
10518 hash_t *tmp_hash = &tmp_pot->hash;
10519
10520 tmp_hash->digest = mymalloc (dgst_size);
10521
10522 if (isSalted)
10523 {
10524 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10525 }
10526
10527 if (esalt_size)
10528 {
10529 tmp_hash->esalt = mymalloc (esalt_size);
10530 }
10531
10532 pot_hashes_avail++;
10533 }
10534 }
10535
10536 int plain_len = 0;
10537
10538 int parser_status;
10539
10540 int iter = MAX_CUT_TRIES;
10541
10542 do
10543 {
10544 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10545 {
10546 if (line_buf[i] == ':')
10547 {
10548 line_len--;
10549
10550 break;
10551 }
10552 }
10553
10554 if (data.hash_mode != 2500)
10555 {
10556 parser_status = parse_func (line_buf, line_len, hashes_buf);
10557 }
10558 else
10559 {
10560 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10561
10562 if (line_len > max_salt_size)
10563 {
10564 parser_status = PARSER_GLOBAL_LENGTH;
10565 }
10566 else
10567 {
10568 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10569
10570 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10571
10572 hashes_buf->salt->salt_len = line_len;
10573
10574 parser_status = PARSER_OK;
10575 }
10576 }
10577
10578 // if NOT parsed without error, we add the ":" to the plain
10579
10580 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10581 {
10582 plain_len++;
10583 plain_buf--;
10584 }
10585
10586 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10587
10588 if (parser_status < PARSER_GLOBAL_ZERO)
10589 {
10590 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10591
10592 continue;
10593 }
10594
10595 if (plain_len >= 255) continue;
10596
10597 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10598
10599 pot_ptr->plain_len = plain_len;
10600
10601 pot_cnt++;
10602 }
10603
10604 fclose (pot_fp);
10605
10606 SUPPRESS_OUTPUT = 0;
10607
10608 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10609 }
10610
10611 /**
10612 * word len
10613 */
10614
10615 uint pw_min = PW_MIN;
10616 uint pw_max = PW_MAX;
10617
10618 switch (hash_mode)
10619 {
10620 case 400: if (pw_max > 40) pw_max = 40;
10621 break;
10622 case 500: if (pw_max > 16) pw_max = 16;
10623 break;
10624 case 1500: if (pw_max > 8) pw_max = 8;
10625 break;
10626 case 1600: if (pw_max > 16) pw_max = 16;
10627 break;
10628 case 1800: if (pw_max > 16) pw_max = 16;
10629 break;
10630 case 2100: if (pw_max > 16) pw_max = 16;
10631 break;
10632 case 2500: if (pw_min < 8) pw_min = 8;
10633 break;
10634 case 3000: if (pw_max > 7) pw_max = 7;
10635 break;
10636 case 5200: if (pw_max > 24) pw_max = 24;
10637 break;
10638 case 5800: if (pw_max > 16) pw_max = 16;
10639 break;
10640 case 6300: if (pw_max > 16) pw_max = 16;
10641 break;
10642 case 7400: if (pw_max > 16) pw_max = 16;
10643 break;
10644 case 7900: if (pw_max > 48) pw_max = 48;
10645 break;
10646 case 8500: if (pw_max > 8) pw_max = 8;
10647 break;
10648 case 8600: if (pw_max > 16) pw_max = 16;
10649 break;
10650 case 9710: pw_min = 5;
10651 pw_max = 5;
10652 break;
10653 case 9810: pw_min = 5;
10654 pw_max = 5;
10655 break;
10656 case 10410: pw_min = 5;
10657 pw_max = 5;
10658 break;
10659 case 10300: if (pw_max < 3) pw_min = 3;
10660 if (pw_max > 40) pw_max = 40;
10661 break;
10662 case 10500: if (pw_max < 3) pw_min = 3;
10663 if (pw_max > 40) pw_max = 40;
10664 break;
10665 case 10700: if (pw_max > 16) pw_max = 16;
10666 break;
10667 case 11300: if (pw_max > 40) pw_max = 40;
10668 break;
10669 case 12500: if (pw_max > 20) pw_max = 20;
10670 break;
10671 case 12800: if (pw_max > 24) pw_max = 24;
10672 break;
10673 }
10674
10675 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10676 {
10677 switch (attack_kern)
10678 {
10679 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10680 break;
10681 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10682 break;
10683 }
10684 }
10685
10686 /**
10687 * charsets : keep them together for more easy maintainnce
10688 */
10689
10690 cs_t mp_sys[6] = { { { 0 }, 0 } };
10691 cs_t mp_usr[4] = { { { 0 }, 0 } };
10692
10693 mp_setup_sys (mp_sys);
10694
10695 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10696 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10697 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10698 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10699
10700 /**
10701 * load hashes, part I: find input mode, count hashes
10702 */
10703
10704 uint hashlist_mode = 0;
10705 uint hashlist_format = HLFMT_HASHCAT;
10706
10707 uint hashes_avail = 0;
10708
10709 if (benchmark == 0)
10710 {
10711 struct stat f;
10712
10713 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10714
10715 if ((hash_mode == 2500) ||
10716 (hash_mode == 5200) ||
10717 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10718 (hash_mode == 9000))
10719 {
10720 hashlist_mode = HL_MODE_ARG;
10721
10722 char *hashfile = myargv[optind];
10723
10724 data.hashfile = hashfile;
10725
10726 logfile_top_var_string ("target", hashfile);
10727 }
10728
10729 if (hashlist_mode == HL_MODE_ARG)
10730 {
10731 if (hash_mode == 2500)
10732 {
10733 struct stat st;
10734
10735 if (stat (data.hashfile, &st) == -1)
10736 {
10737 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10738
10739 return (-1);
10740 }
10741
10742 hashes_avail = st.st_size / sizeof (hccap_t);
10743 }
10744 else
10745 {
10746 hashes_avail = 1;
10747 }
10748 }
10749 else if (hashlist_mode == HL_MODE_FILE)
10750 {
10751 char *hashfile = myargv[optind];
10752
10753 data.hashfile = hashfile;
10754
10755 logfile_top_var_string ("target", hashfile);
10756
10757 FILE *fp = NULL;
10758
10759 if ((fp = fopen (hashfile, "rb")) == NULL)
10760 {
10761 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10762
10763 return (-1);
10764 }
10765
10766 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10767
10768 hashes_avail = count_lines (fp);
10769
10770 rewind (fp);
10771
10772 if (hashes_avail == 0)
10773 {
10774 log_error ("ERROR: hashfile is empty or corrupt");
10775
10776 fclose (fp);
10777
10778 return (-1);
10779 }
10780
10781 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10782
10783 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10784 {
10785 log_error ("ERROR: remove not supported in native hashfile-format mode");
10786
10787 fclose (fp);
10788
10789 return (-1);
10790 }
10791
10792 fclose (fp);
10793 }
10794 }
10795 else
10796 {
10797 hashlist_mode = HL_MODE_ARG;
10798
10799 hashes_avail = 1;
10800 }
10801
10802 if (hash_mode == 3000) hashes_avail *= 2;
10803
10804 data.hashlist_mode = hashlist_mode;
10805 data.hashlist_format = hashlist_format;
10806
10807 logfile_top_uint (hashlist_mode);
10808 logfile_top_uint (hashlist_format);
10809
10810 /**
10811 * load hashes, part II: allocate required memory, set pointers
10812 */
10813
10814 hash_t *hashes_buf = NULL;
10815 void *digests_buf = NULL;
10816 salt_t *salts_buf = NULL;
10817 void *esalts_buf = NULL;
10818
10819 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10820
10821 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10822
10823 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10824 {
10825 u32 hash_pos;
10826
10827 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10828 {
10829 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10830
10831 hashes_buf[hash_pos].hash_info = hash_info;
10832
10833 if (username && (remove || show || left))
10834 {
10835 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10836 }
10837
10838 if (benchmark)
10839 {
10840 hash_info->orighash = (char *) mymalloc (256);
10841 }
10842 }
10843 }
10844
10845 if (isSalted)
10846 {
10847 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10848
10849 if (esalt_size)
10850 {
10851 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10852 }
10853 }
10854 else
10855 {
10856 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10857 }
10858
10859 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10860 {
10861 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10862
10863 if (isSalted)
10864 {
10865 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10866
10867 if (esalt_size)
10868 {
10869 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10870 }
10871 }
10872 else
10873 {
10874 hashes_buf[hash_pos].salt = &salts_buf[0];
10875 }
10876 }
10877
10878 /**
10879 * load hashes, part III: parse hashes or generate them if benchmark
10880 */
10881
10882 uint hashes_cnt = 0;
10883
10884 if (benchmark == 0)
10885 {
10886 if (keyspace == 1)
10887 {
10888 // useless to read hash file for keyspace, cheat a little bit w/ optind
10889 }
10890 else if (hashes_avail == 0)
10891 {
10892 }
10893 else if (hashlist_mode == HL_MODE_ARG)
10894 {
10895 char *input_buf = myargv[optind];
10896
10897 uint input_len = strlen (input_buf);
10898
10899 logfile_top_var_string ("target", input_buf);
10900
10901 char *hash_buf = NULL;
10902 int hash_len = 0;
10903
10904 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10905
10906 if (hash_len)
10907 {
10908 if (opts_type & OPTS_TYPE_HASH_COPY)
10909 {
10910 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10911
10912 hash_info_tmp->orighash = mystrdup (hash_buf);
10913 }
10914
10915 if (isSalted)
10916 {
10917 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10918 }
10919
10920 int parser_status = PARSER_OK;
10921
10922 if (hash_mode == 2500)
10923 {
10924 if (hash_len == 0)
10925 {
10926 log_error ("ERROR: hccap file not specified");
10927
10928 return (-1);
10929 }
10930
10931 hashlist_mode = HL_MODE_FILE;
10932
10933 data.hashlist_mode = hashlist_mode;
10934
10935 FILE *fp = fopen (hash_buf, "rb");
10936
10937 if (fp == NULL)
10938 {
10939 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10940
10941 return (-1);
10942 }
10943
10944 if (hashes_avail < 1)
10945 {
10946 log_error ("ERROR: hccap file is empty or corrupt");
10947
10948 fclose (fp);
10949
10950 return (-1);
10951 }
10952
10953 uint hccap_size = sizeof (hccap_t);
10954
10955 char *in = (char *) mymalloc (hccap_size);
10956
10957 while (!feof (fp))
10958 {
10959 int n = fread (in, hccap_size, 1, fp);
10960
10961 if (n != 1)
10962 {
10963 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10964
10965 break;
10966 }
10967
10968 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10969
10970 if (parser_status != PARSER_OK)
10971 {
10972 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10973
10974 continue;
10975 }
10976
10977 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10978
10979 if ((show == 1) || (left == 1))
10980 {
10981 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10982
10983 char *salt_ptr = (char *) tmp_salt->salt_buf;
10984
10985 int cur_pos = tmp_salt->salt_len;
10986 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10987
10988 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10989
10990 u8 *pke_ptr = (u8 *) wpa->pke;
10991
10992 // do the appending task
10993
10994 snprintf (salt_ptr + cur_pos,
10995 rem_len,
10996 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10997 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10998 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10999
11000
11001 // memset () the remaining part of the salt
11002
11003 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11004 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11005
11006 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11007
11008 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11009 }
11010
11011 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);
11012 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);
11013
11014 hashes_cnt++;
11015 }
11016
11017 fclose (fp);
11018
11019 myfree (in);
11020 }
11021 else if (hash_mode == 3000)
11022 {
11023 if (hash_len == 32)
11024 {
11025 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11026
11027 hash_t *lm_hash_left = NULL;
11028
11029 if (parser_status == PARSER_OK)
11030 {
11031 lm_hash_left = &hashes_buf[hashes_cnt];
11032
11033 hashes_cnt++;
11034 }
11035 else
11036 {
11037 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11038 }
11039
11040 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11041
11042 hash_t *lm_hash_right = NULL;
11043
11044 if (parser_status == PARSER_OK)
11045 {
11046 lm_hash_right = &hashes_buf[hashes_cnt];
11047
11048 hashes_cnt++;
11049 }
11050 else
11051 {
11052 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11053 }
11054
11055 // show / left
11056
11057 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11058 {
11059 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);
11060 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);
11061 }
11062 }
11063 else
11064 {
11065 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11066
11067 if (parser_status == PARSER_OK)
11068 {
11069 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11070 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11071 }
11072
11073 if (parser_status == PARSER_OK)
11074 {
11075 hashes_cnt++;
11076 }
11077 else
11078 {
11079 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11080 }
11081 }
11082 }
11083 else
11084 {
11085 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11086
11087 if (parser_status == PARSER_OK)
11088 {
11089 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11090 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11091 }
11092
11093 if (parser_status == PARSER_OK)
11094 {
11095 hashes_cnt++;
11096 }
11097 else
11098 {
11099 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11100 }
11101 }
11102 }
11103 }
11104 else if (hashlist_mode == HL_MODE_FILE)
11105 {
11106 char *hashfile = data.hashfile;
11107
11108 FILE *fp;
11109
11110 if ((fp = fopen (hashfile, "rb")) == NULL)
11111 {
11112 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11113
11114 return (-1);
11115 }
11116
11117 uint line_num = 0;
11118
11119 while (!feof (fp))
11120 {
11121 line_num++;
11122
11123 char line_buf[BUFSIZ] = { 0 };
11124
11125 int line_len = fgetl (fp, line_buf);
11126
11127 if (line_len == 0) continue;
11128
11129 char *hash_buf = NULL;
11130 int hash_len = 0;
11131
11132 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11133
11134 if (username)
11135 {
11136 char *user_buf = NULL;
11137 int user_len = 0;
11138
11139 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11140
11141 if (remove || show)
11142 {
11143 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11144
11145 *user = (user_t *) mymalloc (sizeof (user_t));
11146
11147 user_t *user_ptr = *user;
11148
11149 if (user_buf != NULL)
11150 {
11151 user_ptr->user_name = mystrdup (user_buf);
11152 }
11153 else
11154 {
11155 user_ptr->user_name = mystrdup ("");
11156 }
11157
11158 user_ptr->user_len = user_len;
11159 }
11160 }
11161
11162 if (opts_type & OPTS_TYPE_HASH_COPY)
11163 {
11164 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11165
11166 hash_info_tmp->orighash = mystrdup (hash_buf);
11167 }
11168
11169 if (isSalted)
11170 {
11171 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11172 }
11173
11174 if (hash_mode == 3000)
11175 {
11176 if (hash_len == 32)
11177 {
11178 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11179
11180 if (parser_status < PARSER_GLOBAL_ZERO)
11181 {
11182 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11183
11184 continue;
11185 }
11186
11187 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11188
11189 hashes_cnt++;
11190
11191 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11192
11193 if (parser_status < PARSER_GLOBAL_ZERO)
11194 {
11195 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11196
11197 continue;
11198 }
11199
11200 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11201
11202 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);
11203
11204 hashes_cnt++;
11205
11206 // show / left
11207
11208 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);
11209 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);
11210 }
11211 else
11212 {
11213 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11214
11215 if (parser_status < PARSER_GLOBAL_ZERO)
11216 {
11217 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11218
11219 continue;
11220 }
11221
11222 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);
11223
11224 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11225 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11226
11227 hashes_cnt++;
11228 }
11229 }
11230 else
11231 {
11232 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11233
11234 if (parser_status < PARSER_GLOBAL_ZERO)
11235 {
11236 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11237
11238 continue;
11239 }
11240
11241 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);
11242
11243 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11244 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11245
11246 hashes_cnt++;
11247 }
11248 }
11249
11250 fclose (fp);
11251
11252 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11253
11254 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11255 }
11256 }
11257 else
11258 {
11259 if (isSalted)
11260 {
11261 hashes_buf[0].salt->salt_len = 8;
11262
11263 // special salt handling
11264
11265 switch (hash_mode)
11266 {
11267 case 1500: hashes_buf[0].salt->salt_len = 2;
11268 break;
11269 case 1731: hashes_buf[0].salt->salt_len = 4;
11270 break;
11271 case 2410: hashes_buf[0].salt->salt_len = 4;
11272 break;
11273 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11274 break;
11275 case 3100: hashes_buf[0].salt->salt_len = 1;
11276 break;
11277 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11278 break;
11279 case 5800: hashes_buf[0].salt->salt_len = 16;
11280 break;
11281 case 6800: hashes_buf[0].salt->salt_len = 32;
11282 break;
11283 case 8400: hashes_buf[0].salt->salt_len = 40;
11284 break;
11285 case 8800: hashes_buf[0].salt->salt_len = 16;
11286 break;
11287 case 8900: hashes_buf[0].salt->salt_len = 16;
11288 hashes_buf[0].salt->scrypt_N = 1024;
11289 hashes_buf[0].salt->scrypt_r = 1;
11290 hashes_buf[0].salt->scrypt_p = 1;
11291 break;
11292 case 9100: hashes_buf[0].salt->salt_len = 16;
11293 break;
11294 case 9300: hashes_buf[0].salt->salt_len = 14;
11295 hashes_buf[0].salt->scrypt_N = 16384;
11296 hashes_buf[0].salt->scrypt_r = 1;
11297 hashes_buf[0].salt->scrypt_p = 1;
11298 break;
11299 case 9400: hashes_buf[0].salt->salt_len = 16;
11300 break;
11301 case 9500: hashes_buf[0].salt->salt_len = 16;
11302 break;
11303 case 9600: hashes_buf[0].salt->salt_len = 16;
11304 break;
11305 case 9700: hashes_buf[0].salt->salt_len = 16;
11306 break;
11307 case 9710: hashes_buf[0].salt->salt_len = 16;
11308 break;
11309 case 9720: hashes_buf[0].salt->salt_len = 16;
11310 break;
11311 case 9800: hashes_buf[0].salt->salt_len = 16;
11312 break;
11313 case 9810: hashes_buf[0].salt->salt_len = 16;
11314 break;
11315 case 9820: hashes_buf[0].salt->salt_len = 16;
11316 break;
11317 case 10300: hashes_buf[0].salt->salt_len = 12;
11318 break;
11319 case 11500: hashes_buf[0].salt->salt_len = 4;
11320 break;
11321 case 11600: hashes_buf[0].salt->salt_len = 4;
11322 break;
11323 case 12400: hashes_buf[0].salt->salt_len = 4;
11324 break;
11325 case 12500: hashes_buf[0].salt->salt_len = 8;
11326 break;
11327 case 12600: hashes_buf[0].salt->salt_len = 64;
11328 break;
11329 }
11330
11331 // special esalt handling
11332
11333 switch (hash_mode)
11334 {
11335 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11336 break;
11337 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11338 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11339 break;
11340 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11341 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11342 break;
11343 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11344 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11345 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11346 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11347 break;
11348 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11349 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11350 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11351 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11352 break;
11353 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11354 break;
11355 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11356 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11357 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11358 break;
11359 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11360 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11361 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11362 break;
11363 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11364 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11365 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11366 break;
11367 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11368 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11369 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11370 break;
11371 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11372 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11373 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11374 break;
11375 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11376 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11377 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11378 break;
11379 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11380 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11381 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11382 break;
11383 }
11384 }
11385
11386 // set hashfile
11387
11388 switch (hash_mode)
11389 {
11390 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11391 break;
11392 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11393 break;
11394 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11395 break;
11396 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11397 break;
11398 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11399 break;
11400 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11401 break;
11402 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11403 break;
11404 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11405 break;
11406 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11407 break;
11408 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11409 break;
11410 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11411 break;
11412 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11413 break;
11414 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11415 break;
11416 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11417 break;
11418 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11419 break;
11420 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11421 break;
11422 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11423 break;
11424 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11425 break;
11426 }
11427
11428 // set default iterations
11429
11430 switch (hash_mode)
11431 {
11432 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11433 break;
11434 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11435 break;
11436 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11437 break;
11438 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11439 break;
11440 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11441 break;
11442 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11443 break;
11444 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11445 break;
11446 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11447 break;
11448 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11449 break;
11450 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11451 break;
11452 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11453 break;
11454 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11455 break;
11456 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11457 break;
11458 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11459 break;
11460 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11461 break;
11462 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11463 break;
11464 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11465 break;
11466 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11467 break;
11468 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11469 break;
11470 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11471 break;
11472 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11473 break;
11474 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11475 break;
11476 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11477 break;
11478 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11479 break;
11480 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11481 break;
11482 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11483 break;
11484 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11485 break;
11486 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11487 break;
11488 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11489 break;
11490 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11491 break;
11492 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11493 break;
11494 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11495 break;
11496 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11497 break;
11498 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11499 break;
11500 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11501 break;
11502 case 8900: hashes_buf[0].salt->salt_iter = 1;
11503 break;
11504 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11505 break;
11506 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11507 break;
11508 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11509 break;
11510 case 9300: hashes_buf[0].salt->salt_iter = 1;
11511 break;
11512 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11513 break;
11514 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11515 break;
11516 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11517 break;
11518 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11519 break;
11520 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11521 break;
11522 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11523 break;
11524 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11525 break;
11526 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11527 break;
11528 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11529 break;
11530 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11531 break;
11532 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11533 break;
11534 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11535 break;
11536 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11537 break;
11538 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11539 break;
11540 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11541 break;
11542 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11543 break;
11544 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11545 break;
11546 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11547 break;
11548 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11549 break;
11550 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11551 break;
11552 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11553 break;
11554 }
11555
11556 hashes_cnt = 1;
11557 }
11558
11559 if (show == 1 || left == 1)
11560 {
11561 for (uint i = 0; i < pot_cnt; i++)
11562 {
11563 pot_t *pot_ptr = &pot[i];
11564
11565 hash_t *hashes_buf = &pot_ptr->hash;
11566
11567 local_free (hashes_buf->digest);
11568
11569 if (isSalted)
11570 {
11571 local_free (hashes_buf->salt);
11572 }
11573 }
11574
11575 local_free (pot);
11576
11577 if (data.quiet == 0) log_info_nn ("");
11578
11579 return (0);
11580 }
11581
11582 if (keyspace == 0)
11583 {
11584 if (hashes_cnt == 0)
11585 {
11586 log_error ("ERROR: No hashes loaded");
11587
11588 return (-1);
11589 }
11590 }
11591
11592 /**
11593 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11594 */
11595
11596 if (data.outfile != NULL)
11597 {
11598 if (data.hashfile != NULL)
11599 {
11600 #ifdef _POSIX
11601 struct stat tmpstat_outfile;
11602 struct stat tmpstat_hashfile;
11603 #endif
11604
11605 #ifdef _WIN
11606 struct stat64 tmpstat_outfile;
11607 struct stat64 tmpstat_hashfile;
11608 #endif
11609
11610 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11611
11612 if (tmp_outfile_fp)
11613 {
11614 #ifdef _POSIX
11615 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11616 #endif
11617
11618 #ifdef _WIN
11619 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11620 #endif
11621
11622 fclose (tmp_outfile_fp);
11623 }
11624
11625 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11626
11627 if (tmp_hashfile_fp)
11628 {
11629 #ifdef _POSIX
11630 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11631 #endif
11632
11633 #ifdef _WIN
11634 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11635 #endif
11636
11637 fclose (tmp_hashfile_fp);
11638 }
11639
11640 if (tmp_outfile_fp && tmp_outfile_fp)
11641 {
11642 tmpstat_outfile.st_mode = 0;
11643 tmpstat_outfile.st_nlink = 0;
11644 tmpstat_outfile.st_uid = 0;
11645 tmpstat_outfile.st_gid = 0;
11646 tmpstat_outfile.st_rdev = 0;
11647 tmpstat_outfile.st_atime = 0;
11648
11649 tmpstat_hashfile.st_mode = 0;
11650 tmpstat_hashfile.st_nlink = 0;
11651 tmpstat_hashfile.st_uid = 0;
11652 tmpstat_hashfile.st_gid = 0;
11653 tmpstat_hashfile.st_rdev = 0;
11654 tmpstat_hashfile.st_atime = 0;
11655
11656 #ifdef _POSIX
11657 tmpstat_outfile.st_blksize = 0;
11658 tmpstat_outfile.st_blocks = 0;
11659
11660 tmpstat_hashfile.st_blksize = 0;
11661 tmpstat_hashfile.st_blocks = 0;
11662 #endif
11663
11664 #ifdef _POSIX
11665 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11666 {
11667 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11668
11669 return (-1);
11670 }
11671 #endif
11672
11673 #ifdef _WIN
11674 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11675 {
11676 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11677
11678 return (-1);
11679 }
11680 #endif
11681 }
11682 }
11683 }
11684
11685 /**
11686 * Remove duplicates
11687 */
11688
11689 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11690
11691 if (isSalted)
11692 {
11693 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11694 }
11695 else
11696 {
11697 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11698 }
11699
11700 uint hashes_cnt_orig = hashes_cnt;
11701
11702 hashes_cnt = 1;
11703
11704 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11705 {
11706 if (isSalted)
11707 {
11708 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11709 {
11710 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11711 }
11712 }
11713 else
11714 {
11715 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11716 }
11717
11718 if (hashes_pos > hashes_cnt)
11719 {
11720 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11721 }
11722
11723 hashes_cnt++;
11724 }
11725
11726 /**
11727 * Potfile removes
11728 */
11729
11730 uint potfile_remove_cracks = 0;
11731
11732 if (potfile_disable == 0)
11733 {
11734 hash_t hash_buf;
11735
11736 hash_buf.digest = mymalloc (dgst_size);
11737 hash_buf.salt = NULL;
11738 hash_buf.esalt = NULL;
11739 hash_buf.hash_info = NULL;
11740 hash_buf.cracked = 0;
11741
11742 if (isSalted)
11743 {
11744 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11745 }
11746
11747 if (esalt_size)
11748 {
11749 hash_buf.esalt = mymalloc (esalt_size);
11750 }
11751
11752 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11753
11754 // no solution for these special hash types (for instane because they use hashfile in output etc)
11755 if ((hash_mode != 5200) &&
11756 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11757 (hash_mode != 9000))
11758 {
11759 FILE *fp = fopen (potfile, "rb");
11760
11761 if (fp != NULL)
11762 {
11763 while (!feof (fp))
11764 {
11765 char line_buf[BUFSIZ] = { 0 };
11766
11767 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11768
11769 if (ptr == NULL) break;
11770
11771 int line_len = strlen (line_buf);
11772
11773 if (line_len == 0) continue;
11774
11775 int iter = MAX_CUT_TRIES;
11776
11777 for (int i = line_len - 1; i && iter; i--, line_len--)
11778 {
11779 if (line_buf[i] != ':') continue;
11780
11781 if (isSalted)
11782 {
11783 memset (hash_buf.salt, 0, sizeof (salt_t));
11784 }
11785
11786 hash_t *found = NULL;
11787
11788 if (hash_mode == 6800)
11789 {
11790 if (i < 64) // 64 = 16 * uint in salt_buf[]
11791 {
11792 // manipulate salt_buf
11793 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11794
11795 hash_buf.salt->salt_len = i;
11796
11797 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11798 }
11799 }
11800 else if (hash_mode == 2500)
11801 {
11802 if (i < 64) // 64 = 16 * uint in salt_buf[]
11803 {
11804 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11805 // manipulate salt_buf
11806
11807 // to be safe work with a copy (because of line_len loop, i etc)
11808
11809 char line_buf_cpy[BUFSIZ] = { 0 };
11810
11811 memcpy (line_buf_cpy, line_buf, i);
11812
11813 char *mac2_pos = strrchr (line_buf_cpy, ':');
11814
11815 if (mac2_pos == NULL) continue;
11816
11817 mac2_pos[0] = 0;
11818 mac2_pos++;
11819
11820 if (strlen (mac2_pos) != 12) continue;
11821
11822 char *mac1_pos = strrchr (line_buf_cpy, ':');
11823
11824 if (mac1_pos == NULL) continue;
11825
11826 mac1_pos[0] = 0;
11827 mac1_pos++;
11828
11829 if (strlen (mac1_pos) != 12) continue;
11830
11831 uint essid_length = mac1_pos - line_buf_cpy - 1;
11832
11833 // here we need the ESSID
11834 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11835
11836 hash_buf.salt->salt_len = essid_length;
11837
11838 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11839
11840 if (found)
11841 {
11842 wpa_t *wpa = (wpa_t *) found->esalt;
11843
11844 uint pke[25] = { 0 };
11845
11846 char *pke_ptr = (char *) pke;
11847
11848 for (uint i = 0; i < 25; i++)
11849 {
11850 pke[i] = byte_swap_32 (wpa->pke[i]);
11851 }
11852
11853 u8 mac1[6] = { 0 };
11854 u8 mac2[6] = { 0 };
11855
11856 memcpy (mac1, pke_ptr + 23, 6);
11857 memcpy (mac2, pke_ptr + 29, 6);
11858
11859 // compare hex string(s) vs binary MAC address(es)
11860
11861 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11862 {
11863 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11864 {
11865 found = NULL;
11866 break;
11867 }
11868 }
11869
11870 // early skip ;)
11871 if (!found) continue;
11872
11873 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11874 {
11875 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11876 {
11877 found = NULL;
11878 break;
11879 }
11880 }
11881 }
11882 }
11883 }
11884 else
11885 {
11886 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11887
11888 if (parser_status == PARSER_OK)
11889 {
11890 if (isSalted)
11891 {
11892 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11893 }
11894 else
11895 {
11896 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11897 }
11898 }
11899 }
11900
11901 if (found == NULL) continue;
11902
11903 if (!found->cracked) potfile_remove_cracks++;
11904
11905 found->cracked = 1;
11906
11907 if (found) break;
11908
11909 iter--;
11910 }
11911 }
11912
11913 fclose (fp);
11914 }
11915 }
11916
11917 if (esalt_size)
11918 {
11919 local_free (hash_buf.esalt);
11920 }
11921
11922 if (isSalted)
11923 {
11924 local_free (hash_buf.salt);
11925 }
11926
11927 local_free (hash_buf.digest);
11928 }
11929
11930 /**
11931 * Now generate all the buffers required for later
11932 */
11933
11934 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11935
11936 salt_t *salts_buf_new = NULL;
11937 void *esalts_buf_new = NULL;
11938
11939 if (isSalted)
11940 {
11941 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11942
11943 if (esalt_size)
11944 {
11945 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11946 }
11947 }
11948 else
11949 {
11950 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11951 }
11952
11953 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11954
11955 uint digests_cnt = hashes_cnt;
11956 uint digests_done = 0;
11957
11958 uint size_digests = digests_cnt * dgst_size;
11959 uint size_shown = digests_cnt * sizeof (uint);
11960
11961 uint *digests_shown = (uint *) mymalloc (size_shown);
11962 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11963
11964 uint salts_cnt = 0;
11965 uint salts_done = 0;
11966
11967 hashinfo_t **hash_info = NULL;
11968
11969 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11970 {
11971 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11972
11973 if (username && (remove || show))
11974 {
11975 uint user_pos;
11976
11977 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11978 {
11979 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11980
11981 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11982 }
11983 }
11984 }
11985
11986 uint *salts_shown = (uint *) mymalloc (size_shown);
11987
11988 salt_t *salt_buf;
11989
11990 {
11991 // copied from inner loop
11992
11993 salt_buf = &salts_buf_new[salts_cnt];
11994
11995 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11996
11997 if (esalt_size)
11998 {
11999 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12000 }
12001
12002 salt_buf->digests_cnt = 0;
12003 salt_buf->digests_done = 0;
12004 salt_buf->digests_offset = 0;
12005
12006 salts_cnt++;
12007 }
12008
12009 if (hashes_buf[0].cracked == 1)
12010 {
12011 digests_shown[0] = 1;
12012
12013 digests_done++;
12014
12015 salt_buf->digests_done++;
12016 }
12017
12018 salt_buf->digests_cnt++;
12019
12020 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12021
12022 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12023 {
12024 hash_info[0] = hashes_buf[0].hash_info;
12025 }
12026
12027 // copy from inner loop
12028
12029 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12030 {
12031 if (isSalted)
12032 {
12033 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12034 {
12035 salt_buf = &salts_buf_new[salts_cnt];
12036
12037 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12038
12039 if (esalt_size)
12040 {
12041 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12042 }
12043
12044 salt_buf->digests_cnt = 0;
12045 salt_buf->digests_done = 0;
12046 salt_buf->digests_offset = hashes_pos;
12047
12048 salts_cnt++;
12049 }
12050 }
12051
12052 if (hashes_buf[hashes_pos].cracked == 1)
12053 {
12054 digests_shown[hashes_pos] = 1;
12055
12056 digests_done++;
12057
12058 salt_buf->digests_done++;
12059 }
12060
12061 salt_buf->digests_cnt++;
12062
12063 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12064
12065 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12066 {
12067 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12068 }
12069 }
12070
12071 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12072 {
12073 salt_t *salt_buf = &salts_buf_new[salt_pos];
12074
12075 if (salt_buf->digests_done == salt_buf->digests_cnt)
12076 {
12077 salts_shown[salt_pos] = 1;
12078
12079 salts_done++;
12080 }
12081
12082 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12083 }
12084
12085 local_free (digests_buf);
12086 local_free (salts_buf);
12087 local_free (esalts_buf);
12088
12089 digests_buf = digests_buf_new;
12090 salts_buf = salts_buf_new;
12091 esalts_buf = esalts_buf_new;
12092
12093 local_free (hashes_buf);
12094
12095 /**
12096 * special modification not set from parser
12097 */
12098
12099 switch (hash_mode)
12100 {
12101 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12102 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12103 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12104 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12105 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12106 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12107 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12108 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12109 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12110 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12111 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12112 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12113 }
12114
12115 if (truecrypt_keyfiles)
12116 {
12117 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12118
12119 char *keyfiles = strdup (truecrypt_keyfiles);
12120
12121 char *keyfile = strtok (keyfiles, ",");
12122
12123 do
12124 {
12125 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12126
12127 } while ((keyfile = strtok (NULL, ",")) != NULL);
12128
12129 free (keyfiles);
12130 }
12131
12132 data.digests_cnt = digests_cnt;
12133 data.digests_done = digests_done;
12134 data.digests_buf = digests_buf;
12135 data.digests_shown = digests_shown;
12136 data.digests_shown_tmp = digests_shown_tmp;
12137
12138 data.salts_cnt = salts_cnt;
12139 data.salts_done = salts_done;
12140 data.salts_buf = salts_buf;
12141 data.salts_shown = salts_shown;
12142
12143 data.esalts_buf = esalts_buf;
12144 data.hash_info = hash_info;
12145
12146 /**
12147 * Automatic Optimizers
12148 */
12149
12150 if (salts_cnt == 1)
12151 opti_type |= OPTI_TYPE_SINGLE_SALT;
12152
12153 if (digests_cnt == 1)
12154 opti_type |= OPTI_TYPE_SINGLE_HASH;
12155
12156 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12157 opti_type |= OPTI_TYPE_NOT_ITERATED;
12158
12159 if (attack_mode == ATTACK_MODE_BF)
12160 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12161
12162 data.opti_type = opti_type;
12163
12164 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12165 {
12166 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12167 {
12168 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12169 {
12170 if (opts_type & OPTS_TYPE_ST_ADD80)
12171 {
12172 opts_type &= ~OPTS_TYPE_ST_ADD80;
12173 opts_type |= OPTS_TYPE_PT_ADD80;
12174 }
12175
12176 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12177 {
12178 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12179 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12180 }
12181
12182 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12183 {
12184 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12185 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12186 }
12187 }
12188 }
12189 }
12190
12191 /**
12192 * Some algorithm, like descrypt, can benefit from JIT compilation
12193 */
12194
12195 int force_jit_compilation = -1;
12196
12197 if (hash_mode == 8900)
12198 {
12199 force_jit_compilation = 8900;
12200 }
12201 else if (hash_mode == 9300)
12202 {
12203 force_jit_compilation = 8900;
12204 }
12205 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12206 {
12207 force_jit_compilation = 1500;
12208 }
12209
12210 /**
12211 * generate bitmap tables
12212 */
12213
12214 const uint bitmap_shift1 = 5;
12215 const uint bitmap_shift2 = 13;
12216
12217 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12218
12219 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12220 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12221 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12222 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12223 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12224 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12225 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12226 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12227
12228 uint bitmap_bits;
12229 uint bitmap_nums;
12230 uint bitmap_mask;
12231 uint bitmap_size;
12232
12233 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12234 {
12235 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12236
12237 bitmap_nums = 1 << bitmap_bits;
12238
12239 bitmap_mask = bitmap_nums - 1;
12240
12241 bitmap_size = bitmap_nums * sizeof (uint);
12242
12243 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12244
12245 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;
12246 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;
12247
12248 break;
12249 }
12250
12251 bitmap_nums = 1 << bitmap_bits;
12252
12253 bitmap_mask = bitmap_nums - 1;
12254
12255 bitmap_size = bitmap_nums * sizeof (uint);
12256
12257 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);
12258 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);
12259
12260 /**
12261 * prepare quick rule
12262 */
12263
12264 data.rule_buf_l = rule_buf_l;
12265 data.rule_buf_r = rule_buf_r;
12266
12267 int rule_len_l = (int) strlen (rule_buf_l);
12268 int rule_len_r = (int) strlen (rule_buf_r);
12269
12270 data.rule_len_l = rule_len_l;
12271 data.rule_len_r = rule_len_r;
12272
12273 /**
12274 * load rules
12275 */
12276
12277 uint *all_kernel_rules_cnt = NULL;
12278
12279 kernel_rule_t **all_kernel_rules_buf = NULL;
12280
12281 if (rp_files_cnt)
12282 {
12283 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12284
12285 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12286 }
12287
12288 char rule_buf[BUFSIZ] = { 0 };
12289
12290 int rule_len = 0;
12291
12292 for (uint i = 0; i < rp_files_cnt; i++)
12293 {
12294 uint kernel_rules_avail = 0;
12295
12296 uint kernel_rules_cnt = 0;
12297
12298 kernel_rule_t *kernel_rules_buf = NULL;
12299
12300 char *rp_file = rp_files[i];
12301
12302 char in[BLOCK_SIZE] = { 0 };
12303 char out[BLOCK_SIZE] = { 0 };
12304
12305 FILE *fp = NULL;
12306
12307 uint rule_line = 0;
12308
12309 if ((fp = fopen (rp_file, "rb")) == NULL)
12310 {
12311 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12312
12313 return (-1);
12314 }
12315
12316 while (!feof (fp))
12317 {
12318 memset (rule_buf, 0, BUFSIZ);
12319
12320 rule_len = fgetl (fp, rule_buf);
12321
12322 rule_line++;
12323
12324 if (rule_len == 0) continue;
12325
12326 if (rule_buf[0] == '#') continue;
12327
12328 if (kernel_rules_avail == kernel_rules_cnt)
12329 {
12330 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12331
12332 kernel_rules_avail += INCR_RULES;
12333 }
12334
12335 memset (in, 0, BLOCK_SIZE);
12336 memset (out, 0, BLOCK_SIZE);
12337
12338 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12339
12340 if (result == -1)
12341 {
12342 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12343
12344 continue;
12345 }
12346
12347 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12348 {
12349 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12350
12351 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12352
12353 continue;
12354 }
12355
12356 /* its so slow
12357 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12358 {
12359 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12360
12361 continue;
12362 }
12363 */
12364
12365 kernel_rules_cnt++;
12366 }
12367
12368 fclose (fp);
12369
12370 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12371
12372 all_kernel_rules_buf[i] = kernel_rules_buf;
12373 }
12374
12375 /**
12376 * merge rules or automatic rule generator
12377 */
12378
12379 uint kernel_rules_cnt = 0;
12380
12381 kernel_rule_t *kernel_rules_buf = NULL;
12382
12383 if (attack_mode == ATTACK_MODE_STRAIGHT)
12384 {
12385 if (rp_files_cnt)
12386 {
12387 kernel_rules_cnt = 1;
12388
12389 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12390
12391 repeats[0] = kernel_rules_cnt;
12392
12393 for (uint i = 0; i < rp_files_cnt; i++)
12394 {
12395 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12396
12397 repeats[i + 1] = kernel_rules_cnt;
12398 }
12399
12400 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12401
12402 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12403
12404 for (uint i = 0; i < kernel_rules_cnt; i++)
12405 {
12406 uint out_pos = 0;
12407
12408 kernel_rule_t *out = &kernel_rules_buf[i];
12409
12410 for (uint j = 0; j < rp_files_cnt; j++)
12411 {
12412 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12413 uint in_pos;
12414
12415 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12416
12417 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12418 {
12419 if (out_pos == RULES_MAX - 1)
12420 {
12421 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12422
12423 break;
12424 }
12425
12426 out->cmds[out_pos] = in->cmds[in_pos];
12427 }
12428 }
12429 }
12430
12431 local_free (repeats);
12432 }
12433 else if (rp_gen)
12434 {
12435 uint kernel_rules_avail = 0;
12436
12437 while (kernel_rules_cnt < rp_gen)
12438 {
12439 if (kernel_rules_avail == kernel_rules_cnt)
12440 {
12441 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12442
12443 kernel_rules_avail += INCR_RULES;
12444 }
12445
12446 memset (rule_buf, 0, BLOCK_SIZE);
12447
12448 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12449
12450 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12451
12452 kernel_rules_cnt++;
12453 }
12454 }
12455 }
12456
12457 /**
12458 * generate NOP rules
12459 */
12460
12461 if (kernel_rules_cnt == 0)
12462 {
12463 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12464
12465 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12466
12467 kernel_rules_cnt++;
12468 }
12469
12470 data.kernel_rules_cnt = kernel_rules_cnt;
12471 data.kernel_rules_buf = kernel_rules_buf;
12472
12473 /**
12474 * OpenCL platforms: detect
12475 */
12476
12477 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12478 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12479
12480 cl_uint platforms_cnt = 0;
12481 cl_uint platform_devices_cnt = 0;
12482
12483 if (keyspace == 0)
12484 {
12485 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12486
12487 if (platforms_cnt == 0)
12488 {
12489 log_error ("ERROR: No OpenCL compatible platform found");
12490
12491 return (-1);
12492 }
12493
12494 if (opencl_platforms_filter != (uint) -1)
12495 {
12496 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
12497
12498 if (opencl_platforms_filter > platform_cnt_mask)
12499 {
12500 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
12501
12502 return (-1);
12503 }
12504 }
12505 }
12506
12507 /**
12508 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12509 */
12510
12511 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12512 {
12513 cl_platform_id platform = platforms[platform_id];
12514
12515 char platform_vendor[INFOSZ] = { 0 };
12516
12517 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12518
12519 #ifdef HAVE_HWMON
12520 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12521 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12522 {
12523 // make sure that we do not directly control the fan for NVidia
12524
12525 gpu_temp_retain = 0;
12526
12527 data.gpu_temp_retain = gpu_temp_retain;
12528 }
12529 #endif // HAVE_NVML || HAVE_NVAPI
12530 #endif
12531 }
12532
12533 /**
12534 * OpenCL devices: simply push all devices from all platforms into the same device array
12535 */
12536
12537 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12538
12539 data.devices_param = devices_param;
12540
12541 uint devices_cnt = 0;
12542
12543 uint devices_active = 0;
12544
12545 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12546 {
12547 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12548
12549 cl_platform_id platform = platforms[platform_id];
12550
12551 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12552
12553 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12554 {
12555 size_t param_value_size = 0;
12556
12557 const uint device_id = devices_cnt;
12558
12559 hc_device_param_t *device_param = &data.devices_param[device_id];
12560
12561 device_param->device = platform_devices[platform_devices_id];
12562
12563 device_param->device_id = device_id;
12564
12565 device_param->platform_devices_id = platform_devices_id;
12566
12567 // device_type
12568
12569 cl_device_type device_type;
12570
12571 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12572
12573 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12574
12575 device_param->device_type = device_type;
12576
12577 // vendor_id
12578
12579 cl_uint vendor_id = 0;
12580
12581 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12582
12583 device_param->vendor_id = vendor_id;
12584
12585 // device_name
12586
12587 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12588
12589 char *device_name = (char *) mymalloc (param_value_size);
12590
12591 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12592
12593 device_param->device_name = device_name;
12594
12595 // tuning db
12596
12597 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12598
12599 // device_version
12600
12601 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12602
12603 char *device_version = (char *) mymalloc (param_value_size);
12604
12605 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12606
12607 device_param->device_version = device_version;
12608
12609 // device_opencl_version
12610
12611 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12612
12613 char *device_opencl_version = (char *) mymalloc (param_value_size);
12614
12615 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12616
12617 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12618
12619 myfree (device_opencl_version);
12620
12621 if (strstr (device_version, "pocl"))
12622 {
12623 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12624 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12625
12626 cl_uint vendor_id = VENDOR_ID_GENERIC;
12627
12628 device_param->vendor_id = vendor_id;
12629 }
12630
12631 // vector_width
12632
12633 cl_uint vector_width;
12634
12635 if (opencl_vector_width_chgd == 0)
12636 {
12637 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12638 {
12639 if (opti_type & OPTI_TYPE_USES_BITS_64)
12640 {
12641 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12642 }
12643 else
12644 {
12645 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12646 }
12647 }
12648 else
12649 {
12650 vector_width = (cl_uint) tuningdb_entry->vector_width;
12651 }
12652 }
12653 else
12654 {
12655 vector_width = opencl_vector_width;
12656 }
12657
12658 if (vector_width > 16) vector_width = 16;
12659
12660 device_param->vector_width = vector_width;
12661
12662 // max_compute_units
12663
12664 cl_uint device_processors;
12665
12666 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12667
12668 device_param->device_processors = device_processors;
12669
12670 // max_mem_alloc_size
12671
12672 cl_ulong device_maxmem_alloc;
12673
12674 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12675
12676 device_param->device_maxmem_alloc = device_maxmem_alloc;
12677
12678 // max_mem_alloc_size
12679
12680 cl_ulong device_global_mem;
12681
12682 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12683
12684 device_param->device_global_mem = device_global_mem;
12685
12686 // max_clock_frequency
12687
12688 cl_uint device_maxclock_frequency;
12689
12690 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12691
12692 device_param->device_maxclock_frequency = device_maxclock_frequency;
12693
12694 // skipped
12695
12696 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12697 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12698
12699 device_param->skipped = (skipped1 || skipped2);
12700
12701 // driver_version
12702 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12703
12704 char *driver_version = (char *) mymalloc (param_value_size);
12705
12706 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12707
12708 device_param->driver_version = driver_version;
12709
12710 // device_name_chksum
12711
12712 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12713
12714 #if __x86_64__
12715 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);
12716 #else
12717 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);
12718 #endif
12719
12720 uint device_name_digest[4] = { 0 };
12721
12722 md5_64 ((uint *) device_name_chksum, device_name_digest);
12723
12724 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12725
12726 device_param->device_name_chksum = device_name_chksum;
12727
12728 // device_processor_cores
12729
12730 if (device_type & CL_DEVICE_TYPE_CPU)
12731 {
12732 cl_uint device_processor_cores = 1;
12733
12734 device_param->device_processor_cores = device_processor_cores;
12735 }
12736
12737 if (device_type & CL_DEVICE_TYPE_GPU)
12738 {
12739 if (vendor_id == VENDOR_ID_AMD)
12740 {
12741 cl_uint device_processor_cores = 0;
12742
12743 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12744
12745 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12746
12747 device_param->device_processor_cores = device_processor_cores;
12748 }
12749 else if (vendor_id == VENDOR_ID_NV)
12750 {
12751 cl_uint kernel_exec_timeout = 0;
12752
12753 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12754
12755 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12756
12757 device_param->kernel_exec_timeout = kernel_exec_timeout;
12758
12759 cl_uint device_processor_cores = 0;
12760
12761 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12762
12763 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12764
12765 device_param->device_processor_cores = device_processor_cores;
12766
12767 cl_uint sm_minor = 0;
12768 cl_uint sm_major = 0;
12769
12770 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12771 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12772
12773 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12774 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12775
12776 device_param->sm_minor = sm_minor;
12777 device_param->sm_major = sm_major;
12778 }
12779 else
12780 {
12781 cl_uint device_processor_cores = 1;
12782
12783 device_param->device_processor_cores = device_processor_cores;
12784 }
12785 }
12786
12787 // display results
12788
12789 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12790 {
12791 if (device_param->skipped == 0)
12792 {
12793 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12794 device_id + 1,
12795 device_name,
12796 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12797 (unsigned int) (device_global_mem / 1024 / 1024),
12798 (unsigned int) (device_maxclock_frequency),
12799 (unsigned int) device_processors);
12800 }
12801 else
12802 {
12803 log_info ("Device #%u: %s, skipped",
12804 device_id + 1,
12805 device_name);
12806 }
12807 }
12808
12809 // common driver check
12810
12811 if (device_param->skipped == 0)
12812 {
12813 if (strstr (device_version, "pocl"))
12814 {
12815 if (force == 0)
12816 {
12817 log_info ("");
12818 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12819 log_info ("You are STRONGLY encouraged not to use it");
12820 log_info ("You can use --force to override this but do not post error reports if you do so");
12821 log_info ("");
12822
12823 return (-1);
12824 }
12825 }
12826
12827 if (device_type & CL_DEVICE_TYPE_GPU)
12828 {
12829 if (vendor_id == VENDOR_ID_NV)
12830 {
12831 if (device_param->kernel_exec_timeout != 0)
12832 {
12833 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);
12834 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12835 }
12836 }
12837 else if (vendor_id == VENDOR_ID_AMD)
12838 {
12839 int catalyst_check = (force == 1) ? 0 : 1;
12840
12841 int catalyst_warn = 0;
12842
12843 int catalyst_broken = 0;
12844
12845 if (catalyst_check == 1)
12846 {
12847 catalyst_warn = 1;
12848
12849 // v14.9 and higher
12850 if (atoi (device_param->driver_version) >= 1573)
12851 {
12852 catalyst_warn = 0;
12853 }
12854
12855 catalyst_check = 0;
12856 }
12857
12858 if (catalyst_broken == 1)
12859 {
12860 log_info ("");
12861 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12862 log_info ("It will pass over cracked hashes and does not report them as cracked");
12863 log_info ("You are STRONGLY encouraged not to use it");
12864 log_info ("You can use --force to override this but do not post error reports if you do so");
12865 log_info ("");
12866
12867 return (-1);
12868 }
12869
12870 if (catalyst_warn == 1)
12871 {
12872 log_info ("");
12873 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12874 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12875 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12876 #ifdef _WIN
12877 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12878 #endif
12879 log_info ("You can use --force to override this but do not post error reports if you do so");
12880 log_info ("");
12881
12882 return (-1);
12883 }
12884 }
12885 }
12886
12887 /**
12888 * kernel accel and loops tuning db adjustment
12889 */
12890
12891 device_param->kernel_accel_min = 1;
12892 device_param->kernel_accel_max = 1024;
12893
12894 device_param->kernel_loops_min = 1;
12895 device_param->kernel_loops_max = 1024;
12896
12897 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12898
12899 if (tuningdb_entry)
12900 {
12901 u32 _kernel_accel = tuningdb_entry->kernel_accel;
12902 u32 _kernel_loops = tuningdb_entry->kernel_loops;
12903
12904 if (_kernel_accel)
12905 {
12906 device_param->kernel_accel_min = _kernel_accel;
12907 device_param->kernel_accel_max = _kernel_accel;
12908 }
12909
12910 if (_kernel_loops)
12911 {
12912 if (workload_profile == 1)
12913 {
12914 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
12915 }
12916 else if (workload_profile == 2)
12917 {
12918 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
12919 }
12920
12921 device_param->kernel_loops_min = _kernel_loops;
12922 device_param->kernel_loops_max = _kernel_loops;
12923 }
12924 }
12925
12926 // commandline parameters overwrite tuningdb entries
12927
12928 if (kernel_accel)
12929 {
12930 device_param->kernel_accel_min = kernel_accel;
12931 device_param->kernel_accel_max = kernel_accel;
12932 }
12933
12934 if (kernel_loops)
12935 {
12936 device_param->kernel_loops_min = kernel_loops;
12937 device_param->kernel_loops_max = kernel_loops;
12938 }
12939
12940 /**
12941 * activate device
12942 */
12943
12944 devices_active++;
12945 }
12946
12947 // next please
12948
12949 devices_cnt++;
12950 }
12951 }
12952
12953 if (keyspace == 0 && devices_active == 0)
12954 {
12955 log_error ("ERROR: No devices found/left");
12956
12957 return (-1);
12958 }
12959
12960 // 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)
12961
12962 if (devices_filter != (uint) -1)
12963 {
12964 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
12965
12966 if (devices_filter > devices_cnt_mask)
12967 {
12968 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
12969
12970 return (-1);
12971 }
12972 }
12973
12974 data.devices_cnt = devices_cnt;
12975
12976 data.devices_active = devices_active;
12977
12978 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12979 {
12980 log_info ("");
12981 }
12982
12983 /**
12984 * HM devices: init
12985 */
12986
12987 #ifdef HAVE_HWMON
12988 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12989 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12990 #endif
12991
12992 #ifdef HAVE_ADL
12993 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12994 #endif
12995
12996 if (gpu_temp_disable == 0)
12997 {
12998 #if defined(WIN) && defined(HAVE_NVAPI)
12999 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13000
13001 if (nvapi_init (nvapi) == 0)
13002 data.hm_nv = nvapi;
13003
13004 if (data.hm_nv)
13005 {
13006 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13007 {
13008 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13009
13010 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13011
13012 int tmp_out = 0;
13013
13014 for (int i = 0; i < tmp_in; i++)
13015 {
13016 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13017 }
13018
13019 for (int i = 0; i < tmp_out; i++)
13020 {
13021 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13022
13023 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13024
13025 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;
13026 }
13027 }
13028 }
13029 #endif // WIN && HAVE_NVAPI
13030
13031 #if defined(LINUX) && defined(HAVE_NVML)
13032 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13033
13034 if (nvml_init (nvml) == 0)
13035 data.hm_nv = nvml;
13036
13037 if (data.hm_nv)
13038 {
13039 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13040 {
13041 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13042
13043 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13044
13045 int tmp_out = 0;
13046
13047 for (int i = 0; i < tmp_in; i++)
13048 {
13049 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13050 }
13051
13052 for (int i = 0; i < tmp_out; i++)
13053 {
13054 unsigned int speed;
13055
13056 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;
13057 }
13058 }
13059 }
13060 #endif // LINUX && HAVE_NVML
13061
13062 data.hm_amd = NULL;
13063
13064 #ifdef HAVE_ADL
13065 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13066
13067 if (adl_init (adl) == 0)
13068 data.hm_amd = adl;
13069
13070 if (data.hm_amd)
13071 {
13072 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13073 {
13074 // total number of adapters
13075
13076 int hm_adapters_num;
13077
13078 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13079
13080 // adapter info
13081
13082 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13083
13084 if (lpAdapterInfo == NULL) return (-1);
13085
13086 // get a list (of ids of) valid/usable adapters
13087
13088 int num_adl_adapters = 0;
13089
13090 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13091
13092 if (num_adl_adapters > 0)
13093 {
13094 hc_thread_mutex_lock (mux_adl);
13095
13096 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13097
13098 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13099
13100 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13101 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13102
13103 hc_thread_mutex_unlock (mux_adl);
13104 }
13105
13106 myfree (valid_adl_device_list);
13107 myfree (lpAdapterInfo);
13108 }
13109 }
13110 #endif // HAVE_ADL
13111
13112 if (data.hm_amd == NULL && data.hm_nv == NULL)
13113 {
13114 gpu_temp_disable = 1;
13115 }
13116 }
13117
13118 /**
13119 * OpenCL devices: allocate buffer for device specific information
13120 */
13121
13122 #ifdef HAVE_HWMON
13123 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13124
13125 #ifdef HAVE_ADL
13126 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13127
13128 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13129 #endif // ADL
13130 #endif
13131
13132 /**
13133 * enable custom signal handler(s)
13134 */
13135
13136 if (benchmark == 0)
13137 {
13138 hc_signal (sigHandler_default);
13139 }
13140 else
13141 {
13142 hc_signal (sigHandler_benchmark);
13143 }
13144
13145 /**
13146 * User-defined GPU temp handling
13147 */
13148
13149 #ifdef HAVE_HWMON
13150 if (gpu_temp_disable == 1)
13151 {
13152 gpu_temp_abort = 0;
13153 gpu_temp_retain = 0;
13154 }
13155
13156 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13157 {
13158 if (gpu_temp_abort < gpu_temp_retain)
13159 {
13160 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13161
13162 return (-1);
13163 }
13164 }
13165
13166 data.gpu_temp_disable = gpu_temp_disable;
13167 data.gpu_temp_abort = gpu_temp_abort;
13168 data.gpu_temp_retain = gpu_temp_retain;
13169 #endif
13170
13171 /**
13172 * inform the user
13173 */
13174
13175 if (data.quiet == 0)
13176 {
13177 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13178
13179 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);
13180
13181 if (attack_mode == ATTACK_MODE_STRAIGHT)
13182 {
13183 log_info ("Rules: %u", kernel_rules_cnt);
13184 }
13185
13186 if (opti_type)
13187 {
13188 log_info ("Applicable Optimizers:");
13189
13190 for (uint i = 0; i < 32; i++)
13191 {
13192 const uint opti_bit = 1u << i;
13193
13194 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13195 }
13196 }
13197
13198 /**
13199 * Watchdog and Temperature balance
13200 */
13201
13202 #ifdef HAVE_HWMON
13203 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13204 {
13205 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13206 }
13207
13208 if (gpu_temp_abort == 0)
13209 {
13210 log_info ("Watchdog: Temperature abort trigger disabled");
13211 }
13212 else
13213 {
13214 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13215 }
13216
13217 if (gpu_temp_retain == 0)
13218 {
13219 log_info ("Watchdog: Temperature retain trigger disabled");
13220 }
13221 else
13222 {
13223 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13224 }
13225 #endif
13226 }
13227
13228 if (data.quiet == 0) log_info ("");
13229
13230 /**
13231 * HM devices: copy
13232 */
13233
13234 if (gpu_temp_disable == 0)
13235 {
13236 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13237 {
13238 hc_device_param_t *device_param = &data.devices_param[device_id];
13239
13240 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13241
13242 if (device_param->skipped) continue;
13243
13244 const uint platform_devices_id = device_param->platform_devices_id;
13245
13246 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13247 if (device_param->vendor_id == VENDOR_ID_NV)
13248 {
13249 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13250 }
13251 #endif
13252
13253 #ifdef HAVE_ADL
13254 if (device_param->vendor_id == VENDOR_ID_AMD)
13255 {
13256 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13257 }
13258 #endif
13259 }
13260 }
13261
13262 /*
13263 * Temporary fix:
13264 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13265 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13266 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13267 * Driver / ADL bug?
13268 */
13269
13270 #ifdef HAVE_ADL
13271 if (powertune_enable == 1)
13272 {
13273 hc_thread_mutex_lock (mux_adl);
13274
13275 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13276 {
13277 hc_device_param_t *device_param = &data.devices_param[device_id];
13278
13279 if (device_param->skipped) continue;
13280
13281 if (data.hm_device[device_id].od_version == 6)
13282 {
13283 // set powertune value only
13284
13285 int powertune_supported = 0;
13286
13287 int ADL_rc = 0;
13288
13289 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13290 {
13291 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13292
13293 return (-1);
13294 }
13295
13296 if (powertune_supported != 0)
13297 {
13298 // powertune set
13299 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13300
13301 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13302 {
13303 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13304
13305 return (-1);
13306 }
13307
13308 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13309 {
13310 log_error ("ERROR: Failed to set new ADL PowerControl values");
13311
13312 return (-1);
13313 }
13314 }
13315 }
13316 }
13317
13318 hc_thread_mutex_unlock (mux_adl);
13319 }
13320 #endif // HAVE_ADK
13321 #endif // HAVE_HWMON
13322
13323 #ifdef DEBUG
13324 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13325 #endif
13326
13327 uint kernel_power_all = 0;
13328
13329 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13330 {
13331 /**
13332 * host buffer
13333 */
13334
13335 hc_device_param_t *device_param = &data.devices_param[device_id];
13336
13337 if (device_param->skipped) continue;
13338
13339 /**
13340 * device properties
13341 */
13342
13343 const char *device_name_chksum = device_param->device_name_chksum;
13344 const u32 device_processors = device_param->device_processors;
13345 const u32 device_processor_cores = device_param->device_processor_cores;
13346
13347 /**
13348 * create context for each device
13349 */
13350
13351 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13352
13353 /**
13354 * create command-queue
13355 */
13356
13357 // not supported with NV
13358 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13359
13360 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13361
13362 /**
13363 * create input buffers on device : calculate size of fixed memory buffers
13364 */
13365
13366 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13367 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13368
13369 device_param->size_root_css = size_root_css;
13370 device_param->size_markov_css = size_markov_css;
13371
13372 uint size_results = KERNEL_THREADS * sizeof (uint);
13373
13374 device_param->size_results = size_results;
13375
13376 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13377 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13378
13379 uint size_plains = digests_cnt * sizeof (plain_t);
13380 uint size_salts = salts_cnt * sizeof (salt_t);
13381 uint size_esalts = salts_cnt * esalt_size;
13382
13383 device_param->size_plains = size_plains;
13384 device_param->size_digests = size_digests;
13385 device_param->size_shown = size_shown;
13386 device_param->size_salts = size_salts;
13387
13388 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13389 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13390 uint size_tm = 32 * sizeof (bs_word_t);
13391
13392 // scryptV stuff
13393
13394 u64 size_scryptV = 1;
13395
13396 if ((hash_mode == 8900) || (hash_mode == 9300))
13397 {
13398 uint tmto_start = 0;
13399 uint tmto_stop = 10;
13400
13401 if (scrypt_tmto)
13402 {
13403 tmto_start = scrypt_tmto;
13404 }
13405 else
13406 {
13407 // in case the user did not specify the tmto manually
13408 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13409 // but set the lower end only in case the user has a device with too less memory
13410
13411 if (hash_mode == 8900)
13412 {
13413 if (device_param->vendor_id == VENDOR_ID_AMD)
13414 {
13415 tmto_start = 1;
13416 }
13417 else if (device_param->vendor_id == VENDOR_ID_NV)
13418 {
13419 tmto_start = 3;
13420 }
13421 }
13422 else if (hash_mode == 9300)
13423 {
13424 if (device_param->vendor_id == VENDOR_ID_AMD)
13425 {
13426 tmto_start = 3;
13427 }
13428 else if (device_param->vendor_id == VENDOR_ID_NV)
13429 {
13430 tmto_start = 5;
13431 }
13432 }
13433 }
13434
13435 if (quiet == 0) log_info ("");
13436
13437 uint shader_per_mp = 1;
13438
13439 if (device_param->vendor_id == VENDOR_ID_AMD)
13440 {
13441 shader_per_mp = 8;
13442 }
13443 else if (device_param->vendor_id == VENDOR_ID_NV)
13444 {
13445 shader_per_mp = 32;
13446 }
13447
13448 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13449 {
13450 // TODO: in theory the following calculation needs to be done per salt, not global
13451 // we assume all hashes have the same scrypt settings
13452
13453 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13454
13455 size_scryptV /= 1 << tmto;
13456
13457 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13458
13459 if (size_scryptV > device_param->device_maxmem_alloc)
13460 {
13461 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13462
13463 continue;
13464 }
13465
13466 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13467 {
13468 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13469 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13470 }
13471
13472 break;
13473 }
13474
13475 if (data.salts_buf[0].scrypt_phy == 0)
13476 {
13477 log_error ("ERROR: can't allocate enough device memory");
13478
13479 return -1;
13480 }
13481
13482 if (quiet == 0) log_info ("");
13483 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13484 }
13485
13486 /**
13487 * create input buffers on device : calculate size of dynamic size memory buffers
13488 */
13489
13490 uint kernel_threads = KERNEL_THREADS;
13491
13492 // some algorithms need a fixed kernel-threads count (mostly because of shared memory usage)
13493
13494 if (hash_mode == 3200) kernel_threads = 8;
13495 if (hash_mode == 9000) kernel_threads = 8;
13496
13497 /**
13498 * some algorithms need a fixed kernel-loops count
13499 */
13500
13501 if (hash_mode == 1500)
13502 {
13503 const u32 kernel_loops_fixed = 1024;
13504
13505 device_param->kernel_loops_min = kernel_loops_fixed;
13506 device_param->kernel_loops_max = kernel_loops_fixed;
13507 }
13508
13509 if (hash_mode == 3000)
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 == 8900)
13518 {
13519 const u32 kernel_loops_fixed = 1;
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 == 9300)
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 == 12500)
13534 {
13535 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13536
13537 device_param->kernel_loops_min = kernel_loops_fixed;
13538 device_param->kernel_loops_max = kernel_loops_fixed;
13539 }
13540
13541 /**
13542 * some algorithms have a maximum kernel-loops count
13543 */
13544
13545 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13546 {
13547 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13548 {
13549 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13550 }
13551 }
13552
13553 /**
13554 * some algorithms need a special kernel-accel
13555 */
13556
13557 if (hash_mode == 8900)
13558 {
13559 device_param->kernel_accel_min = 1;
13560 device_param->kernel_accel_max = 64;
13561 }
13562
13563 if (hash_mode == 9300)
13564 {
13565 device_param->kernel_accel_min = 1;
13566 device_param->kernel_accel_max = 64;
13567 }
13568
13569 u32 kernel_accel_min = device_param->kernel_accel_min;
13570 u32 kernel_accel_max = device_param->kernel_accel_max;
13571
13572 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13573
13574 uint size_pws = 4;
13575 uint size_tmps = 4;
13576 uint size_hooks = 4;
13577
13578 while (kernel_accel_max >= kernel_accel_min)
13579 {
13580 uint kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13581
13582 // size_pws
13583
13584 size_pws = kernel_power_max * sizeof (pw_t);
13585
13586 // size_tmps
13587
13588 switch (hash_mode)
13589 {
13590 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13591 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13592 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13593 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13594 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13595 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13596 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13597 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13598 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13599 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13600 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13601 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13602 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13603 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13604 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13605 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13606 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13607 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13608 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13609 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13610 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13611 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13612 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13613 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13614 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13615 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13616 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13617 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13618 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13619 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13620 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13621 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13622 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13623 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13624 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13625 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13626 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13627 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13628 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13629 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13630 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13631 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13632 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13633 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13634 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13635 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13636 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13637 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13638 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13639 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13640 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13641 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13642 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13643 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13644 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13645 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13646 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13647 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13648 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13649 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13650 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13651 };
13652
13653 // size_hooks
13654
13655 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13656 {
13657 // none yet
13658 }
13659
13660 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13661 // if not, decrease amplifier and try again
13662
13663 int skip = 0;
13664
13665 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13666 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13667 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13668
13669 if (( bitmap_size
13670 + bitmap_size
13671 + bitmap_size
13672 + bitmap_size
13673 + bitmap_size
13674 + bitmap_size
13675 + bitmap_size
13676 + bitmap_size
13677 + size_bfs
13678 + size_combs
13679 + size_digests
13680 + size_esalts
13681 + size_hooks
13682 + size_markov_css
13683 + size_plains
13684 + size_pws
13685 + size_results
13686 + size_root_css
13687 + size_rules
13688 + size_rules_c
13689 + size_salts
13690 + size_scryptV
13691 + size_shown
13692 + size_tm
13693 + size_tmps) > device_param->device_global_mem) skip = 1;
13694
13695 if (skip == 1)
13696 {
13697 kernel_accel_max--;
13698
13699 continue;
13700 }
13701
13702 break;
13703 }
13704
13705 /*
13706 if (kernel_accel_max == 0)
13707 {
13708 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13709
13710 return -1;
13711 }
13712 */
13713
13714 device_param->kernel_accel_min = kernel_accel_min;
13715 device_param->kernel_accel_max = kernel_accel_max;
13716
13717 /*
13718 if (kernel_accel_max < kernel_accel)
13719 {
13720 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13721
13722 device_param->kernel_accel = kernel_accel_max;
13723 }
13724 */
13725
13726 device_param->size_bfs = size_bfs;
13727 device_param->size_combs = size_combs;
13728 device_param->size_rules = size_rules;
13729 device_param->size_rules_c = size_rules_c;
13730 device_param->size_pws = size_pws;
13731 device_param->size_tmps = size_tmps;
13732 device_param->size_hooks = size_hooks;
13733
13734 // do not confuse kernel_accel_max with kernel_accel here
13735
13736 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13737
13738 device_param->kernel_threads = kernel_threads;
13739 device_param->kernel_power_user = kernel_power;
13740
13741 kernel_power_all += kernel_power;
13742
13743 /**
13744 * default building options
13745 */
13746
13747 char build_opts[1024] = { 0 };
13748
13749 // we don't have sm_* on vendors not NV but it doesn't matter
13750
13751 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);
13752
13753 /**
13754 * main kernel
13755 */
13756
13757 {
13758 /**
13759 * kernel source filename
13760 */
13761
13762 char source_file[256] = { 0 };
13763
13764 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13765
13766 struct stat sst;
13767
13768 if (stat (source_file, &sst) == -1)
13769 {
13770 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13771
13772 return -1;
13773 }
13774
13775 /**
13776 * kernel cached filename
13777 */
13778
13779 char cached_file[256] = { 0 };
13780
13781 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13782
13783 int cached = 1;
13784
13785 struct stat cst;
13786
13787 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13788 {
13789 cached = 0;
13790 }
13791
13792 /**
13793 * kernel compile or load
13794 */
13795
13796 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13797
13798 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13799
13800 if (force_jit_compilation == -1)
13801 {
13802 if (cached == 0)
13803 {
13804 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13805
13806 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13807
13808 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13809
13810 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13811
13812 if (rc != 0)
13813 {
13814 device_param->skipped = true;
13815 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13816 continue;
13817 }
13818
13819 size_t binary_size;
13820
13821 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13822
13823 u8 *binary = (u8 *) mymalloc (binary_size);
13824
13825 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13826
13827 writeProgramBin (cached_file, binary, binary_size);
13828
13829 local_free (binary);
13830 }
13831 else
13832 {
13833 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13834
13835 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13836
13837 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13838
13839 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
13840 }
13841 }
13842 else
13843 {
13844 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13845
13846 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13847
13848 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13849
13850 char build_opts_update[1024] = { 0 };
13851
13852 if (force_jit_compilation == 1500)
13853 {
13854 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13855 }
13856 else if (force_jit_compilation == 8900)
13857 {
13858 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);
13859 }
13860 else
13861 {
13862 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
13863 }
13864
13865 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
13866
13867 if (rc != 0)
13868 {
13869 device_param->skipped = true;
13870
13871 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13872 }
13873 }
13874
13875 local_free (kernel_lengths);
13876 local_free (kernel_sources[0]);
13877 local_free (kernel_sources);
13878 }
13879
13880 /**
13881 * word generator kernel
13882 */
13883
13884 if (attack_mode != ATTACK_MODE_STRAIGHT)
13885 {
13886 /**
13887 * kernel mp source filename
13888 */
13889
13890 char source_file[256] = { 0 };
13891
13892 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13893
13894 struct stat sst;
13895
13896 if (stat (source_file, &sst) == -1)
13897 {
13898 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13899
13900 return -1;
13901 }
13902
13903 /**
13904 * kernel mp cached filename
13905 */
13906
13907 char cached_file[256] = { 0 };
13908
13909 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13910
13911 int cached = 1;
13912
13913 struct stat cst;
13914
13915 if (stat (cached_file, &cst) == -1)
13916 {
13917 cached = 0;
13918 }
13919
13920 /**
13921 * kernel compile or load
13922 */
13923
13924 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13925
13926 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13927
13928 if (cached == 0)
13929 {
13930 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13931
13932 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13933
13934 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13935
13936 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
13937
13938 if (rc != 0)
13939 {
13940 device_param->skipped = true;
13941 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13942 continue;
13943 }
13944
13945 size_t binary_size;
13946
13947 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13948
13949 u8 *binary = (u8 *) mymalloc (binary_size);
13950
13951 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13952
13953 writeProgramBin (cached_file, binary, binary_size);
13954
13955 local_free (binary);
13956 }
13957 else
13958 {
13959 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13960
13961 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13962
13963 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13964
13965 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
13966 }
13967
13968 local_free (kernel_lengths);
13969 local_free (kernel_sources[0]);
13970 local_free (kernel_sources);
13971 }
13972
13973 /**
13974 * amplifier kernel
13975 */
13976
13977 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13978 {
13979
13980 }
13981 else
13982 {
13983 /**
13984 * kernel amp source filename
13985 */
13986
13987 char source_file[256] = { 0 };
13988
13989 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13990
13991 struct stat sst;
13992
13993 if (stat (source_file, &sst) == -1)
13994 {
13995 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13996
13997 return -1;
13998 }
13999
14000 /**
14001 * kernel amp cached filename
14002 */
14003
14004 char cached_file[256] = { 0 };
14005
14006 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14007
14008 int cached = 1;
14009
14010 struct stat cst;
14011
14012 if (stat (cached_file, &cst) == -1)
14013 {
14014 cached = 0;
14015 }
14016
14017 /**
14018 * kernel compile or load
14019 */
14020
14021 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14022
14023 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14024
14025 if (cached == 0)
14026 {
14027 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14028
14029 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14030
14031 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14032
14033 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14034
14035 if (rc != 0)
14036 {
14037 device_param->skipped = true;
14038 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14039 continue;
14040 }
14041
14042 size_t binary_size;
14043
14044 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14045
14046 u8 *binary = (u8 *) mymalloc (binary_size);
14047
14048 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14049
14050 writeProgramBin (cached_file, binary, binary_size);
14051
14052 local_free (binary);
14053 }
14054 else
14055 {
14056 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14057
14058 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14059
14060 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14061
14062 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14063 }
14064
14065 local_free (kernel_lengths);
14066 local_free (kernel_sources[0]);
14067 local_free (kernel_sources);
14068 }
14069
14070 // some algorithm collide too fast, make that impossible
14071
14072 if (benchmark == 1)
14073 {
14074 ((uint *) digests_buf)[0] = -1;
14075 ((uint *) digests_buf)[1] = -1;
14076 ((uint *) digests_buf)[2] = -1;
14077 ((uint *) digests_buf)[3] = -1;
14078 }
14079
14080 /**
14081 * global buffers
14082 */
14083
14084 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14085 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14086 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14087 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14088 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14089 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14090 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14091 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14092 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14093 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14094 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14095 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14096 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14097 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14098 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14099 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14100 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14101 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14102
14103 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);
14104 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);
14105 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);
14106 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);
14107 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);
14108 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);
14109 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);
14110 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);
14111 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14112 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14113 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14114
14115 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14116 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14117 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14118 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14119 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14120 run_kernel_bzero (device_param, device_param->d_result, size_results);
14121
14122 /**
14123 * special buffers
14124 */
14125
14126 if (attack_kern == ATTACK_KERN_STRAIGHT)
14127 {
14128 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14129 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14130
14131 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14132
14133 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14134 }
14135 else if (attack_kern == ATTACK_KERN_COMBI)
14136 {
14137 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14138 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14139 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14140 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14141
14142 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14143 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14144 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14145 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14146 }
14147 else if (attack_kern == ATTACK_KERN_BF)
14148 {
14149 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14150 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14151 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14152 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14153 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14154
14155 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14156 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14157 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14158 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14159 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14160 }
14161
14162 if (size_esalts)
14163 {
14164 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14165
14166 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14167 }
14168
14169 /**
14170 * main host data
14171 */
14172
14173 uint *result = (uint *) mymalloc (size_results);
14174
14175 device_param->result = result;
14176
14177 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14178
14179 device_param->pws_buf = pws_buf;
14180
14181 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14182
14183 device_param->combs_buf = combs_buf;
14184
14185 void *hooks_buf = mymalloc (size_hooks);
14186
14187 device_param->hooks_buf = hooks_buf;
14188
14189 /**
14190 * kernel args
14191 */
14192
14193 device_param->kernel_params_buf32[21] = bitmap_mask;
14194 device_param->kernel_params_buf32[22] = bitmap_shift1;
14195 device_param->kernel_params_buf32[23] = bitmap_shift2;
14196 device_param->kernel_params_buf32[24] = 0; // salt_pos
14197 device_param->kernel_params_buf32[25] = 0; // loop_pos
14198 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14199 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14200 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14201 device_param->kernel_params_buf32[29] = 0; // digests_offset
14202 device_param->kernel_params_buf32[30] = 0; // combs_mode
14203 device_param->kernel_params_buf32[31] = 0; // gid_max
14204
14205 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14206 ? &device_param->d_pws_buf
14207 : &device_param->d_pws_amp_buf;
14208 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14209 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14210 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14211 device_param->kernel_params[ 4] = &device_param->d_tmps;
14212 device_param->kernel_params[ 5] = &device_param->d_hooks;
14213 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14214 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14215 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14216 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14217 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14218 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14219 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14220 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14221 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14222 device_param->kernel_params[15] = &device_param->d_digests_buf;
14223 device_param->kernel_params[16] = &device_param->d_digests_shown;
14224 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14225 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14226 device_param->kernel_params[19] = &device_param->d_result;
14227 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14228 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14229 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14230 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14231 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14232 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14233 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14234 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14235 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14236 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14237 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14238 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14239
14240 device_param->kernel_params_mp_buf64[3] = 0;
14241 device_param->kernel_params_mp_buf32[4] = 0;
14242 device_param->kernel_params_mp_buf32[5] = 0;
14243 device_param->kernel_params_mp_buf32[6] = 0;
14244 device_param->kernel_params_mp_buf32[7] = 0;
14245 device_param->kernel_params_mp_buf32[8] = 0;
14246
14247 device_param->kernel_params_mp[0] = NULL;
14248 device_param->kernel_params_mp[1] = NULL;
14249 device_param->kernel_params_mp[2] = NULL;
14250 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14251 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14252 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14253 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14254 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14255 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14256
14257 device_param->kernel_params_mp_l_buf64[3] = 0;
14258 device_param->kernel_params_mp_l_buf32[4] = 0;
14259 device_param->kernel_params_mp_l_buf32[5] = 0;
14260 device_param->kernel_params_mp_l_buf32[6] = 0;
14261 device_param->kernel_params_mp_l_buf32[7] = 0;
14262 device_param->kernel_params_mp_l_buf32[8] = 0;
14263 device_param->kernel_params_mp_l_buf32[9] = 0;
14264
14265 device_param->kernel_params_mp_l[0] = NULL;
14266 device_param->kernel_params_mp_l[1] = NULL;
14267 device_param->kernel_params_mp_l[2] = NULL;
14268 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14269 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14270 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14271 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14272 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14273 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14274 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14275
14276 device_param->kernel_params_mp_r_buf64[3] = 0;
14277 device_param->kernel_params_mp_r_buf32[4] = 0;
14278 device_param->kernel_params_mp_r_buf32[5] = 0;
14279 device_param->kernel_params_mp_r_buf32[6] = 0;
14280 device_param->kernel_params_mp_r_buf32[7] = 0;
14281 device_param->kernel_params_mp_r_buf32[8] = 0;
14282
14283 device_param->kernel_params_mp_r[0] = NULL;
14284 device_param->kernel_params_mp_r[1] = NULL;
14285 device_param->kernel_params_mp_r[2] = NULL;
14286 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14287 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14288 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14289 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14290 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14291 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14292
14293 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14294 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14295
14296 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14297 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14298 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14299 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14300 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14301 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14302 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14303
14304 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14305
14306 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14307 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14308
14309 /**
14310 * kernel name
14311 */
14312
14313 char kernel_name[64] = { 0 };
14314
14315 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14316 {
14317 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14318 {
14319 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14320
14321 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14322
14323 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14324
14325 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14326
14327 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14328
14329 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14330 }
14331 else
14332 {
14333 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14334
14335 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14336
14337 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14338
14339 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14340
14341 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14342
14343 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14344 }
14345
14346 if (data.attack_mode == ATTACK_MODE_BF)
14347 {
14348 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14349 {
14350 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14351
14352 device_param->kernel_tb = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14353
14354 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14355
14356 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14357 }
14358 }
14359 }
14360 else
14361 {
14362 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14363
14364 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14365
14366 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14367
14368 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14369
14370 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14371
14372 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14373
14374 if (opts_type & OPTS_TYPE_HOOK12)
14375 {
14376 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14377
14378 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14379 }
14380
14381 if (opts_type & OPTS_TYPE_HOOK23)
14382 {
14383 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14384
14385 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14386 }
14387 }
14388
14389 for (uint i = 0; i <= 20; i++)
14390 {
14391 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14392 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14393 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14394
14395 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14396 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14397 }
14398
14399 for (uint i = 21; i <= 31; i++)
14400 {
14401 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14402 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14403 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14404
14405 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14406 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14407 }
14408
14409 if (attack_mode == ATTACK_MODE_BF)
14410 {
14411 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14412 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14413
14414 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14415 {
14416 hc_clSetKernelArg (data.ocl, device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14417
14418 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14419 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14420 }
14421 }
14422 else if (attack_mode == ATTACK_MODE_HYBRID1)
14423 {
14424 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14425 }
14426 else if (attack_mode == ATTACK_MODE_HYBRID2)
14427 {
14428 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14429 }
14430
14431 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14432 {
14433 // nothing to do
14434 }
14435 else
14436 {
14437 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14438 }
14439
14440 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14441 {
14442 // nothing to do
14443 }
14444 else
14445 {
14446 for (uint i = 0; i < 5; i++)
14447 {
14448 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14449 }
14450
14451 for (uint i = 5; i < 7; i++)
14452 {
14453 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14454 }
14455 }
14456
14457 /**
14458 * Store initial fanspeed if gpu_temp_retain is enabled
14459 */
14460
14461 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14462 int gpu_temp_retain_set = 0;
14463
14464 if (gpu_temp_disable == 0)
14465 {
14466 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14467 {
14468 hc_thread_mutex_lock (mux_adl);
14469
14470 if (data.hm_device[device_id].fan_supported == 1)
14471 {
14472 if (gpu_temp_retain_chgd == 0)
14473 {
14474 uint cur_temp = 0;
14475 uint default_temp = 0;
14476
14477 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);
14478
14479 if (ADL_rc == ADL_OK)
14480 {
14481 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14482
14483 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14484
14485 // special case with multi gpu setups: always use minimum retain
14486
14487 if (gpu_temp_retain_set == 0)
14488 {
14489 gpu_temp_retain = gpu_temp_retain_target;
14490 gpu_temp_retain_set = 1;
14491 }
14492 else
14493 {
14494 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14495 }
14496
14497 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14498 }
14499 }
14500
14501 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14502
14503 temp_retain_fanspeed_value[device_id] = fan_speed;
14504
14505 if (fan_speed == -1)
14506 {
14507 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14508
14509 temp_retain_fanspeed_value[device_id] = 0;
14510 }
14511 }
14512
14513 hc_thread_mutex_unlock (mux_adl);
14514 }
14515 }
14516
14517 /**
14518 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14519 */
14520
14521 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14522 {
14523 hc_thread_mutex_lock (mux_adl);
14524
14525 if (data.hm_device[device_id].od_version == 6)
14526 {
14527 int ADL_rc;
14528
14529 // check powertune capabilities first, if not available then skip device
14530
14531 int powertune_supported = 0;
14532
14533 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14534 {
14535 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14536
14537 return (-1);
14538 }
14539
14540 if (powertune_supported != 0)
14541 {
14542 // powercontrol settings
14543
14544 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14545
14546 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14547 {
14548 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14549 }
14550
14551 if (ADL_rc != ADL_OK)
14552 {
14553 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14554
14555 return (-1);
14556 }
14557
14558 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14559 {
14560 log_error ("ERROR: Failed to set new ADL PowerControl values");
14561
14562 return (-1);
14563 }
14564
14565 // clocks
14566
14567 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14568
14569 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14570
14571 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)
14572 {
14573 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14574
14575 return (-1);
14576 }
14577
14578 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14579
14580 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14581
14582 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14583 {
14584 log_error ("ERROR: Failed to get ADL device capabilities");
14585
14586 return (-1);
14587 }
14588
14589 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14590 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14591
14592 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14593 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14594
14595 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14596 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14597
14598 // warning if profile has too low max values
14599
14600 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14601 {
14602 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14603 }
14604
14605 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14606 {
14607 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14608 }
14609
14610 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14611
14612 performance_state->iNumberOfPerformanceLevels = 2;
14613
14614 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14615 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14616 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14617 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14618
14619 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)
14620 {
14621 log_info ("ERROR: Failed to set ADL performance state");
14622
14623 return (-1);
14624 }
14625
14626 local_free (performance_state);
14627 }
14628 }
14629
14630 hc_thread_mutex_unlock (mux_adl);
14631 }
14632 #endif // HAVE_HWMON && HAVE_ADL
14633 }
14634
14635 data.kernel_power_all = kernel_power_all;
14636
14637 if (data.quiet == 0) log_info ("");
14638
14639 /**
14640 * Inform user which algorithm is checked and at which workload setting
14641 */
14642
14643 if (benchmark == 1)
14644 {
14645 quiet = 0;
14646
14647 data.quiet = quiet;
14648
14649 char *hash_type = strhashtype (data.hash_mode); // not a bug
14650
14651 log_info ("Hashtype: %s", hash_type);
14652 log_info ("");
14653 }
14654
14655 /**
14656 * keep track of the progress
14657 */
14658
14659 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14660 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14661 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14662
14663 /**
14664 * open filehandles
14665 */
14666
14667 #if _WIN
14668 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14669 {
14670 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14671
14672 return (-1);
14673 }
14674
14675 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14676 {
14677 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14678
14679 return (-1);
14680 }
14681
14682 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14683 {
14684 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14685
14686 return (-1);
14687 }
14688 #endif
14689
14690 /**
14691 * dictionary pad
14692 */
14693
14694 segment_size *= (1024 * 1024);
14695
14696 data.segment_size = segment_size;
14697
14698 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14699
14700 wl_data->buf = (char *) mymalloc (segment_size);
14701 wl_data->avail = segment_size;
14702 wl_data->incr = segment_size;
14703 wl_data->cnt = 0;
14704 wl_data->pos = 0;
14705
14706 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14707
14708 data.wordlist_mode = wordlist_mode;
14709
14710 cs_t *css_buf = NULL;
14711 uint css_cnt = 0;
14712 uint dictcnt = 0;
14713 uint maskcnt = 1;
14714 char **masks = NULL;
14715 char **dictfiles = NULL;
14716
14717 uint mask_from_file = 0;
14718
14719 if (attack_mode == ATTACK_MODE_STRAIGHT)
14720 {
14721 if (wordlist_mode == WL_MODE_FILE)
14722 {
14723 int wls_left = myargc - (optind + 1);
14724
14725 for (int i = 0; i < wls_left; i++)
14726 {
14727 char *l0_filename = myargv[optind + 1 + i];
14728
14729 struct stat l0_stat;
14730
14731 if (stat (l0_filename, &l0_stat) == -1)
14732 {
14733 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14734
14735 return (-1);
14736 }
14737
14738 uint is_dir = S_ISDIR (l0_stat.st_mode);
14739
14740 if (is_dir == 0)
14741 {
14742 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14743
14744 dictcnt++;
14745
14746 dictfiles[dictcnt - 1] = l0_filename;
14747 }
14748 else
14749 {
14750 // do not allow --keyspace w/ a directory
14751
14752 if (keyspace == 1)
14753 {
14754 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14755
14756 return (-1);
14757 }
14758
14759 char **dictionary_files = NULL;
14760
14761 dictionary_files = scan_directory (l0_filename);
14762
14763 if (dictionary_files != NULL)
14764 {
14765 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14766
14767 for (int d = 0; dictionary_files[d] != NULL; d++)
14768 {
14769 char *l1_filename = dictionary_files[d];
14770
14771 struct stat l1_stat;
14772
14773 if (stat (l1_filename, &l1_stat) == -1)
14774 {
14775 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14776
14777 return (-1);
14778 }
14779
14780 if (S_ISREG (l1_stat.st_mode))
14781 {
14782 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14783
14784 dictcnt++;
14785
14786 dictfiles[dictcnt - 1] = strdup (l1_filename);
14787 }
14788 }
14789 }
14790
14791 local_free (dictionary_files);
14792 }
14793 }
14794
14795 if (dictcnt < 1)
14796 {
14797 log_error ("ERROR: No usable dictionary file found.");
14798
14799 return (-1);
14800 }
14801 }
14802 else if (wordlist_mode == WL_MODE_STDIN)
14803 {
14804 dictcnt = 1;
14805 }
14806 }
14807 else if (attack_mode == ATTACK_MODE_COMBI)
14808 {
14809 // display
14810
14811 char *dictfile1 = myargv[optind + 1 + 0];
14812 char *dictfile2 = myargv[optind + 1 + 1];
14813
14814 // find the bigger dictionary and use as base
14815
14816 FILE *fp1 = NULL;
14817 FILE *fp2 = NULL;
14818
14819 struct stat tmp_stat;
14820
14821 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14822 {
14823 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14824
14825 return (-1);
14826 }
14827
14828 if (stat (dictfile1, &tmp_stat) == -1)
14829 {
14830 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14831
14832 fclose (fp1);
14833
14834 return (-1);
14835 }
14836
14837 if (S_ISDIR (tmp_stat.st_mode))
14838 {
14839 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14840
14841 fclose (fp1);
14842
14843 return (-1);
14844 }
14845
14846 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14847 {
14848 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14849
14850 fclose (fp1);
14851
14852 return (-1);
14853 }
14854
14855 if (stat (dictfile2, &tmp_stat) == -1)
14856 {
14857 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14858
14859 fclose (fp1);
14860 fclose (fp2);
14861
14862 return (-1);
14863 }
14864
14865 if (S_ISDIR (tmp_stat.st_mode))
14866 {
14867 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14868
14869 fclose (fp1);
14870 fclose (fp2);
14871
14872 return (-1);
14873 }
14874
14875 data.combs_cnt = 1;
14876
14877 data.quiet = 1;
14878
14879 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14880
14881 data.quiet = quiet;
14882
14883 if (words1_cnt == 0)
14884 {
14885 log_error ("ERROR: %s: empty file", dictfile1);
14886
14887 fclose (fp1);
14888 fclose (fp2);
14889
14890 return (-1);
14891 }
14892
14893 data.combs_cnt = 1;
14894
14895 data.quiet = 1;
14896
14897 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14898
14899 data.quiet = quiet;
14900
14901 if (words2_cnt == 0)
14902 {
14903 log_error ("ERROR: %s: empty file", dictfile2);
14904
14905 fclose (fp1);
14906 fclose (fp2);
14907
14908 return (-1);
14909 }
14910
14911 fclose (fp1);
14912 fclose (fp2);
14913
14914 data.dictfile = dictfile1;
14915 data.dictfile2 = dictfile2;
14916
14917 if (words1_cnt >= words2_cnt)
14918 {
14919 data.combs_cnt = words2_cnt;
14920 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14921
14922 dictfiles = &data.dictfile;
14923
14924 dictcnt = 1;
14925 }
14926 else
14927 {
14928 data.combs_cnt = words1_cnt;
14929 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14930
14931 dictfiles = &data.dictfile2;
14932
14933 dictcnt = 1;
14934
14935 // we also have to switch wordlist related rules!
14936
14937 char *tmpc = data.rule_buf_l;
14938
14939 data.rule_buf_l = data.rule_buf_r;
14940 data.rule_buf_r = tmpc;
14941
14942 int tmpi = data.rule_len_l;
14943
14944 data.rule_len_l = data.rule_len_r;
14945 data.rule_len_r = tmpi;
14946 }
14947 }
14948 else if (attack_mode == ATTACK_MODE_BF)
14949 {
14950 char *mask = NULL;
14951
14952 maskcnt = 0;
14953
14954 if (benchmark == 0)
14955 {
14956 mask = myargv[optind + 1];
14957
14958 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14959
14960 if ((optind + 2) <= myargc)
14961 {
14962 struct stat file_stat;
14963
14964 if (stat (mask, &file_stat) == -1)
14965 {
14966 maskcnt = 1;
14967
14968 masks[maskcnt - 1] = mystrdup (mask);
14969 }
14970 else
14971 {
14972 int wls_left = myargc - (optind + 1);
14973
14974 uint masks_avail = INCR_MASKS;
14975
14976 for (int i = 0; i < wls_left; i++)
14977 {
14978 if (i != 0)
14979 {
14980 mask = myargv[optind + 1 + i];
14981
14982 if (stat (mask, &file_stat) == -1)
14983 {
14984 log_error ("ERROR: %s: %s", mask, strerror (errno));
14985
14986 return (-1);
14987 }
14988 }
14989
14990 uint is_file = S_ISREG (file_stat.st_mode);
14991
14992 if (is_file == 1)
14993 {
14994 FILE *mask_fp;
14995
14996 if ((mask_fp = fopen (mask, "r")) == NULL)
14997 {
14998 log_error ("ERROR: %s: %s", mask, strerror (errno));
14999
15000 return (-1);
15001 }
15002
15003 char line_buf[BUFSIZ] = { 0 };
15004
15005 while (!feof (mask_fp))
15006 {
15007 memset (line_buf, 0, BUFSIZ);
15008
15009 int line_len = fgetl (mask_fp, line_buf);
15010
15011 if (line_len == 0) continue;
15012
15013 if (line_buf[0] == '#') continue;
15014
15015 if (masks_avail == maskcnt)
15016 {
15017 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15018
15019 masks_avail += INCR_MASKS;
15020 }
15021
15022 masks[maskcnt] = mystrdup (line_buf);
15023
15024 maskcnt++;
15025 }
15026
15027 fclose (mask_fp);
15028 }
15029 else
15030 {
15031 log_error ("ERROR: %s: unsupported file-type", mask);
15032
15033 return (-1);
15034 }
15035 }
15036
15037 mask_from_file = 1;
15038 }
15039 }
15040 else
15041 {
15042 custom_charset_1 = (char *) "?l?d?u";
15043 custom_charset_2 = (char *) "?l?d";
15044 custom_charset_3 = (char *) "?l?d*!$@_";
15045
15046 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15047 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15048 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15049
15050 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15051
15052 wordlist_mode = WL_MODE_MASK;
15053
15054 data.wordlist_mode = wordlist_mode;
15055
15056 increment = 1;
15057
15058 maskcnt = 1;
15059 }
15060 }
15061 else
15062 {
15063 /**
15064 * generate full masks and charsets
15065 */
15066
15067 masks = (char **) mymalloc (sizeof (char *));
15068
15069 switch (hash_mode)
15070 {
15071 case 1731: pw_min = 5;
15072 pw_max = 5;
15073 mask = mystrdup ("?b?b?b?b?b");
15074 break;
15075 case 12500: pw_min = 5;
15076 pw_max = 5;
15077 mask = mystrdup ("?b?b?b?b?b");
15078 break;
15079 default: pw_min = 7;
15080 pw_max = 7;
15081 mask = mystrdup ("?b?b?b?b?b?b?b");
15082 break;
15083 }
15084
15085 maskcnt = 1;
15086
15087 masks[maskcnt - 1] = mystrdup (mask);
15088
15089 wordlist_mode = WL_MODE_MASK;
15090
15091 data.wordlist_mode = wordlist_mode;
15092
15093 increment = 1;
15094 }
15095
15096 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15097
15098 if (increment)
15099 {
15100 if (increment_min > pw_min) pw_min = increment_min;
15101
15102 if (increment_max < pw_max) pw_max = increment_max;
15103 }
15104 }
15105 else if (attack_mode == ATTACK_MODE_HYBRID1)
15106 {
15107 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15108
15109 // display
15110
15111 char *mask = myargv[myargc - 1];
15112
15113 maskcnt = 0;
15114
15115 masks = (char **) mymalloc (1 * sizeof (char *));
15116
15117 // mod
15118
15119 struct stat file_stat;
15120
15121 if (stat (mask, &file_stat) == -1)
15122 {
15123 maskcnt = 1;
15124
15125 masks[maskcnt - 1] = mystrdup (mask);
15126 }
15127 else
15128 {
15129 uint is_file = S_ISREG (file_stat.st_mode);
15130
15131 if (is_file == 1)
15132 {
15133 FILE *mask_fp;
15134
15135 if ((mask_fp = fopen (mask, "r")) == NULL)
15136 {
15137 log_error ("ERROR: %s: %s", mask, strerror (errno));
15138
15139 return (-1);
15140 }
15141
15142 char line_buf[BUFSIZ] = { 0 };
15143
15144 uint masks_avail = 1;
15145
15146 while (!feof (mask_fp))
15147 {
15148 memset (line_buf, 0, BUFSIZ);
15149
15150 int line_len = fgetl (mask_fp, line_buf);
15151
15152 if (line_len == 0) continue;
15153
15154 if (line_buf[0] == '#') continue;
15155
15156 if (masks_avail == maskcnt)
15157 {
15158 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15159
15160 masks_avail += INCR_MASKS;
15161 }
15162
15163 masks[maskcnt] = mystrdup (line_buf);
15164
15165 maskcnt++;
15166 }
15167
15168 fclose (mask_fp);
15169
15170 mask_from_file = 1;
15171 }
15172 else
15173 {
15174 maskcnt = 1;
15175
15176 masks[maskcnt - 1] = mystrdup (mask);
15177 }
15178 }
15179
15180 // base
15181
15182 int wls_left = myargc - (optind + 2);
15183
15184 for (int i = 0; i < wls_left; i++)
15185 {
15186 char *filename = myargv[optind + 1 + i];
15187
15188 struct stat file_stat;
15189
15190 if (stat (filename, &file_stat) == -1)
15191 {
15192 log_error ("ERROR: %s: %s", filename, strerror (errno));
15193
15194 return (-1);
15195 }
15196
15197 uint is_dir = S_ISDIR (file_stat.st_mode);
15198
15199 if (is_dir == 0)
15200 {
15201 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15202
15203 dictcnt++;
15204
15205 dictfiles[dictcnt - 1] = filename;
15206 }
15207 else
15208 {
15209 // do not allow --keyspace w/ a directory
15210
15211 if (keyspace == 1)
15212 {
15213 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15214
15215 return (-1);
15216 }
15217
15218 char **dictionary_files = NULL;
15219
15220 dictionary_files = scan_directory (filename);
15221
15222 if (dictionary_files != NULL)
15223 {
15224 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15225
15226 for (int d = 0; dictionary_files[d] != NULL; d++)
15227 {
15228 char *l1_filename = dictionary_files[d];
15229
15230 struct stat l1_stat;
15231
15232 if (stat (l1_filename, &l1_stat) == -1)
15233 {
15234 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15235
15236 return (-1);
15237 }
15238
15239 if (S_ISREG (l1_stat.st_mode))
15240 {
15241 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15242
15243 dictcnt++;
15244
15245 dictfiles[dictcnt - 1] = strdup (l1_filename);
15246 }
15247 }
15248 }
15249
15250 local_free (dictionary_files);
15251 }
15252 }
15253
15254 if (dictcnt < 1)
15255 {
15256 log_error ("ERROR: No usable dictionary file found.");
15257
15258 return (-1);
15259 }
15260
15261 if (increment)
15262 {
15263 maskcnt = 0;
15264
15265 uint mask_min = increment_min; // we can't reject smaller masks here
15266 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15267
15268 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15269 {
15270 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15271
15272 if (cur_mask == NULL) break;
15273
15274 masks[maskcnt] = cur_mask;
15275
15276 maskcnt++;
15277
15278 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15279 }
15280 }
15281 }
15282 else if (attack_mode == ATTACK_MODE_HYBRID2)
15283 {
15284 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15285
15286 // display
15287
15288 char *mask = myargv[optind + 1 + 0];
15289
15290 maskcnt = 0;
15291
15292 masks = (char **) mymalloc (1 * sizeof (char *));
15293
15294 // mod
15295
15296 struct stat file_stat;
15297
15298 if (stat (mask, &file_stat) == -1)
15299 {
15300 maskcnt = 1;
15301
15302 masks[maskcnt - 1] = mystrdup (mask);
15303 }
15304 else
15305 {
15306 uint is_file = S_ISREG (file_stat.st_mode);
15307
15308 if (is_file == 1)
15309 {
15310 FILE *mask_fp;
15311
15312 if ((mask_fp = fopen (mask, "r")) == NULL)
15313 {
15314 log_error ("ERROR: %s: %s", mask, strerror (errno));
15315
15316 return (-1);
15317 }
15318
15319 char line_buf[BUFSIZ] = { 0 };
15320
15321 uint masks_avail = 1;
15322
15323 while (!feof (mask_fp))
15324 {
15325 memset (line_buf, 0, BUFSIZ);
15326
15327 int line_len = fgetl (mask_fp, line_buf);
15328
15329 if (line_len == 0) continue;
15330
15331 if (line_buf[0] == '#') continue;
15332
15333 if (masks_avail == maskcnt)
15334 {
15335 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15336
15337 masks_avail += INCR_MASKS;
15338 }
15339
15340 masks[maskcnt] = mystrdup (line_buf);
15341
15342 maskcnt++;
15343 }
15344
15345 fclose (mask_fp);
15346
15347 mask_from_file = 1;
15348 }
15349 else
15350 {
15351 maskcnt = 1;
15352
15353 masks[maskcnt - 1] = mystrdup (mask);
15354 }
15355 }
15356
15357 // base
15358
15359 int wls_left = myargc - (optind + 2);
15360
15361 for (int i = 0; i < wls_left; i++)
15362 {
15363 char *filename = myargv[optind + 2 + i];
15364
15365 struct stat file_stat;
15366
15367 if (stat (filename, &file_stat) == -1)
15368 {
15369 log_error ("ERROR: %s: %s", filename, strerror (errno));
15370
15371 return (-1);
15372 }
15373
15374 uint is_dir = S_ISDIR (file_stat.st_mode);
15375
15376 if (is_dir == 0)
15377 {
15378 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15379
15380 dictcnt++;
15381
15382 dictfiles[dictcnt - 1] = filename;
15383 }
15384 else
15385 {
15386 // do not allow --keyspace w/ a directory
15387
15388 if (keyspace == 1)
15389 {
15390 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15391
15392 return (-1);
15393 }
15394
15395 char **dictionary_files = NULL;
15396
15397 dictionary_files = scan_directory (filename);
15398
15399 if (dictionary_files != NULL)
15400 {
15401 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15402
15403 for (int d = 0; dictionary_files[d] != NULL; d++)
15404 {
15405 char *l1_filename = dictionary_files[d];
15406
15407 struct stat l1_stat;
15408
15409 if (stat (l1_filename, &l1_stat) == -1)
15410 {
15411 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15412
15413 return (-1);
15414 }
15415
15416 if (S_ISREG (l1_stat.st_mode))
15417 {
15418 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15419
15420 dictcnt++;
15421
15422 dictfiles[dictcnt - 1] = strdup (l1_filename);
15423 }
15424 }
15425 }
15426
15427 local_free (dictionary_files);
15428 }
15429 }
15430
15431 if (dictcnt < 1)
15432 {
15433 log_error ("ERROR: No usable dictionary file found.");
15434
15435 return (-1);
15436 }
15437
15438 if (increment)
15439 {
15440 maskcnt = 0;
15441
15442 uint mask_min = increment_min; // we can't reject smaller masks here
15443 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15444
15445 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15446 {
15447 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15448
15449 if (cur_mask == NULL) break;
15450
15451 masks[maskcnt] = cur_mask;
15452
15453 maskcnt++;
15454
15455 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15456 }
15457 }
15458 }
15459
15460 data.pw_min = pw_min;
15461 data.pw_max = pw_max;
15462
15463 /**
15464 * weak hash check
15465 */
15466
15467 if (weak_hash_threshold >= salts_cnt)
15468 {
15469 hc_device_param_t *device_param = NULL;
15470
15471 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15472 {
15473 device_param = &data.devices_param[device_id];
15474
15475 if (device_param->skipped) continue;
15476
15477 break;
15478 }
15479
15480 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15481
15482 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15483 {
15484 weak_hash_check (device_param, salt_pos);
15485 }
15486 }
15487
15488 // Display hack, guarantee that there is at least one \r before real start
15489
15490 if (data.quiet == 0) log_info_nn ("");
15491
15492 /**
15493 * status and monitor threads
15494 */
15495
15496 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15497
15498 hc_thread_t i_thread = 0;
15499
15500 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15501 {
15502 hc_thread_create (i_thread, thread_keypress, &benchmark);
15503 }
15504
15505 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15506
15507 uint ni_threads_cnt = 0;
15508
15509 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15510
15511 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15512
15513 ni_threads_cnt++;
15514
15515 /**
15516 * Outfile remove
15517 */
15518
15519 if (keyspace == 0)
15520 {
15521 if (outfile_check_timer != 0)
15522 {
15523 if (data.outfile_check_directory != NULL)
15524 {
15525 if ((hash_mode != 5200) &&
15526 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15527 (hash_mode != 9000))
15528 {
15529 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15530
15531 ni_threads_cnt++;
15532 }
15533 else
15534 {
15535 outfile_check_timer = 0;
15536 }
15537 }
15538 else
15539 {
15540 outfile_check_timer = 0;
15541 }
15542 }
15543 }
15544
15545 /**
15546 * Inform the user if we got some hashes remove because of the pot file remove feature
15547 */
15548
15549 if (data.quiet == 0)
15550 {
15551 if (potfile_remove_cracks > 0)
15552 {
15553 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15554 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15555 }
15556 }
15557
15558 data.outfile_check_timer = outfile_check_timer;
15559
15560 /**
15561 * main loop
15562 */
15563
15564 char **induction_dictionaries = NULL;
15565
15566 int induction_dictionaries_cnt = 0;
15567
15568 hcstat_table_t *root_table_buf = NULL;
15569 hcstat_table_t *markov_table_buf = NULL;
15570
15571 uint initial_restore_done = 0;
15572
15573 data.maskcnt = maskcnt;
15574
15575 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15576 {
15577 if (data.devices_status == STATUS_CRACKED) break;
15578
15579 data.devices_status = STATUS_INIT;
15580
15581 if (maskpos > rd->maskpos)
15582 {
15583 rd->dictpos = 0;
15584 }
15585
15586 rd->maskpos = maskpos;
15587 data.maskpos = maskpos;
15588
15589 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15590 {
15591 char *mask = masks[maskpos];
15592
15593 if (mask_from_file == 1)
15594 {
15595 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15596
15597 char *str_ptr;
15598 uint str_pos;
15599
15600 uint mask_offset = 0;
15601
15602 uint separator_cnt;
15603
15604 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15605 {
15606 str_ptr = strstr (mask + mask_offset, ",");
15607
15608 if (str_ptr == NULL) break;
15609
15610 str_pos = str_ptr - mask;
15611
15612 // escaped separator, i.e. "\,"
15613
15614 if (str_pos > 0)
15615 {
15616 if (mask[str_pos - 1] == '\\')
15617 {
15618 separator_cnt --;
15619
15620 mask_offset = str_pos + 1;
15621
15622 continue;
15623 }
15624 }
15625
15626 // reset the offset
15627
15628 mask_offset = 0;
15629
15630 mask[str_pos] = '\0';
15631
15632 switch (separator_cnt)
15633 {
15634 case 0:
15635 mp_reset_usr (mp_usr, 0);
15636
15637 custom_charset_1 = mask;
15638 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15639 break;
15640
15641 case 1:
15642 mp_reset_usr (mp_usr, 1);
15643
15644 custom_charset_2 = mask;
15645 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15646 break;
15647
15648 case 2:
15649 mp_reset_usr (mp_usr, 2);
15650
15651 custom_charset_3 = mask;
15652 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15653 break;
15654
15655 case 3:
15656 mp_reset_usr (mp_usr, 3);
15657
15658 custom_charset_4 = mask;
15659 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15660 break;
15661 }
15662
15663 mask = mask + str_pos + 1;
15664 }
15665 }
15666
15667 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15668 {
15669 if (maskpos > 0)
15670 {
15671 local_free (css_buf);
15672 local_free (data.root_css_buf);
15673 local_free (data.markov_css_buf);
15674
15675 local_free (masks[maskpos - 1]);
15676 }
15677
15678 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15679
15680 data.mask = mask;
15681 data.css_cnt = css_cnt;
15682 data.css_buf = css_buf;
15683
15684 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15685
15686 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15687
15688 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15689 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15690
15691 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15692
15693 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15694
15695 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15696 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15697
15698 data.root_css_buf = root_css_buf;
15699 data.markov_css_buf = markov_css_buf;
15700
15701 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15702
15703 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15704
15705 local_free (root_table_buf);
15706 local_free (markov_table_buf);
15707
15708 // args
15709
15710 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15711 {
15712 hc_device_param_t *device_param = &data.devices_param[device_id];
15713
15714 if (device_param->skipped) continue;
15715
15716 device_param->kernel_params_mp[0] = &device_param->d_combs;
15717 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15718 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15719
15720 device_param->kernel_params_mp_buf64[3] = 0;
15721 device_param->kernel_params_mp_buf32[4] = css_cnt;
15722 device_param->kernel_params_mp_buf32[5] = 0;
15723 device_param->kernel_params_mp_buf32[6] = 0;
15724 device_param->kernel_params_mp_buf32[7] = 0;
15725
15726 if (attack_mode == ATTACK_MODE_HYBRID1)
15727 {
15728 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15729 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15730 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15731 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15732 }
15733 else if (attack_mode == ATTACK_MODE_HYBRID2)
15734 {
15735 device_param->kernel_params_mp_buf32[5] = 0;
15736 device_param->kernel_params_mp_buf32[6] = 0;
15737 device_param->kernel_params_mp_buf32[7] = 0;
15738 }
15739
15740 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]);
15741 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]);
15742 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]);
15743
15744 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);
15745 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);
15746 }
15747 }
15748 else if (attack_mode == ATTACK_MODE_BF)
15749 {
15750 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15751
15752 if (increment)
15753 {
15754 for (uint i = 0; i < dictcnt; i++)
15755 {
15756 local_free (dictfiles[i]);
15757 }
15758
15759 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15760 {
15761 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15762
15763 if (l1_filename == NULL) break;
15764
15765 dictcnt++;
15766
15767 dictfiles[dictcnt - 1] = l1_filename;
15768 }
15769 }
15770 else
15771 {
15772 dictcnt++;
15773
15774 dictfiles[dictcnt - 1] = mask;
15775 }
15776
15777 if (dictcnt == 0)
15778 {
15779 log_error ("ERROR: Mask is too small");
15780
15781 return (-1);
15782 }
15783 }
15784 }
15785
15786 free (induction_dictionaries);
15787
15788 // induction_dictionaries_cnt = 0; // implied
15789
15790 if (attack_mode != ATTACK_MODE_BF)
15791 {
15792 if (keyspace == 0)
15793 {
15794 induction_dictionaries = scan_directory (induction_directory);
15795
15796 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15797 }
15798 }
15799
15800 if (induction_dictionaries_cnt)
15801 {
15802 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15803 }
15804
15805 /**
15806 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15807 */
15808 if (keyspace == 1)
15809 {
15810 if ((maskcnt > 1) || (dictcnt > 1))
15811 {
15812 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15813
15814 return (-1);
15815 }
15816 }
15817
15818 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15819 {
15820 char *subid = logfile_generate_subid ();
15821
15822 data.subid = subid;
15823
15824 logfile_sub_msg ("START");
15825
15826 data.devices_status = STATUS_INIT;
15827
15828 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15829 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15830 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15831
15832 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15833
15834 data.cpt_pos = 0;
15835
15836 data.cpt_start = time (NULL);
15837
15838 data.cpt_total = 0;
15839
15840 if (data.restore == 0)
15841 {
15842 rd->words_cur = skip;
15843
15844 skip = 0;
15845
15846 data.skip = 0;
15847 }
15848
15849 data.ms_paused = 0;
15850
15851 data.words_cur = rd->words_cur;
15852
15853 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15854 {
15855 hc_device_param_t *device_param = &data.devices_param[device_id];
15856
15857 if (device_param->skipped) continue;
15858
15859 device_param->speed_pos = 0;
15860
15861 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15862 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15863 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15864
15865 device_param->exec_pos = 0;
15866
15867 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
15868
15869 device_param->kernel_power = device_param->kernel_power_user;
15870
15871 device_param->outerloop_pos = 0;
15872 device_param->outerloop_left = 0;
15873 device_param->innerloop_pos = 0;
15874 device_param->innerloop_left = 0;
15875
15876 // some more resets:
15877
15878 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
15879
15880 device_param->pws_cnt = 0;
15881
15882 device_param->words_off = 0;
15883 device_param->words_done = 0;
15884 }
15885
15886 data.kernel_power_div = 0;
15887
15888 // figure out some workload
15889
15890 if (attack_mode == ATTACK_MODE_STRAIGHT)
15891 {
15892 if (data.wordlist_mode == WL_MODE_FILE)
15893 {
15894 char *dictfile = NULL;
15895
15896 if (induction_dictionaries_cnt)
15897 {
15898 dictfile = induction_dictionaries[0];
15899 }
15900 else
15901 {
15902 dictfile = dictfiles[dictpos];
15903 }
15904
15905 data.dictfile = dictfile;
15906
15907 logfile_sub_string (dictfile);
15908
15909 for (uint i = 0; i < rp_files_cnt; i++)
15910 {
15911 logfile_sub_var_string ("rulefile", rp_files[i]);
15912 }
15913
15914 FILE *fd2 = fopen (dictfile, "rb");
15915
15916 if (fd2 == NULL)
15917 {
15918 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15919
15920 return (-1);
15921 }
15922
15923 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15924
15925 fclose (fd2);
15926
15927 if (data.words_cnt == 0)
15928 {
15929 if (data.devices_status == STATUS_CRACKED) break;
15930 if (data.devices_status == STATUS_ABORTED) break;
15931
15932 dictpos++;
15933
15934 continue;
15935 }
15936 }
15937 }
15938 else if (attack_mode == ATTACK_MODE_COMBI)
15939 {
15940 char *dictfile = data.dictfile;
15941 char *dictfile2 = data.dictfile2;
15942
15943 logfile_sub_string (dictfile);
15944 logfile_sub_string (dictfile2);
15945
15946 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15947 {
15948 FILE *fd2 = fopen (dictfile, "rb");
15949
15950 if (fd2 == NULL)
15951 {
15952 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15953
15954 return (-1);
15955 }
15956
15957 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15958
15959 fclose (fd2);
15960 }
15961 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15962 {
15963 FILE *fd2 = fopen (dictfile2, "rb");
15964
15965 if (fd2 == NULL)
15966 {
15967 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15968
15969 return (-1);
15970 }
15971
15972 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15973
15974 fclose (fd2);
15975 }
15976
15977 if (data.words_cnt == 0)
15978 {
15979 if (data.devices_status == STATUS_CRACKED) break;
15980 if (data.devices_status == STATUS_ABORTED) break;
15981
15982 dictpos++;
15983
15984 continue;
15985 }
15986 }
15987 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15988 {
15989 char *dictfile = NULL;
15990
15991 if (induction_dictionaries_cnt)
15992 {
15993 dictfile = induction_dictionaries[0];
15994 }
15995 else
15996 {
15997 dictfile = dictfiles[dictpos];
15998 }
15999
16000 data.dictfile = dictfile;
16001
16002 char *mask = data.mask;
16003
16004 logfile_sub_string (dictfile);
16005 logfile_sub_string (mask);
16006
16007 FILE *fd2 = fopen (dictfile, "rb");
16008
16009 if (fd2 == NULL)
16010 {
16011 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16012
16013 return (-1);
16014 }
16015
16016 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16017
16018 fclose (fd2);
16019
16020 if (data.words_cnt == 0)
16021 {
16022 if (data.devices_status == STATUS_CRACKED) break;
16023 if (data.devices_status == STATUS_ABORTED) break;
16024
16025 dictpos++;
16026
16027 continue;
16028 }
16029 }
16030 else if (attack_mode == ATTACK_MODE_BF)
16031 {
16032 local_free (css_buf);
16033 local_free (data.root_css_buf);
16034 local_free (data.markov_css_buf);
16035
16036 char *mask = dictfiles[dictpos];
16037
16038 logfile_sub_string (mask);
16039
16040 // base
16041
16042 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16043
16044 if (opts_type & OPTS_TYPE_PT_UNICODE)
16045 {
16046 uint css_cnt_unicode = css_cnt * 2;
16047
16048 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16049
16050 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16051 {
16052 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16053
16054 css_buf_unicode[j + 1].cs_buf[0] = 0;
16055 css_buf_unicode[j + 1].cs_len = 1;
16056 }
16057
16058 free (css_buf);
16059
16060 css_buf = css_buf_unicode;
16061 css_cnt = css_cnt_unicode;
16062 }
16063
16064 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16065
16066 uint mask_min = pw_min;
16067 uint mask_max = pw_max;
16068
16069 if (opts_type & OPTS_TYPE_PT_UNICODE)
16070 {
16071 mask_min *= 2;
16072 mask_max *= 2;
16073 }
16074
16075 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16076 {
16077 if (css_cnt < mask_min)
16078 {
16079 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16080 }
16081
16082 if (css_cnt > mask_max)
16083 {
16084 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16085 }
16086
16087 // skip to next mask
16088
16089 dictpos++;
16090
16091 rd->dictpos = dictpos;
16092
16093 logfile_sub_msg ("STOP");
16094
16095 continue;
16096 }
16097
16098 uint save_css_cnt = css_cnt;
16099
16100 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16101 {
16102 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16103 {
16104 uint salt_len = (uint) data.salts_buf[0].salt_len;
16105 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16106
16107 uint css_cnt_salt = css_cnt + salt_len;
16108
16109 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16110
16111 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16112
16113 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16114 {
16115 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16116 css_buf_salt[j].cs_len = 1;
16117 }
16118
16119 free (css_buf);
16120
16121 css_buf = css_buf_salt;
16122 css_cnt = css_cnt_salt;
16123 }
16124 }
16125
16126 data.mask = mask;
16127 data.css_cnt = css_cnt;
16128 data.css_buf = css_buf;
16129
16130 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16131
16132 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16133
16134 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16135
16136 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16137 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16138
16139 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16140
16141 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16142
16143 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16144 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16145
16146 data.root_css_buf = root_css_buf;
16147 data.markov_css_buf = markov_css_buf;
16148
16149 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16150
16151 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16152
16153 local_free (root_table_buf);
16154 local_free (markov_table_buf);
16155
16156 // copy + args
16157
16158 uint css_cnt_l = css_cnt;
16159 uint css_cnt_r;
16160
16161 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16162 {
16163 if (save_css_cnt < 6)
16164 {
16165 css_cnt_r = 1;
16166 }
16167 else if (save_css_cnt == 6)
16168 {
16169 css_cnt_r = 2;
16170 }
16171 else
16172 {
16173 if (opts_type & OPTS_TYPE_PT_UNICODE)
16174 {
16175 if (save_css_cnt == 8 || save_css_cnt == 10)
16176 {
16177 css_cnt_r = 2;
16178 }
16179 else
16180 {
16181 css_cnt_r = 4;
16182 }
16183 }
16184 else
16185 {
16186 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16187 {
16188 css_cnt_r = 3;
16189 }
16190 else
16191 {
16192 css_cnt_r = 4;
16193 }
16194 }
16195 }
16196 }
16197 else
16198 {
16199 css_cnt_r = 1;
16200
16201 /* unfinished code?
16202 int sum = css_buf[css_cnt_r - 1].cs_len;
16203
16204 for (uint i = 1; i < 4 && i < css_cnt; i++)
16205 {
16206 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16207
16208 css_cnt_r++;
16209
16210 sum *= css_buf[css_cnt_r - 1].cs_len;
16211 }
16212 */
16213 }
16214
16215 css_cnt_l -= css_cnt_r;
16216
16217 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16218
16219 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16220 {
16221 hc_device_param_t *device_param = &data.devices_param[device_id];
16222
16223 if (device_param->skipped) continue;
16224
16225 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16226 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16227 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16228
16229 device_param->kernel_params_mp_l_buf64[3] = 0;
16230 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16231 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16232 device_param->kernel_params_mp_l_buf32[6] = 0;
16233 device_param->kernel_params_mp_l_buf32[7] = 0;
16234 device_param->kernel_params_mp_l_buf32[8] = 0;
16235
16236 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16237 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16238 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16239 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16240
16241 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16242 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16243 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16244
16245 device_param->kernel_params_mp_r_buf64[3] = 0;
16246 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16247 device_param->kernel_params_mp_r_buf32[5] = 0;
16248 device_param->kernel_params_mp_r_buf32[6] = 0;
16249 device_param->kernel_params_mp_r_buf32[7] = 0;
16250
16251 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]);
16252 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]);
16253 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]);
16254
16255 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]);
16256 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]);
16257 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]);
16258
16259 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);
16260 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);
16261 }
16262 }
16263
16264 u64 words_base = data.words_cnt;
16265
16266 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16267 {
16268 if (data.kernel_rules_cnt)
16269 {
16270 words_base /= data.kernel_rules_cnt;
16271 }
16272 }
16273 else if (data.attack_kern == ATTACK_KERN_COMBI)
16274 {
16275 if (data.combs_cnt)
16276 {
16277 words_base /= data.combs_cnt;
16278 }
16279 }
16280 else if (data.attack_kern == ATTACK_KERN_BF)
16281 {
16282 if (data.bfs_cnt)
16283 {
16284 words_base /= data.bfs_cnt;
16285 }
16286 }
16287
16288 data.words_base = words_base;
16289
16290 if (keyspace == 1)
16291 {
16292 log_info ("%llu", (unsigned long long int) words_base);
16293
16294 return (0);
16295 }
16296
16297 if (data.words_cur > data.words_base)
16298 {
16299 log_error ("ERROR: restore value greater keyspace");
16300
16301 return (-1);
16302 }
16303
16304 if (data.words_cur)
16305 {
16306 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16307 {
16308 for (uint i = 0; i < data.salts_cnt; i++)
16309 {
16310 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16311 }
16312 }
16313 else if (data.attack_kern == ATTACK_KERN_COMBI)
16314 {
16315 for (uint i = 0; i < data.salts_cnt; i++)
16316 {
16317 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16318 }
16319 }
16320 else if (data.attack_kern == ATTACK_KERN_BF)
16321 {
16322 for (uint i = 0; i < data.salts_cnt; i++)
16323 {
16324 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16325 }
16326 }
16327 }
16328
16329 /*
16330 * Inform user about possible slow speeds
16331 */
16332
16333 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16334 {
16335 if (data.words_base < kernel_power_all)
16336 {
16337 if (quiet == 0)
16338 {
16339 log_info ("");
16340 log_info ("ATTENTION!");
16341 log_info (" The wordlist or mask you are using is too small.");
16342 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16343 log_info (" The cracking speed will drop.");
16344 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16345 log_info ("");
16346 }
16347 }
16348 }
16349
16350 /*
16351 * Update loopback file
16352 */
16353
16354 if (loopback == 1)
16355 {
16356 time_t now;
16357
16358 time (&now);
16359
16360 uint random_num = get_random_num (0, 9999);
16361
16362 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16363
16364 data.loopback_file = loopback_file;
16365 }
16366
16367 /*
16368 * Update dictionary statistic
16369 */
16370
16371 if (keyspace == 0)
16372 {
16373 dictstat_fp = fopen (dictstat, "wb");
16374
16375 if (dictstat_fp)
16376 {
16377 lock_file (dictstat_fp);
16378
16379 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16380
16381 fclose (dictstat_fp);
16382 }
16383 }
16384
16385 data.devices_status = STATUS_RUNNING;
16386
16387 if (initial_restore_done == 0)
16388 {
16389 if (data.restore_disable == 0) cycle_restore ();
16390
16391 initial_restore_done = 1;
16392 }
16393
16394 hc_timer_set (&data.timer_running);
16395
16396 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16397 {
16398 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16399 {
16400 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16401 if (quiet == 0) fflush (stdout);
16402 }
16403 }
16404 else if (wordlist_mode == WL_MODE_STDIN)
16405 {
16406 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16407 if (data.quiet == 0) log_info ("");
16408 }
16409
16410 time_t runtime_start;
16411
16412 time (&runtime_start);
16413
16414 data.runtime_start = runtime_start;
16415
16416 /**
16417 * create cracker threads
16418 */
16419
16420 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16421
16422 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16423 {
16424 hc_device_param_t *device_param = &devices_param[device_id];
16425
16426 if (wordlist_mode == WL_MODE_STDIN)
16427 {
16428 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16429 }
16430 else
16431 {
16432 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16433 }
16434 }
16435
16436 // wait for crack threads to exit
16437
16438 hc_thread_wait (data.devices_cnt, c_threads);
16439
16440 local_free (c_threads);
16441
16442 data.restore = 0;
16443
16444 // finalize task
16445
16446 logfile_sub_var_uint ("status-after-work", data.devices_status);
16447
16448 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16449
16450 if (data.devices_status == STATUS_CRACKED) break;
16451 if (data.devices_status == STATUS_ABORTED) break;
16452
16453 if (data.devices_status == STATUS_BYPASS)
16454 {
16455 data.devices_status = STATUS_RUNNING;
16456 }
16457
16458 if (induction_dictionaries_cnt)
16459 {
16460 unlink (induction_dictionaries[0]);
16461 }
16462
16463 free (induction_dictionaries);
16464
16465 if (attack_mode != ATTACK_MODE_BF)
16466 {
16467 induction_dictionaries = scan_directory (induction_directory);
16468
16469 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16470 }
16471
16472 if (benchmark == 0)
16473 {
16474 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16475 {
16476 if (quiet == 0) clear_prompt ();
16477
16478 if (quiet == 0) log_info ("");
16479
16480 if (status == 1)
16481 {
16482 status_display ();
16483 }
16484 else
16485 {
16486 if (quiet == 0) status_display ();
16487 }
16488
16489 if (quiet == 0) log_info ("");
16490 }
16491 }
16492
16493 if (attack_mode == ATTACK_MODE_BF)
16494 {
16495 dictpos++;
16496
16497 rd->dictpos = dictpos;
16498 }
16499 else
16500 {
16501 if (induction_dictionaries_cnt)
16502 {
16503 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16504 }
16505 else
16506 {
16507 dictpos++;
16508
16509 rd->dictpos = dictpos;
16510 }
16511 }
16512
16513 time_t runtime_stop;
16514
16515 time (&runtime_stop);
16516
16517 data.runtime_stop = runtime_stop;
16518
16519 logfile_sub_uint (runtime_start);
16520 logfile_sub_uint (runtime_stop);
16521
16522 logfile_sub_msg ("STOP");
16523
16524 global_free (subid);
16525 }
16526
16527 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16528
16529 if (data.devices_status == STATUS_CRACKED) break;
16530 if (data.devices_status == STATUS_ABORTED) break;
16531 if (data.devices_status == STATUS_QUIT) break;
16532
16533 if (data.devices_status == STATUS_BYPASS)
16534 {
16535 data.devices_status = STATUS_RUNNING;
16536 }
16537 }
16538
16539 // 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
16540
16541 if (attack_mode == ATTACK_MODE_STRAIGHT)
16542 {
16543 if (data.wordlist_mode == WL_MODE_FILE)
16544 {
16545 if (data.dictfile == NULL)
16546 {
16547 if (dictfiles != NULL)
16548 {
16549 data.dictfile = dictfiles[0];
16550
16551 hc_timer_set (&data.timer_running);
16552 }
16553 }
16554 }
16555 }
16556 // NOTE: combi is okay because it is already set beforehand
16557 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16558 {
16559 if (data.dictfile == NULL)
16560 {
16561 if (dictfiles != NULL)
16562 {
16563 hc_timer_set (&data.timer_running);
16564
16565 data.dictfile = dictfiles[0];
16566 }
16567 }
16568 }
16569 else if (attack_mode == ATTACK_MODE_BF)
16570 {
16571 if (data.mask == NULL)
16572 {
16573 hc_timer_set (&data.timer_running);
16574
16575 data.mask = masks[0];
16576 }
16577 }
16578
16579 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16580 {
16581 data.devices_status = STATUS_EXHAUSTED;
16582 }
16583
16584 // if cracked / aborted remove last induction dictionary
16585
16586 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16587 {
16588 struct stat induct_stat;
16589
16590 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16591 {
16592 unlink (induction_dictionaries[file_pos]);
16593 }
16594 }
16595
16596 // wait for non-interactive threads
16597
16598 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16599 {
16600 hc_thread_wait (1, &ni_threads[thread_idx]);
16601 }
16602
16603 local_free (ni_threads);
16604
16605 // wait for interactive threads
16606
16607 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16608 {
16609 hc_thread_wait (1, &i_thread);
16610 }
16611
16612 // we dont need restore file anymore
16613 if (data.restore_disable == 0)
16614 {
16615 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16616 {
16617 unlink (eff_restore_file);
16618 unlink (new_restore_file);
16619 }
16620 else
16621 {
16622 cycle_restore ();
16623 }
16624 }
16625
16626 // finally save left hashes
16627
16628 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16629 {
16630 save_hash ();
16631 }
16632
16633 /**
16634 * Clean up
16635 */
16636
16637 if (benchmark == 1)
16638 {
16639 status_benchmark ();
16640
16641 log_info ("");
16642 }
16643 else
16644 {
16645 if (quiet == 0) clear_prompt ();
16646
16647 if (quiet == 0) log_info ("");
16648
16649 if (status == 1)
16650 {
16651 status_display ();
16652 }
16653 else
16654 {
16655 if (quiet == 0) status_display ();
16656 }
16657
16658 if (quiet == 0) log_info ("");
16659 }
16660
16661 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16662 {
16663 hc_device_param_t *device_param = &data.devices_param[device_id];
16664
16665 if (device_param->skipped) continue;
16666
16667 local_free (device_param->result);
16668
16669 local_free (device_param->combs_buf);
16670
16671 local_free (device_param->hooks_buf);
16672
16673 local_free (device_param->device_name);
16674
16675 local_free (device_param->device_name_chksum);
16676
16677 local_free (device_param->device_version);
16678
16679 local_free (device_param->driver_version);
16680
16681 if (device_param->pws_buf) myfree (device_param->pws_buf);
16682 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16683 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16684 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16685 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16686 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16687 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16688 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16689 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16690 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16691 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16692 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16693 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16694 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16695 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16696 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16697 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16698 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16699 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16700 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16701 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16702 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16703 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16704 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16705 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16706 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16707 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16708 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16709 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16710
16711 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16712 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16713 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16714 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16715 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16716 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16717 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16718 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16719 if (device_param->kernel_tb) hc_clReleaseKernel (data.ocl, device_param->kernel_tb);
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