projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Initial MESA support, needs more fixes
[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 100
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 HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 135
152
153 #define global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
168 {
169 900,
170 0,
171 5100,
172 100,
173 1400,
174 10800,
175 1700,
176 5000,
177 10100,
178 6000,
179 6100,
180 6900,
181 11700,
182 11800,
183 400,
184 8900,
185 11900,
186 12000,
187 10900,
188 12100,
189 23,
190 2500,
191 5300,
192 5400,
193 5500,
194 5600,
195 7300,
196 7500,
197 13100,
198 8300,
199 11100,
200 11200,
201 11400,
202 121,
203 2611,
204 2711,
205 2811,
206 8400,
207 11,
208 2612,
209 7900,
210 21,
211 11000,
212 124,
213 10000,
214 3711,
215 7600,
216 12,
217 131,
218 132,
219 1731,
220 200,
221 300,
222 3100,
223 112,
224 12300,
225 8000,
226 141,
227 1441,
228 1600,
229 12600,
230 1421,
231 101,
232 111,
233 1711,
234 3000,
235 1000,
236 1100,
237 2100,
238 12800,
239 1500,
240 12400,
241 500,
242 3200,
243 7400,
244 1800,
245 122,
246 1722,
247 7100,
248 6300,
249 6700,
250 6400,
251 6500,
252 2400,
253 2410,
254 5700,
255 9200,
256 9300,
257 22,
258 501,
259 5800,
260 8100,
261 8500,
262 7200,
263 9900,
264 7700,
265 7800,
266 10300,
267 8600,
268 8700,
269 9100,
270 133,
271 11600,
272 12500,
273 13000,
274 13200,
275 13300,
276 6211,
277 6221,
278 6231,
279 6241,
280 8800,
281 12900,
282 12200,
283 9700,
284 9710,
285 9800,
286 9810,
287 9400,
288 9500,
289 9600,
290 10400,
291 10410,
292 10500,
293 10600,
294 10700,
295 9000,
296 5200,
297 6800,
298 6600,
299 8200,
300 11300,
301 12700,
302 13400,
303 125
304 };
305
306 /**
307 * types
308 */
309
310 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
311
312 /**
313 * globals
314 */
315
316 static unsigned int full01 = 0x01010101;
317 static unsigned int full80 = 0x80808080;
318
319 int SUPPRESS_OUTPUT = 0;
320
321 hc_thread_mutex_t mux_adl;
322 hc_thread_mutex_t mux_counter;
323 hc_thread_mutex_t mux_dispatcher;
324 hc_thread_mutex_t mux_display;
325
326 hc_global_data_t data;
327
328 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
329
330 const char *USAGE_MINI[] =
331 {
332 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
333 "",
334 "Try --help for more help.",
335 NULL
336 };
337
338 const char *USAGE_BIG[] =
339 {
340 "%s, advanced password recovery",
341 "",
342 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
343 "",
344 "=======",
345 "Options",
346 "=======",
347 "",
348 "* General:",
349 "",
350 " -m, --hash-type=NUM Hash-type, see references below",
351 " -a, --attack-mode=NUM Attack-mode, see references below",
352 " -V, --version Print version",
353 " -h, --help Print help",
354 " --quiet Suppress output",
355 "",
356 "* Misc:",
357 "",
358 " --hex-charset Assume charset is given in hex",
359 " --hex-salt Assume salt is given in hex",
360 " --hex-wordlist Assume words in wordlist is given in hex",
361 " --force Ignore warnings",
362 " --status Enable automatic update of the status-screen",
363 " --status-timer=NUM Seconds between status-screen update",
364 " --status-automat Display the status view in a machine readable format",
365 " --loopback Add new plains to induct directory",
366 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
367 "",
368 "* Markov:",
369 "",
370 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
371 " --markov-disable Disables markov-chains, emulates classic brute-force",
372 " --markov-classic Enables classic markov-chains, no per-position enhancement",
373 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
374 "",
375 "* Session:",
376 "",
377 " --runtime=NUM Abort session after NUM seconds of runtime",
378 " --session=STR Define specific session name",
379 " --restore Restore session from --session",
380 " --restore-disable Do not write restore file",
381 "",
382 "* Files:",
383 "",
384 " -o, --outfile=FILE Define outfile for recovered hash",
385 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
386 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
387 " --outfile-check-timer=NUM Seconds between outfile checks",
388 " -p, --separator=CHAR Separator char for hashlists and outfile",
389 " --show Show cracked passwords only",
390 " --left Show un-cracked passwords only",
391 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
392 " --remove Enable remove of hash once it is cracked",
393 " --remove-timer=NUM Update input hash file each NUM seconds",
394 " --potfile-disable Do not write potfile",
395 " --potfile-path Specific path to potfile",
396 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
397 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
398 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
399 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
400 " --logfile-disable Disable the logfile",
401 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
402 "",
403 "* Resources:",
404 "",
405 " -b, --benchmark Run benchmark",
406 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
407 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
408 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
409 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
410 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
411 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
412 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
413 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
414 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
415 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
416 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
417 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
418 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
419 #ifdef HAVE_HWMON
420 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
421 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
422 #ifdef HAVE_ADL
423 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
424 #endif
425 #endif
426 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
427 "",
428 "* Distributed:",
429 "",
430 " -s, --skip=NUM Skip number of words",
431 " -l, --limit=NUM Limit number of words",
432 " --keyspace Show keyspace base:mod values and quit",
433 "",
434 "* Rules:",
435 "",
436 " -j, --rule-left=RULE Single rule applied to each word from left dict",
437 " -k, --rule-right=RULE Single rule applied to each word from right dict",
438 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
439 " -g, --generate-rules=NUM Generate NUM random rules",
440 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
441 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
442 " --generate-rules-seed=NUM Force RNG seed to NUM",
443 "",
444 "* Custom charsets:",
445 "",
446 " -1, --custom-charset1=CS User-defined charsets",
447 " -2, --custom-charset2=CS Example:",
448 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
449 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
450 "",
451 "* Increment:",
452 "",
453 " -i, --increment Enable increment mode",
454 " --increment-min=NUM Start incrementing at NUM",
455 " --increment-max=NUM Stop incrementing at NUM",
456 "",
457 "==========",
458 "References",
459 "==========",
460 "",
461 "* Workload Profile:",
462 "",
463 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
464 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
465 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
466 "",
467 "* OpenCL device-types:",
468 "",
469 " 1 = CPU devices",
470 " 2 = GPU devices",
471 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
472 "",
473 "* Outfile Formats:",
474 "",
475 " 1 = hash[:salt]",
476 " 2 = plain",
477 " 3 = hash[:salt]:plain",
478 " 4 = hex_plain",
479 " 5 = hash[:salt]:hex_plain",
480 " 6 = plain:hex_plain",
481 " 7 = hash[:salt]:plain:hex_plain",
482 " 8 = crackpos",
483 " 9 = hash[:salt]:crackpos",
484 " 10 = plain:crackpos",
485 " 11 = hash[:salt]:plain:crackpos",
486 " 12 = hex_plain:crackpos",
487 " 13 = hash[:salt]:hex_plain:crackpos",
488 " 14 = plain:hex_plain:crackpos",
489 " 15 = hash[:salt]:plain:hex_plain:crackpos",
490 "",
491 "* Debug mode output formats (for hybrid mode only, by using rules):",
492 "",
493 " 1 = save finding rule",
494 " 2 = save original word",
495 " 3 = save original word and finding rule",
496 " 4 = save original word, finding rule and modified plain",
497 "",
498 "* Built-in charsets:",
499 "",
500 " ?l = abcdefghijklmnopqrstuvwxyz",
501 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
502 " ?d = 0123456789",
503 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
504 " ?a = ?l?u?d?s",
505 " ?b = 0x00 - 0xff",
506 "",
507 "* Attack modes:",
508 "",
509 " 0 = Straight",
510 " 1 = Combination",
511 " 3 = Brute-force",
512 " 6 = Hybrid dict + mask",
513 " 7 = Hybrid mask + dict",
514 "",
515 "* Hash types:",
516 "",
517 "[[ Roll-your-own: Raw Hashes ]]",
518 "",
519 " 900 = MD4",
520 " 0 = MD5",
521 " 5100 = Half MD5",
522 " 100 = SHA1",
523 " 10800 = SHA-384",
524 " 1400 = SHA-256",
525 " 1700 = SHA-512",
526 " 5000 = SHA-3(Keccak)",
527 " 10100 = SipHash",
528 " 6000 = RipeMD160",
529 " 6100 = Whirlpool",
530 " 6900 = GOST R 34.11-94",
531 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
532 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
533 "",
534 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
535 "",
536 " 10 = md5($pass.$salt)",
537 " 20 = md5($salt.$pass)",
538 " 30 = md5(unicode($pass).$salt)",
539 " 40 = md5($salt.unicode($pass))",
540 " 3800 = md5($salt.$pass.$salt)",
541 " 3710 = md5($salt.md5($pass))",
542 " 2600 = md5(md5($pass)",
543 " 4300 = md5(strtoupper(md5($pass)))",
544 " 4400 = md5(sha1($pass))",
545 " 110 = sha1($pass.$salt)",
546 " 120 = sha1($salt.$pass)",
547 " 130 = sha1(unicode($pass).$salt)",
548 " 140 = sha1($salt.unicode($pass))",
549 " 4500 = sha1(sha1($pass)",
550 " 4700 = sha1(md5($pass))",
551 " 4900 = sha1($salt.$pass.$salt)",
552 " 1410 = sha256($pass.$salt)",
553 " 1420 = sha256($salt.$pass)",
554 " 1430 = sha256(unicode($pass).$salt)",
555 " 1440 = sha256($salt.unicode($pass))",
556 " 1710 = sha512($pass.$salt)",
557 " 1720 = sha512($salt.$pass)",
558 " 1730 = sha512(unicode($pass).$salt)",
559 " 1740 = sha512($salt.unicode($pass))",
560 "",
561 "[[ Roll-your-own: Authenticated Hashes ]]",
562 "",
563 " 50 = HMAC-MD5 (key = $pass)",
564 " 60 = HMAC-MD5 (key = $salt)",
565 " 150 = HMAC-SHA1 (key = $pass)",
566 " 160 = HMAC-SHA1 (key = $salt)",
567 " 1450 = HMAC-SHA256 (key = $pass)",
568 " 1460 = HMAC-SHA256 (key = $salt)",
569 " 1750 = HMAC-SHA512 (key = $pass)",
570 " 1760 = HMAC-SHA512 (key = $salt)",
571 "",
572 "[[ Generic KDF ]]",
573 "",
574 " 400 = phpass",
575 " 8900 = scrypt",
576 " 11900 = PBKDF2-HMAC-MD5",
577 " 12000 = PBKDF2-HMAC-SHA1",
578 " 10900 = PBKDF2-HMAC-SHA256",
579 " 12100 = PBKDF2-HMAC-SHA512",
580 "",
581 "[[ Network protocols, Challenge-Response ]]",
582 "",
583 " 23 = Skype",
584 " 2500 = WPA/WPA2",
585 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
586 " 5300 = IKE-PSK MD5",
587 " 5400 = IKE-PSK SHA1",
588 " 5500 = NetNTLMv1",
589 " 5500 = NetNTLMv1 + ESS",
590 " 5600 = NetNTLMv2",
591 " 7300 = IPMI2 RAKP HMAC-SHA1",
592 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
593 " 8300 = DNSSEC (NSEC3)",
594 " 10200 = Cram MD5",
595 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
596 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
597 " 11400 = SIP digest authentication (MD5)",
598 " 13100 = Kerberos 5 TGS-REP etype 23",
599 "",
600 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
601 "",
602 " 121 = SMF (Simple Machines Forum)",
603 " 400 = phpBB3",
604 " 2611 = vBulletin < v3.8.5",
605 " 2711 = vBulletin > v3.8.5",
606 " 2811 = MyBB",
607 " 2811 = IPB (Invison Power Board)",
608 " 8400 = WBB3 (Woltlab Burning Board)",
609 " 11 = Joomla < 2.5.18",
610 " 400 = Joomla > 2.5.18",
611 " 400 = Wordpress",
612 " 2612 = PHPS",
613 " 7900 = Drupal7",
614 " 21 = osCommerce",
615 " 21 = xt:Commerce",
616 " 11000 = PrestaShop",
617 " 124 = Django (SHA-1)",
618 " 10000 = Django (PBKDF2-SHA256)",
619 " 3711 = Mediawiki B type",
620 " 7600 = Redmine",
621 "",
622 "[[ Database Server ]]",
623 "",
624 " 12 = PostgreSQL",
625 " 131 = MSSQL(2000)",
626 " 132 = MSSQL(2005)",
627 " 1731 = MSSQL(2012)",
628 " 1731 = MSSQL(2014)",
629 " 200 = MySQL323",
630 " 300 = MySQL4.1/MySQL5",
631 " 3100 = Oracle H: Type (Oracle 7+)",
632 " 112 = Oracle S: Type (Oracle 11+)",
633 " 12300 = Oracle T: Type (Oracle 12+)",
634 " 8000 = Sybase ASE",
635 "",
636 "[[ HTTP, SMTP, LDAP Server ]]",
637 "",
638 " 141 = EPiServer 6.x < v4",
639 " 1441 = EPiServer 6.x > v4",
640 " 1600 = Apache $apr1$",
641 " 12600 = ColdFusion 10+",
642 " 1421 = hMailServer",
643 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
644 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
645 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
646 "",
647 "[[ Checksums ]]",
648 "",
649 " 11500 = CRC32",
650 "",
651 "[[ Operating-Systems ]]",
652 "",
653 " 3000 = LM",
654 " 1000 = NTLM",
655 " 1100 = Domain Cached Credentials (DCC), MS Cache",
656 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
657 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
658 " 1500 = descrypt, DES(Unix), Traditional DES",
659 " 12400 = BSDiCrypt, Extended DES",
660 " 500 = md5crypt $1$, MD5(Unix)",
661 " 3200 = bcrypt $2*$, Blowfish(Unix)",
662 " 7400 = sha256crypt $5$, SHA256(Unix)",
663 " 1800 = sha512crypt $6$, SHA512(Unix)",
664 " 122 = OSX v10.4",
665 " 122 = OSX v10.5",
666 " 122 = OSX v10.6",
667 " 1722 = OSX v10.7",
668 " 7100 = OSX v10.8",
669 " 7100 = OSX v10.9",
670 " 7100 = OSX v10.10",
671 " 6300 = AIX {smd5}",
672 " 6700 = AIX {ssha1}",
673 " 6400 = AIX {ssha256}",
674 " 6500 = AIX {ssha512}",
675 " 2400 = Cisco-PIX",
676 " 2410 = Cisco-ASA",
677 " 500 = Cisco-IOS $1$",
678 " 5700 = Cisco-IOS $4$",
679 " 9200 = Cisco-IOS $8$",
680 " 9300 = Cisco-IOS $9$",
681 " 22 = Juniper Netscreen/SSG (ScreenOS)",
682 " 501 = Juniper IVE",
683 " 5800 = Android PIN",
684 " 8100 = Citrix Netscaler",
685 " 8500 = RACF",
686 " 7200 = GRUB 2",
687 " 9900 = Radmin2",
688 " 125 = ArubaOS",
689 "",
690 "[[ Enterprise Application Software (EAS) ]]",
691 "",
692 " 7700 = SAP CODVN B (BCODE)",
693 " 7800 = SAP CODVN F/G (PASSCODE)",
694 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
695 " 8600 = Lotus Notes/Domino 5",
696 " 8700 = Lotus Notes/Domino 6",
697 " 9100 = Lotus Notes/Domino 8",
698 " 133 = PeopleSoft",
699 "",
700 "[[ Archives ]]",
701 "",
702 " 11600 = 7-Zip",
703 " 12500 = RAR3-hp",
704 " 13000 = RAR5",
705 " 13200 = AxCrypt",
706 " 13300 = AxCrypt in memory SHA1",
707 "",
708 "[[ Full-Disk encryptions (FDE) ]]",
709 "",
710 " 62XY = TrueCrypt 5.0+",
711 " X = 1 = PBKDF2-HMAC-RipeMD160",
712 " X = 2 = PBKDF2-HMAC-SHA512",
713 " X = 3 = PBKDF2-HMAC-Whirlpool",
714 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
715 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
716 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
717 " Y = 3 = XTS 1536 bit (Ciphers: All)",
718 " 8800 = Android FDE < v4.3",
719 " 12900 = Android FDE (Samsung DEK)",
720 " 12200 = eCryptfs",
721 "",
722 "[[ Documents ]]",
723 "",
724 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
725 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
726 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
727 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
728 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
729 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
730 " 9400 = MS Office 2007",
731 " 9500 = MS Office 2010",
732 " 9600 = MS Office 2013",
733 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
734 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
735 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
736 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
737 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
738 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
739 "",
740 "[[ Password Managers ]]",
741 "",
742 " 9000 = Password Safe v2",
743 " 5200 = Password Safe v3",
744 " 6800 = Lastpass",
745 " 6600 = 1Password, agilekeychain",
746 " 8200 = 1Password, cloudkeychain",
747 " 11300 = Bitcoin/Litecoin wallet.dat",
748 " 12700 = Blockchain, My Wallet",
749 " 13400 = Keepass 1 (AES/Twofish) and Keepass 2 (AES)",
750 "",
751 NULL
752 };
753
754 /**
755 * oclHashcat specific functions
756 */
757
758 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
759 {
760 int exec_pos = (int) device_param->exec_pos - last_num_entries;
761
762 if (exec_pos < 0) exec_pos += EXEC_CACHE;
763
764 double exec_ms_sum = 0;
765
766 int exec_ms_cnt = 0;
767
768 for (int i = 0; i < last_num_entries; i++)
769 {
770 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
771
772 if (exec_ms)
773 {
774 exec_ms_sum += exec_ms;
775
776 exec_ms_cnt++;
777 }
778 }
779
780 if (exec_ms_cnt == 0) return 0;
781
782 return exec_ms_sum / exec_ms_cnt;
783 }
784
785 void status_display_automat ()
786 {
787 FILE *out = stdout;
788
789 fprintf (out, "STATUS\t%u\t", data.devices_status);
790
791 /**
792 * speed new
793 */
794
795 fprintf (out, "SPEED\t");
796
797 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
798 {
799 hc_device_param_t *device_param = &data.devices_param[device_id];
800
801 if (device_param->skipped) continue;
802
803 u64 speed_cnt = 0;
804 double speed_ms = 0;
805
806 for (int i = 0; i < SPEED_CACHE; i++)
807 {
808 speed_cnt += device_param->speed_cnt[i];
809 speed_ms += device_param->speed_ms[i];
810 }
811
812 speed_cnt /= SPEED_CACHE;
813 speed_ms /= SPEED_CACHE;
814
815 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
816 }
817
818 /**
819 * exec time
820 */
821
822 fprintf (out, "EXEC_RUNTIME\t");
823
824 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
825 {
826 hc_device_param_t *device_param = &data.devices_param[device_id];
827
828 if (device_param->skipped) continue;
829
830 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
831
832 fprintf (out, "%f\t", exec_ms_avg);
833 }
834
835 /**
836 * words_cur
837 */
838
839 u64 words_cur = get_lowest_words_done ();
840
841 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
842
843 /**
844 * counter
845 */
846
847 u64 progress_total = data.words_cnt * data.salts_cnt;
848
849 u64 all_done = 0;
850 u64 all_rejected = 0;
851 u64 all_restored = 0;
852
853 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
854 {
855 all_done += data.words_progress_done[salt_pos];
856 all_rejected += data.words_progress_rejected[salt_pos];
857 all_restored += data.words_progress_restored[salt_pos];
858 }
859
860 u64 progress_cur = all_restored + all_done + all_rejected;
861 u64 progress_end = progress_total;
862
863 u64 progress_skip = 0;
864
865 if (data.skip)
866 {
867 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
868
869 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
870 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
871 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
872 }
873
874 if (data.limit)
875 {
876 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
877
878 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
879 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
880 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
881 }
882
883 u64 progress_cur_relative_skip = progress_cur - progress_skip;
884 u64 progress_end_relative_skip = progress_end - progress_skip;
885
886 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
887
888 /**
889 * cracks
890 */
891
892 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
893 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
894
895 /**
896 * temperature
897 */
898
899 #ifdef HAVE_HWMON
900 if (data.gpu_temp_disable == 0)
901 {
902 fprintf (out, "TEMP\t");
903
904 hc_thread_mutex_lock (mux_adl);
905
906 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
907 {
908 hc_device_param_t *device_param = &data.devices_param[device_id];
909
910 if (device_param->skipped) continue;
911
912 int temp = hm_get_temperature_with_device_id (device_id);
913
914 fprintf (out, "%d\t", temp);
915 }
916
917 hc_thread_mutex_unlock (mux_adl);
918 }
919 #endif // HAVE_HWMON
920
921 /**
922 * flush
923 */
924
925 #ifdef _WIN
926 fputc ('\r', out);
927 fputc ('\n', out);
928 #endif
929
930 #ifdef _POSIX
931 fputc ('\n', out);
932 #endif
933
934 fflush (out);
935 }
936
937 void status_display ()
938 {
939 if (data.devices_status == STATUS_INIT) return;
940 if (data.devices_status == STATUS_STARTING) return;
941 if (data.devices_status == STATUS_BYPASS) return;
942
943 if (data.status_automat == 1)
944 {
945 status_display_automat ();
946
947 return;
948 }
949
950 char tmp_buf[1000] = { 0 };
951
952 uint tmp_len = 0;
953
954 log_info ("Session.Name...: %s", data.session);
955
956 char *status_type = strstatus (data.devices_status);
957
958 uint hash_mode = data.hash_mode;
959
960 char *hash_type = strhashtype (hash_mode); // not a bug
961
962 log_info ("Status.........: %s", status_type);
963
964 /**
965 * show rules
966 */
967
968 if (data.rp_files_cnt)
969 {
970 uint i;
971
972 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
973 {
974 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
975 }
976
977 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
978
979 log_info ("Rules.Type.....: %s", tmp_buf);
980
981 tmp_len = 0;
982 }
983
984 if (data.rp_gen)
985 {
986 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
987
988 if (data.rp_gen_seed)
989 {
990 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
991 }
992 }
993
994 /**
995 * show input
996 */
997
998 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
999 {
1000 if (data.wordlist_mode == WL_MODE_FILE)
1001 {
1002 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1003 }
1004 else if (data.wordlist_mode == WL_MODE_STDIN)
1005 {
1006 log_info ("Input.Mode.....: Pipe");
1007 }
1008 }
1009 else if (data.attack_mode == ATTACK_MODE_COMBI)
1010 {
1011 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1012 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1013 }
1014 else if (data.attack_mode == ATTACK_MODE_BF)
1015 {
1016 char *mask = data.mask;
1017
1018 if (mask != NULL)
1019 {
1020 uint mask_len = data.css_cnt;
1021
1022 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1023
1024 if (mask_len > 0)
1025 {
1026 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1027 {
1028 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1029 {
1030 mask_len -= data.salts_buf[0].salt_len;
1031 }
1032 }
1033
1034 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1035
1036 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1037 }
1038
1039 if (data.maskcnt > 1)
1040 {
1041 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1042
1043 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1044 }
1045
1046 log_info ("Input.Mode.....: %s", tmp_buf);
1047 }
1048
1049 tmp_len = 0;
1050 }
1051 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1052 {
1053 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1054 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1055 }
1056 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1057 {
1058 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1059 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1060 }
1061
1062 if (data.digests_cnt == 1)
1063 {
1064 if (data.hash_mode == 2500)
1065 {
1066 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1067
1068 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1069 (char *) data.salts_buf[0].salt_buf,
1070 wpa->orig_mac1[0],
1071 wpa->orig_mac1[1],
1072 wpa->orig_mac1[2],
1073 wpa->orig_mac1[3],
1074 wpa->orig_mac1[4],
1075 wpa->orig_mac1[5],
1076 wpa->orig_mac2[0],
1077 wpa->orig_mac2[1],
1078 wpa->orig_mac2[2],
1079 wpa->orig_mac2[3],
1080 wpa->orig_mac2[4],
1081 wpa->orig_mac2[5]);
1082 }
1083 else if (data.hash_mode == 5200)
1084 {
1085 log_info ("Hash.Target....: File (%s)", data.hashfile);
1086 }
1087 else if (data.hash_mode == 9000)
1088 {
1089 log_info ("Hash.Target....: File (%s)", data.hashfile);
1090 }
1091 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1092 {
1093 log_info ("Hash.Target....: File (%s)", data.hashfile);
1094 }
1095 else
1096 {
1097 char out_buf[HCBUFSIZ] = { 0 };
1098
1099 ascii_digest (out_buf, 0, 0);
1100
1101 // limit length
1102 if (strlen (out_buf) > 40)
1103 {
1104 out_buf[41] = '.';
1105 out_buf[42] = '.';
1106 out_buf[43] = '.';
1107 out_buf[44] = 0;
1108 }
1109
1110 log_info ("Hash.Target....: %s", out_buf);
1111 }
1112 }
1113 else
1114 {
1115 if (data.hash_mode == 3000)
1116 {
1117 char out_buf1[32] = { 0 };
1118 char out_buf2[32] = { 0 };
1119
1120 ascii_digest (out_buf1, 0, 0);
1121 ascii_digest (out_buf2, 0, 1);
1122
1123 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1124 }
1125 else
1126 {
1127 log_info ("Hash.Target....: File (%s)", data.hashfile);
1128 }
1129 }
1130
1131 log_info ("Hash.Type......: %s", hash_type);
1132
1133 /**
1134 * speed new
1135 */
1136
1137 u64 speed_cnt[DEVICES_MAX] = { 0 };
1138 double speed_ms[DEVICES_MAX] = { 0 };
1139
1140 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1141 {
1142 hc_device_param_t *device_param = &data.devices_param[device_id];
1143
1144 if (device_param->skipped) continue;
1145
1146 speed_cnt[device_id] = 0;
1147 speed_ms[device_id] = 0;
1148
1149 for (int i = 0; i < SPEED_CACHE; i++)
1150 {
1151 speed_cnt[device_id] += device_param->speed_cnt[i];
1152 speed_ms[device_id] += device_param->speed_ms[i];
1153 }
1154
1155 speed_cnt[device_id] /= SPEED_CACHE;
1156 speed_ms[device_id] /= SPEED_CACHE;
1157 }
1158
1159 float hashes_all_ms = 0;
1160
1161 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1162
1163 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1164 {
1165 hc_device_param_t *device_param = &data.devices_param[device_id];
1166
1167 if (device_param->skipped) continue;
1168
1169 hashes_dev_ms[device_id] = 0;
1170
1171 if (speed_ms[device_id])
1172 {
1173 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1174
1175 hashes_all_ms += hashes_dev_ms[device_id];
1176 }
1177 }
1178
1179 /**
1180 * exec time
1181 */
1182
1183 double exec_all_ms[DEVICES_MAX] = { 0 };
1184
1185 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1186 {
1187 hc_device_param_t *device_param = &data.devices_param[device_id];
1188
1189 if (device_param->skipped) continue;
1190
1191 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1192
1193 exec_all_ms[device_id] = exec_ms_avg;
1194 }
1195
1196 /**
1197 * timers
1198 */
1199
1200 double ms_running = 0;
1201
1202 hc_timer_get (data.timer_running, ms_running);
1203
1204 double ms_paused = data.ms_paused;
1205
1206 if (data.devices_status == STATUS_PAUSED)
1207 {
1208 double ms_paused_tmp = 0;
1209
1210 hc_timer_get (data.timer_paused, ms_paused_tmp);
1211
1212 ms_paused += ms_paused_tmp;
1213 }
1214
1215 #ifdef WIN
1216
1217 __time64_t sec_run = ms_running / 1000;
1218
1219 #else
1220
1221 time_t sec_run = ms_running / 1000;
1222
1223 #endif
1224
1225 if (sec_run)
1226 {
1227 char display_run[32] = { 0 };
1228
1229 struct tm tm_run;
1230
1231 struct tm *tmp = NULL;
1232
1233 #ifdef WIN
1234
1235 tmp = _gmtime64 (&sec_run);
1236
1237 #else
1238
1239 tmp = gmtime (&sec_run);
1240
1241 #endif
1242
1243 if (tmp != NULL)
1244 {
1245 memset (&tm_run, 0, sizeof (tm_run));
1246
1247 memcpy (&tm_run, tmp, sizeof (tm_run));
1248
1249 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1250
1251 char *start = ctime (&data.proc_start);
1252
1253 size_t start_len = strlen (start);
1254
1255 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1256 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1257
1258 log_info ("Time.Started...: %s (%s)", start, display_run);
1259 }
1260 }
1261 else
1262 {
1263 log_info ("Time.Started...: 0 secs");
1264 }
1265
1266 /**
1267 * counters
1268 */
1269
1270 u64 progress_total = data.words_cnt * data.salts_cnt;
1271
1272 u64 all_done = 0;
1273 u64 all_rejected = 0;
1274 u64 all_restored = 0;
1275
1276 u64 progress_noneed = 0;
1277
1278 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1279 {
1280 all_done += data.words_progress_done[salt_pos];
1281 all_rejected += data.words_progress_rejected[salt_pos];
1282 all_restored += data.words_progress_restored[salt_pos];
1283
1284 // Important for ETA only
1285
1286 if (data.salts_shown[salt_pos] == 1)
1287 {
1288 const u64 all = data.words_progress_done[salt_pos]
1289 + data.words_progress_rejected[salt_pos]
1290 + data.words_progress_restored[salt_pos];
1291
1292 const u64 left = data.words_cnt - all;
1293
1294 progress_noneed += left;
1295 }
1296 }
1297
1298 u64 progress_cur = all_restored + all_done + all_rejected;
1299 u64 progress_end = progress_total;
1300
1301 u64 progress_skip = 0;
1302
1303 if (data.skip)
1304 {
1305 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1306
1307 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1308 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1309 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1310 }
1311
1312 if (data.limit)
1313 {
1314 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1315
1316 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1317 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1318 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1319 }
1320
1321 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1322 u64 progress_end_relative_skip = progress_end - progress_skip;
1323
1324 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1325 {
1326 if (data.devices_status != STATUS_CRACKED)
1327 {
1328 #ifdef WIN
1329 __time64_t sec_etc = 0;
1330 #else
1331 time_t sec_etc = 0;
1332 #endif
1333
1334 if (hashes_all_ms)
1335 {
1336 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1337
1338 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1339
1340 sec_etc = ms_left / 1000;
1341 }
1342
1343 if (sec_etc == 0)
1344 {
1345 //log_info ("Time.Estimated.: 0 secs");
1346 }
1347 else if ((u64) sec_etc > ETC_MAX)
1348 {
1349 log_info ("Time.Estimated.: > 10 Years");
1350 }
1351 else
1352 {
1353 char display_etc[32] = { 0 };
1354
1355 struct tm tm_etc;
1356
1357 struct tm *tmp = NULL;
1358
1359 #ifdef WIN
1360
1361 tmp = _gmtime64 (&sec_etc);
1362
1363 #else
1364
1365 tmp = gmtime (&sec_etc);
1366
1367 #endif
1368
1369 if (tmp != NULL)
1370 {
1371 memset (&tm_etc, 0, sizeof (tm_etc));
1372
1373 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1374
1375 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1376
1377 time_t now;
1378
1379 time (&now);
1380
1381 now += sec_etc;
1382
1383 char *etc = ctime (&now);
1384
1385 size_t etc_len = strlen (etc);
1386
1387 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1388 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1389
1390 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1391 }
1392 }
1393 }
1394 }
1395
1396 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1397 {
1398 hc_device_param_t *device_param = &data.devices_param[device_id];
1399
1400 if (device_param->skipped) continue;
1401
1402 char display_dev_cur[16] = { 0 };
1403
1404 strncpy (display_dev_cur, "0.00", 4);
1405
1406 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1407
1408 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1409 }
1410
1411 char display_all_cur[16] = { 0 };
1412
1413 strncpy (display_all_cur, "0.00", 4);
1414
1415 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1416
1417 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1418
1419 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1420 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1421
1422 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);
1423
1424 // crack-per-time
1425
1426 if (data.digests_cnt > 100)
1427 {
1428 time_t now = time (NULL);
1429
1430 int cpt_cur_min = 0;
1431 int cpt_cur_hour = 0;
1432 int cpt_cur_day = 0;
1433
1434 for (int i = 0; i < CPT_BUF; i++)
1435 {
1436 const uint cracked = data.cpt_buf[i].cracked;
1437 const time_t timestamp = data.cpt_buf[i].timestamp;
1438
1439 if ((timestamp + 60) > now)
1440 {
1441 cpt_cur_min += cracked;
1442 }
1443
1444 if ((timestamp + 3600) > now)
1445 {
1446 cpt_cur_hour += cracked;
1447 }
1448
1449 if ((timestamp + 86400) > now)
1450 {
1451 cpt_cur_day += cracked;
1452 }
1453 }
1454
1455 double ms_real = ms_running - ms_paused;
1456
1457 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1458 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1459 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1460
1461 if ((data.cpt_start + 86400) < now)
1462 {
1463 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1464 cpt_cur_min,
1465 cpt_cur_hour,
1466 cpt_cur_day,
1467 cpt_avg_min,
1468 cpt_avg_hour,
1469 cpt_avg_day);
1470 }
1471 else if ((data.cpt_start + 3600) < now)
1472 {
1473 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1474 cpt_cur_min,
1475 cpt_cur_hour,
1476 cpt_avg_min,
1477 cpt_avg_hour,
1478 cpt_avg_day);
1479 }
1480 else if ((data.cpt_start + 60) < now)
1481 {
1482 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1483 cpt_cur_min,
1484 cpt_avg_min,
1485 cpt_avg_hour,
1486 cpt_avg_day);
1487 }
1488 else
1489 {
1490 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1491 cpt_avg_min,
1492 cpt_avg_hour,
1493 cpt_avg_day);
1494 }
1495 }
1496
1497 // Restore point
1498
1499 u64 restore_point = get_lowest_words_done ();
1500
1501 u64 restore_total = data.words_base;
1502
1503 float percent_restore = 0;
1504
1505 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1506
1507 if (progress_end_relative_skip)
1508 {
1509 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1510 {
1511 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1512 float percent_rejected = 0.0;
1513
1514 if (progress_cur)
1515 {
1516 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1517 }
1518
1519 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);
1520 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1521
1522 if (data.restore_disable == 0)
1523 {
1524 if (percent_finished != 1)
1525 {
1526 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1527 }
1528 }
1529 }
1530 }
1531 else
1532 {
1533 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1534 {
1535 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1536 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1537
1538 if (data.restore_disable == 0)
1539 {
1540 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1541 }
1542 }
1543 else
1544 {
1545 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1546 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1547
1548 // --restore not allowed if stdin is used -- really? why?
1549
1550 //if (data.restore_disable == 0)
1551 //{
1552 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1553 //}
1554 }
1555 }
1556
1557 #ifdef HAVE_HWMON
1558 if (data.gpu_temp_disable == 0)
1559 {
1560 hc_thread_mutex_lock (mux_adl);
1561
1562 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1563 {
1564 hc_device_param_t *device_param = &data.devices_param[device_id];
1565
1566 if (device_param->skipped) continue;
1567
1568 #define HM_STR_BUF_SIZE 255
1569
1570 if (data.hm_device[device_id].fan_supported == 1)
1571 {
1572 char utilization[HM_STR_BUF_SIZE] = { 0 };
1573 char temperature[HM_STR_BUF_SIZE] = { 0 };
1574 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1575
1576 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1577 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1578
1579 if (device_param->vendor_id == VENDOR_ID_AMD)
1580 {
1581 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1582 }
1583 else if (device_param->vendor_id == VENDOR_ID_NV)
1584 {
1585 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1586 }
1587
1588 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1589 }
1590 else
1591 {
1592 char utilization[HM_STR_BUF_SIZE] = { 0 };
1593 char temperature[HM_STR_BUF_SIZE] = { 0 };
1594
1595 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1596 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1597
1598 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1599 }
1600 }
1601
1602 hc_thread_mutex_unlock (mux_adl);
1603 }
1604 #endif // HAVE_HWMON
1605 }
1606
1607 static void status_benchmark ()
1608 {
1609 if (data.devices_status == STATUS_INIT) return;
1610 if (data.devices_status == STATUS_STARTING) return;
1611
1612 if (data.words_cnt == 0) return;
1613
1614 u64 speed_cnt[DEVICES_MAX] = { 0 };
1615 double speed_ms[DEVICES_MAX] = { 0 };
1616
1617 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1618 {
1619 hc_device_param_t *device_param = &data.devices_param[device_id];
1620
1621 if (device_param->skipped) continue;
1622
1623 speed_cnt[device_id] = device_param->speed_cnt[0];
1624 speed_ms[device_id] = device_param->speed_ms[0];
1625 }
1626
1627 float hashes_all_ms = 0;
1628
1629 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1630
1631 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1632 {
1633 hc_device_param_t *device_param = &data.devices_param[device_id];
1634
1635 if (device_param->skipped) continue;
1636
1637 hashes_dev_ms[device_id] = 0;
1638
1639 if (speed_ms[device_id])
1640 {
1641 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1642
1643 hashes_all_ms += hashes_dev_ms[device_id];
1644 }
1645 }
1646
1647 /**
1648 * exec time
1649 */
1650
1651 double exec_all_ms[DEVICES_MAX] = { 0 };
1652
1653 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1654 {
1655 hc_device_param_t *device_param = &data.devices_param[device_id];
1656
1657 if (device_param->skipped) continue;
1658
1659 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1660
1661 exec_all_ms[device_id] = exec_ms_avg;
1662 }
1663
1664 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1665 {
1666 hc_device_param_t *device_param = &data.devices_param[device_id];
1667
1668 if (device_param->skipped) continue;
1669
1670 char display_dev_cur[16] = { 0 };
1671
1672 strncpy (display_dev_cur, "0.00", 4);
1673
1674 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1675
1676 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1677 }
1678
1679 char display_all_cur[16] = { 0 };
1680
1681 strncpy (display_all_cur, "0.00", 4);
1682
1683 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1684
1685 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1686 }
1687
1688 /**
1689 * oclHashcat -only- functions
1690 */
1691
1692 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1693 {
1694 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1695 {
1696 if (attack_kern == ATTACK_KERN_STRAIGHT)
1697 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1698 else if (attack_kern == ATTACK_KERN_COMBI)
1699 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1700 else if (attack_kern == ATTACK_KERN_BF)
1701 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1702 }
1703 else
1704 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1705 }
1706
1707 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)
1708 {
1709 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1710 {
1711 if (attack_kern == ATTACK_KERN_STRAIGHT)
1712 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1713 else if (attack_kern == ATTACK_KERN_COMBI)
1714 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1715 else if (attack_kern == ATTACK_KERN_BF)
1716 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1717 }
1718 else
1719 {
1720 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1721 }
1722 }
1723
1724 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1725 {
1726 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1727 {
1728 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1729 }
1730 else
1731 {
1732 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1733 }
1734 }
1735
1736 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)
1737 {
1738 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1739 {
1740 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1741 }
1742 else
1743 {
1744 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1745 }
1746 }
1747
1748 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1749 {
1750 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1751 }
1752
1753 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1754 {
1755 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1756 }
1757
1758 static uint convert_from_hex (char *line_buf, const uint line_len)
1759 {
1760 if (line_len & 1) return (line_len); // not in hex
1761
1762 if (data.hex_wordlist == 1)
1763 {
1764 uint i;
1765 uint j;
1766
1767 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1768 {
1769 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1770 }
1771
1772 memset (line_buf + i, 0, line_len - i);
1773
1774 return (i);
1775 }
1776 else if (line_len >= 6) // $HEX[] = 6
1777 {
1778 if (line_buf[0] != '$') return (line_len);
1779 if (line_buf[1] != 'H') return (line_len);
1780 if (line_buf[2] != 'E') return (line_len);
1781 if (line_buf[3] != 'X') return (line_len);
1782 if (line_buf[4] != '[') return (line_len);
1783 if (line_buf[line_len - 1] != ']') return (line_len);
1784
1785 uint i;
1786 uint j;
1787
1788 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1789 {
1790 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1791 }
1792
1793 memset (line_buf + i, 0, line_len - i);
1794
1795 return (i);
1796 }
1797
1798 return (line_len);
1799 }
1800
1801 static void clear_prompt ()
1802 {
1803 fputc ('\r', stdout);
1804
1805 for (size_t i = 0; i < strlen (PROMPT); i++)
1806 {
1807 fputc (' ', stdout);
1808 }
1809
1810 fputc ('\r', stdout);
1811
1812 fflush (stdout);
1813 }
1814
1815 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1816 {
1817 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);
1818 }
1819
1820 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1821 {
1822 char *outfile = data.outfile;
1823 uint quiet = data.quiet;
1824 FILE *pot_fp = data.pot_fp;
1825 uint loopback = data.loopback;
1826 uint debug_mode = data.debug_mode;
1827 char *debug_file = data.debug_file;
1828
1829 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1830 int debug_rule_len = 0; // -1 error
1831 uint debug_plain_len = 0;
1832
1833 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1834
1835 // hash
1836
1837 char out_buf[HCBUFSIZ] = { 0 };
1838
1839 ascii_digest (out_buf, salt_pos, digest_pos);
1840
1841 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1842
1843 // plain
1844
1845 plain_t plain;
1846
1847 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);
1848
1849 uint gidvid = plain.gidvid;
1850 uint il_pos = plain.il_pos;
1851
1852 u64 crackpos = device_param->words_off;
1853
1854 uint plain_buf[16] = { 0 };
1855
1856 u8 *plain_ptr = (u8 *) plain_buf;
1857 unsigned int plain_len = 0;
1858
1859 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1860 {
1861 u64 gidd = gidvid;
1862 u64 gidm = 0;
1863
1864 pw_t pw;
1865
1866 gidd_to_pw_t (device_param, gidd, &pw);
1867
1868 for (int i = 0, j = gidm; i < 16; i++, j++)
1869 {
1870 plain_buf[i] = pw.i[j];
1871 }
1872
1873 plain_len = pw.pw_len;
1874
1875 const uint off = device_param->innerloop_pos + il_pos;
1876
1877 if (debug_mode > 0)
1878 {
1879 debug_rule_len = 0;
1880
1881 // save rule
1882 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1883 {
1884 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1885
1886 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1887 }
1888
1889 // save plain
1890 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1891 {
1892 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1893
1894 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1895
1896 debug_plain_len = plain_len;
1897 }
1898 }
1899
1900 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1901
1902 crackpos += gidvid;
1903 crackpos *= data.kernel_rules_cnt;
1904 crackpos += device_param->innerloop_pos + il_pos;
1905
1906 if (plain_len > data.pw_max) plain_len = data.pw_max;
1907 }
1908 else if (data.attack_mode == ATTACK_MODE_COMBI)
1909 {
1910 u64 gidd = gidvid;
1911 u64 gidm = 0;
1912
1913 pw_t pw;
1914
1915 gidd_to_pw_t (device_param, gidd, &pw);
1916
1917 for (int i = 0, j = gidm; i < 16; i++, j++)
1918 {
1919 plain_buf[i] = pw.i[j];
1920 }
1921
1922 plain_len = pw.pw_len;
1923
1924 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1925 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1926
1927 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1928 {
1929 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1930 }
1931 else
1932 {
1933 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1934
1935 memcpy (plain_ptr, comb_buf, comb_len);
1936 }
1937
1938 plain_len += comb_len;
1939
1940 crackpos += gidvid;
1941 crackpos *= data.combs_cnt;
1942 crackpos += device_param->innerloop_pos + il_pos;
1943
1944 if (data.pw_max != PW_DICTMAX1)
1945 {
1946 if (plain_len > data.pw_max) plain_len = data.pw_max;
1947 }
1948 }
1949 else if (data.attack_mode == ATTACK_MODE_BF)
1950 {
1951 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1952 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1953
1954 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1955 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1956
1957 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1958 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1959
1960 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1961 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1962
1963 plain_len = data.css_cnt;
1964
1965 crackpos += gidvid;
1966 crackpos *= data.bfs_cnt;
1967 crackpos += device_param->innerloop_pos + il_pos;
1968 }
1969 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1970 {
1971 u64 gidd = gidvid;
1972 u64 gidm = 0;
1973
1974 pw_t pw;
1975
1976 gidd_to_pw_t (device_param, gidd, &pw);
1977
1978 for (int i = 0, j = gidm; i < 16; i++, j++)
1979 {
1980 plain_buf[i] = pw.i[j];
1981 }
1982
1983 plain_len = pw.pw_len;
1984
1985 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
1986
1987 uint start = 0;
1988 uint stop = device_param->kernel_params_mp_buf32[4];
1989
1990 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1991
1992 plain_len += start + stop;
1993
1994 crackpos += gidvid;
1995 crackpos *= data.combs_cnt;
1996 crackpos += device_param->innerloop_pos + il_pos;
1997
1998 if (data.pw_max != PW_DICTMAX1)
1999 {
2000 if (plain_len > data.pw_max) plain_len = data.pw_max;
2001 }
2002 }
2003 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2004 {
2005 u64 gidd = gidvid;
2006 u64 gidm = 0;
2007
2008 pw_t pw;
2009
2010 gidd_to_pw_t (device_param, gidd, &pw);
2011
2012 for (int i = 0, j = gidm; i < 16; i++, j++)
2013 {
2014 plain_buf[i] = pw.i[j];
2015 }
2016
2017 plain_len = pw.pw_len;
2018
2019 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2020
2021 uint start = 0;
2022 uint stop = device_param->kernel_params_mp_buf32[4];
2023
2024 memmove (plain_ptr + stop, plain_ptr, plain_len);
2025
2026 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2027
2028 plain_len += start + stop;
2029
2030 crackpos += gidvid;
2031 crackpos *= data.combs_cnt;
2032 crackpos += device_param->innerloop_pos + il_pos;
2033
2034 if (data.pw_max != PW_DICTMAX1)
2035 {
2036 if (plain_len > data.pw_max) plain_len = data.pw_max;
2037 }
2038 }
2039
2040 if (data.attack_mode == ATTACK_MODE_BF)
2041 {
2042 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2043 {
2044 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2045 {
2046 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2047 {
2048 plain_len = plain_len - data.salts_buf[0].salt_len;
2049 }
2050 }
2051
2052 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2053 {
2054 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2055 {
2056 plain_ptr[j] = plain_ptr[i];
2057 }
2058
2059 plain_len = plain_len / 2;
2060 }
2061 }
2062 }
2063
2064 // if enabled, update also the potfile
2065
2066 if (pot_fp)
2067 {
2068 lock_file (pot_fp);
2069
2070 fprintf (pot_fp, "%s:", out_buf);
2071
2072 format_plain (pot_fp, plain_ptr, plain_len, 1);
2073
2074 fputc ('\n', pot_fp);
2075
2076 fflush (pot_fp);
2077
2078 unlock_file (pot_fp);
2079 }
2080
2081 // outfile
2082
2083 FILE *out_fp = NULL;
2084
2085 if (outfile != NULL)
2086 {
2087 if ((out_fp = fopen (outfile, "ab")) == NULL)
2088 {
2089 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2090
2091 out_fp = stdout;
2092 }
2093 lock_file (out_fp);
2094 }
2095 else
2096 {
2097 out_fp = stdout;
2098
2099 if (quiet == 0) clear_prompt ();
2100 }
2101
2102 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2103
2104 if (outfile != NULL)
2105 {
2106 if (out_fp != stdout)
2107 {
2108 fclose (out_fp);
2109 }
2110 }
2111 else
2112 {
2113 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2114 {
2115 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2116 {
2117 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2118 if (quiet == 0) fflush (stdout);
2119 }
2120 }
2121 }
2122
2123 // loopback
2124
2125 if (loopback)
2126 {
2127 char *loopback_file = data.loopback_file;
2128
2129 FILE *fb_fp = NULL;
2130
2131 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2132 {
2133 lock_file (fb_fp);
2134
2135 format_plain (fb_fp, plain_ptr, plain_len, 1);
2136
2137 fputc ('\n', fb_fp);
2138
2139 fclose (fb_fp);
2140 }
2141 }
2142
2143 // (rule) debug mode
2144
2145 // the next check implies that:
2146 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2147 // - debug_mode > 0
2148
2149 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2150 {
2151 if (debug_rule_len < 0) debug_rule_len = 0;
2152
2153 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2154
2155 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2156
2157 if ((quiet == 0) && (debug_file == NULL))
2158 {
2159 fprintf (stdout, "%s", PROMPT);
2160 fflush (stdout);
2161 }
2162 }
2163 }
2164
2165 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2166 {
2167 salt_t *salt_buf = &data.salts_buf[salt_pos];
2168
2169 int found = 0;
2170
2171 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);
2172
2173 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2174
2175 if (found == 1)
2176 {
2177 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2178
2179 log_info_nn ("");
2180
2181 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);
2182
2183 uint cpt_cracked = 0;
2184
2185 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2186 {
2187 uint idx = salt_buf->digests_offset + digest_pos;
2188
2189 if (data.digests_shown_tmp[idx] == 0) continue;
2190
2191 if (data.digests_shown[idx] == 1) continue;
2192
2193 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2194 {
2195 data.digests_shown[idx] = 1;
2196
2197 data.digests_done++;
2198
2199 cpt_cracked++;
2200
2201 salt_buf->digests_done++;
2202
2203 if (salt_buf->digests_done == salt_buf->digests_cnt)
2204 {
2205 data.salts_shown[salt_pos] = 1;
2206
2207 data.salts_done++;
2208 }
2209 }
2210
2211 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2212
2213 check_hash (device_param, salt_pos, digest_pos);
2214 }
2215
2216 if (cpt_cracked > 0)
2217 {
2218 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2219 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2220
2221 data.cpt_pos++;
2222
2223 data.cpt_total += cpt_cracked;
2224
2225 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2226 }
2227
2228 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2229 {
2230 // we need to reset cracked state on the device
2231 // otherwise host thinks again and again the hash was cracked
2232 // and returns invalid password each time
2233
2234 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2235
2236 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);
2237 }
2238
2239 memset (device_param->result, 0, device_param->size_results);
2240
2241 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);
2242 }
2243 }
2244
2245 static void save_hash ()
2246 {
2247 char *hashfile = data.hashfile;
2248
2249 char new_hashfile[256] = { 0 };
2250 char old_hashfile[256] = { 0 };
2251
2252 snprintf (new_hashfile, 255, "%s.new", hashfile);
2253 snprintf (old_hashfile, 255, "%s.old", hashfile);
2254
2255 unlink (new_hashfile);
2256
2257 char separator = data.separator;
2258
2259 FILE *fp = fopen (new_hashfile, "wb");
2260
2261 if (fp == NULL)
2262 {
2263 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2264
2265 exit (-1);
2266 }
2267
2268 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2269 {
2270 if (data.salts_shown[salt_pos] == 1) continue;
2271
2272 salt_t *salt_buf = &data.salts_buf[salt_pos];
2273
2274 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2275 {
2276 uint idx = salt_buf->digests_offset + digest_pos;
2277
2278 if (data.digests_shown[idx] == 1) continue;
2279
2280 if (data.hash_mode != 2500)
2281 {
2282 char out_buf[HCBUFSIZ] = { 0 };
2283
2284 if (data.username == 1)
2285 {
2286 user_t *user = data.hash_info[idx]->user;
2287
2288 uint i;
2289
2290 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2291
2292 fputc (separator, fp);
2293 }
2294
2295 ascii_digest (out_buf, salt_pos, digest_pos);
2296
2297 fputs (out_buf, fp);
2298
2299 log_out (fp, "");
2300 }
2301 else
2302 {
2303 hccap_t hccap;
2304
2305 to_hccap_t (&hccap, salt_pos, digest_pos);
2306
2307 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2308 }
2309 }
2310 }
2311
2312 fflush (fp);
2313
2314 fclose (fp);
2315
2316 unlink (old_hashfile);
2317
2318 if (rename (hashfile, old_hashfile) != 0)
2319 {
2320 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2321
2322 exit (-1);
2323 }
2324
2325 unlink (hashfile);
2326
2327 if (rename (new_hashfile, hashfile) != 0)
2328 {
2329 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2330
2331 exit (-1);
2332 }
2333
2334 unlink (old_hashfile);
2335 }
2336
2337 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2338 {
2339 // function called only in case kernel_power_all > words_left
2340
2341 float kernel_power_div = (float) (total_left) / kernel_power_all;
2342
2343 kernel_power_div += kernel_power_div / 100;
2344
2345 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2346
2347 while (kernel_power_new < total_left)
2348 {
2349 kernel_power_div += kernel_power_div / 100;
2350
2351 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2352 }
2353
2354 if (data.quiet == 0)
2355 {
2356 clear_prompt ();
2357
2358 log_info ("");
2359
2360 log_info ("INFO: approaching final keyspace, workload adjusted");
2361
2362 log_info ("");
2363
2364 fprintf (stdout, "%s", PROMPT);
2365
2366 fflush (stdout);
2367 }
2368
2369 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2370
2371 return kernel_power_div;
2372 }
2373
2374 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2375 {
2376 uint num_elements = num;
2377
2378 device_param->kernel_params_buf32[30] = data.combs_mode;
2379 device_param->kernel_params_buf32[31] = num;
2380
2381 uint kernel_threads = device_param->kernel_threads;
2382
2383 while (num_elements % kernel_threads) num_elements++;
2384
2385 cl_kernel kernel = NULL;
2386
2387 switch (kern_run)
2388 {
2389 case KERN_RUN_1: kernel = device_param->kernel1; break;
2390 case KERN_RUN_12: kernel = device_param->kernel12; break;
2391 case KERN_RUN_2: kernel = device_param->kernel2; break;
2392 case KERN_RUN_23: kernel = device_param->kernel23; break;
2393 case KERN_RUN_3: kernel = device_param->kernel3; break;
2394 }
2395
2396 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2397 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2398 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2399 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2400 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2401 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2402 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2403 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2404 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2405 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2406 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2407
2408 hc_timer_t timer;
2409
2410 hc_timer_set (&timer);
2411
2412 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2413 {
2414 const size_t global_work_size[3] = { num_elements, 32, 1 };
2415 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2416
2417 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2418 }
2419 else
2420 {
2421 size_t workgroup_size = 0;
2422
2423 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2424
2425 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2426
2427 const size_t global_work_size[3] = { num_elements, 1, 1 };
2428 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2429
2430 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2431 }
2432
2433 hc_clFlush (data.ocl, device_param->command_queue);
2434
2435 hc_clFinish (data.ocl, device_param->command_queue);
2436
2437 if (event_update)
2438 {
2439 double exec_time;
2440
2441 hc_timer_get (timer, exec_time);
2442
2443 uint exec_pos = device_param->exec_pos;
2444
2445 device_param->exec_ms[exec_pos] = exec_time;
2446
2447 exec_pos++;
2448
2449 if (exec_pos == EXEC_CACHE)
2450 {
2451 exec_pos = 0;
2452 }
2453
2454 device_param->exec_pos = exec_pos;
2455 }
2456 }
2457
2458 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2459 {
2460 uint num_elements = num;
2461
2462 switch (kern_run)
2463 {
2464 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2465 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2466 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2467 }
2468
2469 // causes problems with special threads like in bcrypt
2470 // const uint kernel_threads = device_param->kernel_threads;
2471
2472 uint kernel_threads = KERNEL_THREADS;
2473
2474 while (num_elements % kernel_threads) num_elements++;
2475
2476 cl_kernel kernel = NULL;
2477
2478 switch (kern_run)
2479 {
2480 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2481 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2482 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2483 }
2484
2485 switch (kern_run)
2486 {
2487 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2488 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2489 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2490 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2491 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2492 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2493 break;
2494 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2495 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2496 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2497 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2498 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2499 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2500 break;
2501 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2502 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2503 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2504 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2505 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2506 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2507 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2508 break;
2509 }
2510
2511 size_t workgroup_size = 0;
2512 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
2513 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2514
2515 const size_t global_work_size[3] = { num_elements, 1, 1 };
2516 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2517
2518 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2519
2520 hc_clFlush (data.ocl, device_param->command_queue);
2521
2522 hc_clFinish (data.ocl, device_param->command_queue);
2523 }
2524
2525 static void run_kernel_tm (hc_device_param_t *device_param)
2526 {
2527 const uint num_elements = 1024; // fixed
2528
2529 uint kernel_threads = 32;
2530
2531 cl_kernel kernel = device_param->kernel_tm;
2532
2533 size_t workgroup_size = 0;
2534 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2535 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2536
2537 const size_t global_work_size[3] = { num_elements, 1, 1 };
2538 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2539
2540 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2541
2542 hc_clFlush (data.ocl, device_param->command_queue);
2543
2544 hc_clFinish (data.ocl, device_param->command_queue);
2545 }
2546
2547 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2548 {
2549 uint num_elements = num;
2550
2551 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2552 device_param->kernel_params_amp_buf32[6] = num_elements;
2553
2554 // causes problems with special threads like in bcrypt
2555 // const uint kernel_threads = device_param->kernel_threads;
2556
2557 uint kernel_threads = KERNEL_THREADS;
2558
2559 while (num_elements % kernel_threads) num_elements++;
2560
2561 cl_kernel kernel = device_param->kernel_amp;
2562
2563 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2564 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2565
2566 size_t workgroup_size = 0;
2567 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2568 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2569
2570 const size_t global_work_size[3] = { num_elements, 1, 1 };
2571 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2572
2573 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2574
2575 hc_clFlush (data.ocl, device_param->command_queue);
2576
2577 hc_clFinish (data.ocl, device_param->command_queue);
2578 }
2579
2580 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2581 {
2582 int rc = -1;
2583
2584 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2585 {
2586 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2587
2588 const cl_uchar zero = 0;
2589
2590 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2591 }
2592
2593 if (rc != 0)
2594 {
2595 // NOTE: clEnqueueFillBuffer () always fails with -59
2596 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2597 // How's that possible, OpenCL 1.2 support is advertised??
2598 // We need to workaround...
2599
2600 #define FILLSZ 0x100000
2601
2602 char *tmp = (char *) mymalloc (FILLSZ);
2603
2604 for (uint i = 0; i < size; i += FILLSZ)
2605 {
2606 const int left = size - i;
2607
2608 const int fillsz = MIN (FILLSZ, left);
2609
2610 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2611 }
2612
2613 myfree (tmp);
2614 }
2615 }
2616
2617 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)
2618 {
2619 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2620 {
2621 if (attack_mode == ATTACK_MODE_BF)
2622 {
2623 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2624 {
2625 const uint size_tm = 32 * sizeof (bs_word_t);
2626
2627 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2628
2629 run_kernel_tm (device_param);
2630
2631 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);
2632 }
2633 }
2634
2635 if (highest_pw_len < 16)
2636 {
2637 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2638 }
2639 else if (highest_pw_len < 32)
2640 {
2641 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2642 }
2643 else
2644 {
2645 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2646 }
2647 }
2648 else
2649 {
2650 run_kernel_amp (device_param, pws_cnt);
2651
2652 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2653
2654 if (opts_type & OPTS_TYPE_HOOK12)
2655 {
2656 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2657 }
2658
2659 uint iter = salt_buf->salt_iter;
2660
2661 uint loop_step = device_param->kernel_loops;
2662
2663 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2664 {
2665 uint loop_left = iter - loop_pos;
2666
2667 loop_left = MIN (loop_left, loop_step);
2668
2669 device_param->kernel_params_buf32[25] = loop_pos;
2670 device_param->kernel_params_buf32[26] = loop_left;
2671
2672 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2673
2674 if (data.devices_status == STATUS_CRACKED) break;
2675 if (data.devices_status == STATUS_ABORTED) break;
2676 if (data.devices_status == STATUS_QUIT) break;
2677
2678 /**
2679 * speed
2680 */
2681
2682 const float iter_part = (float) (loop_pos + loop_left) / iter;
2683
2684 const u64 perf_sum_all = pws_cnt * iter_part;
2685
2686 double speed_ms;
2687
2688 hc_timer_get (device_param->timer_speed, speed_ms);
2689
2690 const u32 speed_pos = device_param->speed_pos;
2691
2692 device_param->speed_cnt[speed_pos] = perf_sum_all;
2693
2694 device_param->speed_ms[speed_pos] = speed_ms;
2695 }
2696
2697 if (opts_type & OPTS_TYPE_HOOK23)
2698 {
2699 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2700
2701 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);
2702
2703 // do something with data
2704
2705 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);
2706 }
2707
2708 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2709 }
2710 }
2711
2712 static int run_rule_engine (const int rule_len, const char *rule_buf)
2713 {
2714 if (rule_len == 0)
2715 {
2716 return 0;
2717 }
2718 else if (rule_len == 1)
2719 {
2720 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2721 }
2722
2723 return 1;
2724 }
2725
2726 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2727 {
2728 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2729 {
2730 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);
2731 }
2732 else if (data.attack_kern == ATTACK_KERN_COMBI)
2733 {
2734 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2735 {
2736 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2737 {
2738 for (u32 i = 0; i < pws_cnt; i++)
2739 {
2740 const u32 pw_len = device_param->pws_buf[i].pw_len;
2741
2742 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2743
2744 ptr[pw_len] = 0x01;
2745 }
2746 }
2747 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2748 {
2749 for (u32 i = 0; i < pws_cnt; i++)
2750 {
2751 const u32 pw_len = device_param->pws_buf[i].pw_len;
2752
2753 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2754
2755 ptr[pw_len] = 0x80;
2756 }
2757 }
2758 }
2759
2760 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);
2761 }
2762 else if (data.attack_kern == ATTACK_KERN_BF)
2763 {
2764 const u64 off = device_param->words_off;
2765
2766 device_param->kernel_params_mp_l_buf64[3] = off;
2767
2768 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2769 }
2770 }
2771
2772 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops, const int repeat)
2773 {
2774 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2775
2776 device_param->kernel_params_buf32[26] = kernel_loops;
2777 device_param->kernel_params_buf32[27] = kernel_loops;
2778
2779 // init some fake words
2780
2781 for (u32 i = 0; i < kernel_power; i++)
2782 {
2783 device_param->pws_buf[i].i[0] = i;
2784 device_param->pws_buf[i].i[1] = 0x01234567;
2785 device_param->pws_buf[i].pw_len = 4 + (i & 3);
2786 }
2787
2788 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);
2789
2790 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2791 {
2792 run_kernel_amp (device_param, kernel_power);
2793 }
2794
2795 // caching run
2796
2797 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2798 {
2799 run_kernel (KERN_RUN_1, device_param, kernel_power, false);
2800 }
2801 else
2802 {
2803 run_kernel (KERN_RUN_2, device_param, kernel_power, false);
2804 }
2805
2806 // now user repeats
2807
2808 for (int i = 0; i < repeat; i++)
2809 {
2810 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2811 {
2812 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2813 }
2814 else
2815 {
2816 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2817 }
2818 }
2819
2820 const double exec_ms_prev = get_avg_exec_time (device_param, repeat);
2821
2822 // reset fake words
2823
2824 memset (device_param->pws_buf, 0, kernel_power * sizeof (pw_t));
2825
2826 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);
2827 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);
2828
2829 return exec_ms_prev;
2830 }
2831
2832 static void autotune (hc_device_param_t *device_param)
2833 {
2834 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2835
2836 const u32 kernel_accel_min = device_param->kernel_accel_min;
2837 const u32 kernel_accel_max = device_param->kernel_accel_max;
2838
2839 const u32 kernel_loops_min = device_param->kernel_loops_min;
2840 const u32 kernel_loops_max = device_param->kernel_loops_max;
2841
2842 u32 kernel_accel = kernel_accel_min;
2843 u32 kernel_loops = kernel_loops_min;
2844
2845 // steps
2846
2847 #define STEPS_CNT 10
2848
2849 #define STEPS_ACCEL_CNT (STEPS_CNT + 2)
2850 #define STEPS_LOOPS_CNT (STEPS_CNT + 2)
2851
2852 u32 steps_accel[STEPS_ACCEL_CNT];
2853 u32 steps_loops[STEPS_LOOPS_CNT];
2854
2855 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2856 {
2857 steps_accel[i] = 1 << i;
2858 }
2859
2860 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2861 {
2862 steps_loops[i] = 1 << i;
2863 }
2864
2865 steps_accel[STEPS_CNT + 0] = kernel_accel_min;
2866 steps_accel[STEPS_CNT + 1] = kernel_accel_max;
2867
2868 steps_loops[STEPS_CNT + 0] = kernel_loops_min;
2869 steps_loops[STEPS_CNT + 1] = kernel_loops_max;
2870
2871 qsort (steps_accel, STEPS_ACCEL_CNT, sizeof (u32), sort_by_u32);
2872 qsort (steps_loops, STEPS_LOOPS_CNT, sizeof (u32), sort_by_u32);
2873
2874 // find out highest kernel-loops that stays below target_ms, we can use it later for multiplication as this is a linear function
2875
2876 u32 kernel_loops_tmp;
2877
2878 for (kernel_loops_tmp = kernel_loops_max; kernel_loops_tmp > kernel_loops_min; kernel_loops_tmp >>= 1)
2879 {
2880 const double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops_tmp, 1);
2881
2882 if (exec_ms < target_ms) break;
2883 }
2884
2885 // kernel-accel
2886
2887 if (kernel_accel_min < kernel_accel_max)
2888 {
2889 double e_best = 0;
2890
2891 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2892 {
2893 const u32 kernel_accel_try = steps_accel[i];
2894
2895 if (kernel_accel_try < kernel_accel_min) continue;
2896 if (kernel_accel_try > kernel_accel_max) break;
2897
2898 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_tmp, 1);
2899
2900 if (exec_ms > target_ms) break;
2901
2902 const double e = kernel_accel_try / exec_ms;
2903
2904 if (e > e_best)
2905 {
2906 kernel_accel = kernel_accel_try;
2907
2908 e_best = e;
2909 }
2910 }
2911 }
2912
2913 // kernel-loops final
2914
2915 if (kernel_loops_min < kernel_loops_max)
2916 {
2917 double e_best = 0;
2918
2919 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2920 {
2921 const u32 kernel_loops_try = steps_loops[i];
2922
2923 if (kernel_loops_try < kernel_loops_min) continue;
2924 if (kernel_loops_try > kernel_loops_max) break;
2925
2926 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops_try, 1);
2927
2928 if (exec_ms > target_ms) break;
2929
2930 const double e = kernel_loops_try / exec_ms;
2931
2932 if (e > e_best)
2933 {
2934 kernel_loops = kernel_loops_try;
2935
2936 e_best = e;
2937 }
2938 }
2939 }
2940
2941 // final balance
2942
2943 u32 kernel_accel_best = kernel_accel;
2944 u32 kernel_loops_best = kernel_loops;
2945
2946 u32 exec_best = -1;
2947
2948 if ((kernel_accel_min < kernel_accel_max) || (kernel_loops_min < kernel_loops_max))
2949 {
2950 const double exec_ms = try_run (device_param, kernel_accel_best, kernel_loops_best, 1);
2951
2952 exec_best = exec_ms;
2953 }
2954
2955 // reset
2956
2957 if (kernel_accel_min < kernel_accel_max)
2958 {
2959 u32 kernel_accel_try = kernel_accel;
2960 u32 kernel_loops_try = kernel_loops;
2961
2962 for (int i = 0; i < 2; i++)
2963 {
2964 kernel_accel_try >>= 1;
2965 kernel_loops_try <<= 1;
2966
2967 if (kernel_accel_try < kernel_accel_min) break;
2968 if (kernel_loops_try > kernel_loops_max) break;
2969
2970 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
2971
2972 if (exec_ms < exec_best)
2973 {
2974 kernel_accel_best = kernel_accel_try;
2975 kernel_loops_best = kernel_loops_try;
2976
2977 exec_best = exec_ms;
2978 }
2979 }
2980 }
2981
2982 // reset
2983
2984 if (kernel_loops_min < kernel_loops_max)
2985 {
2986 u32 kernel_accel_try = kernel_accel;
2987 u32 kernel_loops_try = kernel_loops;
2988
2989 for (int i = 0; i < 2; i++)
2990 {
2991 kernel_accel_try <<= 1;
2992 kernel_loops_try >>= 1;
2993
2994 if (kernel_accel_try > kernel_accel_max) break;
2995 if (kernel_loops_try < kernel_loops_min) break;
2996
2997 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
2998
2999 if (exec_ms < exec_best)
3000 {
3001 kernel_accel_best = kernel_accel_try;
3002 kernel_loops_best = kernel_loops_try;
3003
3004 exec_best = exec_ms;
3005 }
3006 }
3007 }
3008
3009 // reset timer
3010
3011 device_param->exec_pos = 0;
3012
3013 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3014
3015 // store
3016
3017 kernel_accel = kernel_accel_best;
3018 kernel_loops = kernel_loops_best;
3019
3020 device_param->kernel_accel = kernel_accel;
3021 device_param->kernel_loops = kernel_loops;
3022
3023 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3024
3025 device_param->kernel_power = kernel_power;
3026
3027 #ifdef DEBUG
3028
3029 if (data.quiet == 0)
3030 {
3031 clear_prompt ();
3032
3033 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3034 "Device #%u: autotuned kernel-loops to %u\n",
3035 device_param->device_id + 1,
3036 kernel_accel,
3037 device_param->device_id + 1,
3038 kernel_loops);
3039
3040 fprintf (stdout, "%s", PROMPT);
3041 fflush (stdout);
3042 }
3043
3044 #endif
3045 }
3046
3047 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3048 {
3049 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3050
3051 // init speed timer
3052
3053 uint speed_pos = device_param->speed_pos;
3054
3055 #ifdef _POSIX
3056 if (device_param->timer_speed.tv_sec == 0)
3057 {
3058 hc_timer_set (&device_param->timer_speed);
3059 }
3060 #endif
3061
3062 #ifdef _WIN
3063 if (device_param->timer_speed.QuadPart == 0)
3064 {
3065 hc_timer_set (&device_param->timer_speed);
3066 }
3067 #endif
3068
3069 // find higest password length, this is for optimization stuff
3070
3071 uint highest_pw_len = 0;
3072
3073 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3074 {
3075 }
3076 else if (data.attack_kern == ATTACK_KERN_COMBI)
3077 {
3078 }
3079 else if (data.attack_kern == ATTACK_KERN_BF)
3080 {
3081 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3082 + device_param->kernel_params_mp_l_buf32[5];
3083 }
3084
3085 // iteration type
3086
3087 uint innerloop_step = 0;
3088 uint innerloop_cnt = 0;
3089
3090 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3091 else innerloop_step = 1;
3092
3093 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3094 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3095 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3096
3097 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3098
3099 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3100 {
3101 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3102
3103 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3104
3105 if (data.devices_status == STATUS_CRACKED) break;
3106 if (data.devices_status == STATUS_ABORTED) break;
3107 if (data.devices_status == STATUS_QUIT) break;
3108 if (data.devices_status == STATUS_BYPASS) break;
3109
3110 salt_t *salt_buf = &data.salts_buf[salt_pos];
3111
3112 device_param->kernel_params_buf32[24] = salt_pos;
3113 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3114 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3115
3116 FILE *combs_fp = device_param->combs_fp;
3117
3118 if (data.attack_mode == ATTACK_MODE_COMBI)
3119 {
3120 rewind (combs_fp);
3121 }
3122
3123 // innerloops
3124
3125 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3126 {
3127 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3128
3129 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3130
3131 if (data.devices_status == STATUS_CRACKED) break;
3132 if (data.devices_status == STATUS_ABORTED) break;
3133 if (data.devices_status == STATUS_QUIT) break;
3134 if (data.devices_status == STATUS_BYPASS) break;
3135
3136 uint innerloop_left = innerloop_cnt - innerloop_pos;
3137
3138 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3139
3140 device_param->innerloop_pos = innerloop_pos;
3141 device_param->innerloop_left = innerloop_left;
3142
3143 device_param->kernel_params_buf32[27] = innerloop_left;
3144
3145 // i think we can get rid of this
3146 if (innerloop_left == 0)
3147 {
3148 puts ("bug, how should this happen????\n");
3149
3150 continue;
3151 }
3152
3153 if (data.salts_shown[salt_pos] == 1)
3154 {
3155 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3156
3157 continue;
3158 }
3159
3160 // initialize amplifiers
3161
3162 if (data.attack_mode == ATTACK_MODE_COMBI)
3163 {
3164 uint i = 0;
3165
3166 while (i < innerloop_left)
3167 {
3168 if (feof (combs_fp)) break;
3169
3170 int line_len = fgetl (combs_fp, line_buf);
3171
3172 if (line_len >= PW_MAX1) continue;
3173
3174 line_len = convert_from_hex (line_buf, line_len);
3175
3176 char *line_buf_new = line_buf;
3177
3178 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3179 {
3180 char rule_buf_out[BLOCK_SIZE] = { 0 };
3181
3182 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3183
3184 if (rule_len_out < 0)
3185 {
3186 data.words_progress_rejected[salt_pos] += pws_cnt;
3187
3188 continue;
3189 }
3190
3191 line_len = rule_len_out;
3192
3193 line_buf_new = rule_buf_out;
3194 }
3195
3196 line_len = MIN (line_len, PW_DICTMAX);
3197
3198 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3199
3200 memcpy (ptr, line_buf_new, line_len);
3201
3202 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3203
3204 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3205 {
3206 uppercase (ptr, line_len);
3207 }
3208
3209 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3210 {
3211 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3212 {
3213 ptr[line_len] = 0x80;
3214 }
3215
3216 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3217 {
3218 ptr[line_len] = 0x01;
3219 }
3220 }
3221
3222 device_param->combs_buf[i].pw_len = line_len;
3223
3224 i++;
3225 }
3226
3227 for (uint j = i; j < innerloop_left; j++)
3228 {
3229 device_param->combs_buf[j].i[0] = 0;
3230 device_param->combs_buf[j].i[1] = 0;
3231 device_param->combs_buf[j].i[2] = 0;
3232 device_param->combs_buf[j].i[3] = 0;
3233 device_param->combs_buf[j].i[4] = 0;
3234 device_param->combs_buf[j].i[5] = 0;
3235 device_param->combs_buf[j].i[6] = 0;
3236 device_param->combs_buf[j].i[7] = 0;
3237
3238 device_param->combs_buf[j].pw_len = 0;
3239 }
3240
3241 innerloop_left = i;
3242 }
3243 else if (data.attack_mode == ATTACK_MODE_BF)
3244 {
3245 u64 off = innerloop_pos;
3246
3247 device_param->kernel_params_mp_r_buf64[3] = off;
3248
3249 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3250 }
3251 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3252 {
3253 u64 off = innerloop_pos;
3254
3255 device_param->kernel_params_mp_buf64[3] = off;
3256
3257 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3258 }
3259 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3260 {
3261 u64 off = innerloop_pos;
3262
3263 device_param->kernel_params_mp_buf64[3] = off;
3264
3265 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3266 }
3267
3268 // copy amplifiers
3269
3270 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3271 {
3272 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);
3273 }
3274 else if (data.attack_mode == ATTACK_MODE_COMBI)
3275 {
3276 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);
3277 }
3278 else if (data.attack_mode == ATTACK_MODE_BF)
3279 {
3280 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);
3281 }
3282 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3283 {
3284 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);
3285 }
3286 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3287 {
3288 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);
3289 }
3290
3291 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3292
3293 if (data.benchmark == 1)
3294 {
3295 double exec_ms_avg_prev = get_avg_exec_time (device_param, EXEC_CACHE);
3296
3297 // a few caching rounds
3298
3299 for (u32 i = 0; i < 2; i++)
3300 {
3301 hc_timer_set (&device_param->timer_speed);
3302
3303 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3304
3305 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
3306
3307 exec_ms_avg_prev = exec_ms_avg;
3308 }
3309
3310 // benchmark_repeats became a maximum possible repeats
3311
3312 for (u32 i = 2; i < data.benchmark_repeats; i++)
3313 {
3314 hc_timer_set (&device_param->timer_speed);
3315
3316 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3317
3318 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
3319
3320 if ((exec_ms_avg_prev / exec_ms_avg) < 1.001) break;
3321
3322 exec_ms_avg_prev = exec_ms_avg;
3323 }
3324 }
3325
3326 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3327
3328 if (data.devices_status == STATUS_CRACKED) break;
3329 if (data.devices_status == STATUS_ABORTED) break;
3330 if (data.devices_status == STATUS_QUIT) break;
3331
3332 /**
3333 * result
3334 */
3335
3336 hc_thread_mutex_lock (mux_display);
3337
3338 check_cracked (device_param, salt_pos);
3339
3340 hc_thread_mutex_unlock (mux_display);
3341
3342 /**
3343 * progress
3344 */
3345
3346 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3347
3348 hc_thread_mutex_lock (mux_counter);
3349
3350 data.words_progress_done[salt_pos] += perf_sum_all;
3351
3352 hc_thread_mutex_unlock (mux_counter);
3353
3354 /**
3355 * speed
3356 */
3357
3358 double speed_ms;
3359
3360 hc_timer_get (device_param->timer_speed, speed_ms);
3361
3362 hc_timer_set (&device_param->timer_speed);
3363
3364 hc_thread_mutex_lock (mux_display);
3365
3366 // current speed
3367
3368 device_param->speed_cnt[speed_pos] = perf_sum_all;
3369
3370 device_param->speed_ms[speed_pos] = speed_ms;
3371
3372 hc_thread_mutex_unlock (mux_display);
3373
3374 speed_pos++;
3375
3376 if (speed_pos == SPEED_CACHE)
3377 {
3378 speed_pos = 0;
3379 }
3380
3381 /**
3382 * benchmark
3383 */
3384
3385 if (data.benchmark == 1) break;
3386 }
3387 }
3388
3389 device_param->speed_pos = speed_pos;
3390
3391 myfree (line_buf);
3392 }
3393
3394 static void load_segment (wl_data_t *wl_data, FILE *fd)
3395 {
3396 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3397
3398 wl_data->pos = 0;
3399
3400 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3401
3402 wl_data->buf[wl_data->cnt] = 0;
3403
3404 if (wl_data->cnt == 0) return;
3405
3406 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3407
3408 while (!feof (fd))
3409 {
3410 if (wl_data->cnt == wl_data->avail)
3411 {
3412 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3413
3414 wl_data->avail += wl_data->incr;
3415 }
3416
3417 const int c = fgetc (fd);
3418
3419 if (c == EOF) break;
3420
3421 wl_data->buf[wl_data->cnt] = (char) c;
3422
3423 wl_data->cnt++;
3424
3425 if (c == '\n') break;
3426 }
3427
3428 // ensure stream ends with a newline
3429
3430 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3431 {
3432 wl_data->cnt++;
3433
3434 wl_data->buf[wl_data->cnt - 1] = '\n';
3435 }
3436
3437 return;
3438 }
3439
3440 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3441 {
3442 char *ptr = buf;
3443
3444 for (u32 i = 0; i < sz; i++, ptr++)
3445 {
3446 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3447
3448 if (i == 7)
3449 {
3450 *off = i;
3451 *len = i;
3452
3453 return;
3454 }
3455
3456 if (*ptr != '\n') continue;
3457
3458 *off = i + 1;
3459
3460 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3461
3462 *len = i;
3463
3464 return;
3465 }
3466
3467 *off = sz;
3468 *len = sz;
3469 }
3470
3471 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3472 {
3473 char *ptr = buf;
3474
3475 for (u32 i = 0; i < sz; i++, ptr++)
3476 {
3477 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3478
3479 if (*ptr != '\n') continue;
3480
3481 *off = i + 1;
3482
3483 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3484
3485 *len = i;
3486
3487 return;
3488 }
3489
3490 *off = sz;
3491 *len = sz;
3492 }
3493
3494 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3495 {
3496 char *ptr = buf;
3497
3498 for (u32 i = 0; i < sz; i++, ptr++)
3499 {
3500 if (*ptr != '\n') continue;
3501
3502 *off = i + 1;
3503
3504 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3505
3506 *len = i;
3507
3508 return;
3509 }
3510
3511 *off = sz;
3512 *len = sz;
3513 }
3514
3515 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3516 {
3517 while (wl_data->pos < wl_data->cnt)
3518 {
3519 uint off;
3520 uint len;
3521
3522 char *ptr = wl_data->buf + wl_data->pos;
3523
3524 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3525
3526 wl_data->pos += off;
3527
3528 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3529 {
3530 char rule_buf_out[BLOCK_SIZE] = { 0 };
3531
3532 int rule_len_out = -1;
3533
3534 if (len < BLOCK_SIZE)
3535 {
3536 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3537 }
3538
3539 if (rule_len_out < 0)
3540 {
3541 continue;
3542 }
3543
3544 if (rule_len_out > PW_MAX)
3545 {
3546 continue;
3547 }
3548 }
3549 else
3550 {
3551 if (len > PW_MAX)
3552 {
3553 continue;
3554 }
3555 }
3556
3557 *out_buf = ptr;
3558 *out_len = len;
3559
3560 return;
3561 }
3562
3563 if (feof (fd))
3564 {
3565 fprintf (stderr, "BUG feof()!!\n");
3566
3567 return;
3568 }
3569
3570 load_segment (wl_data, fd);
3571
3572 get_next_word (wl_data, fd, out_buf, out_len);
3573 }
3574
3575 #ifdef _POSIX
3576 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3577 #endif
3578
3579 #ifdef _WIN
3580 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3581 #endif
3582 {
3583 hc_signal (NULL);
3584
3585 dictstat_t d;
3586
3587 d.cnt = 0;
3588
3589 #ifdef _POSIX
3590 fstat (fileno (fd), &d.stat);
3591 #endif
3592
3593 #ifdef _WIN
3594 _fstat64 (fileno (fd), &d.stat);
3595 #endif
3596
3597 d.stat.st_mode = 0;
3598 d.stat.st_nlink = 0;
3599 d.stat.st_uid = 0;
3600 d.stat.st_gid = 0;
3601 d.stat.st_rdev = 0;
3602 d.stat.st_atime = 0;
3603
3604 #ifdef _POSIX
3605 d.stat.st_blksize = 0;
3606 d.stat.st_blocks = 0;
3607 #endif
3608
3609 if (d.stat.st_size == 0) return 0;
3610
3611 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3612
3613 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3614 {
3615 if (d_cache)
3616 {
3617 u64 cnt = d_cache->cnt;
3618
3619 u64 keyspace = cnt;
3620
3621 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3622 {
3623 keyspace *= data.kernel_rules_cnt;
3624 }
3625 else if (data.attack_kern == ATTACK_KERN_COMBI)
3626 {
3627 keyspace *= data.combs_cnt;
3628 }
3629
3630 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);
3631 if (data.quiet == 0) log_info ("");
3632
3633 hc_signal (sigHandler_default);
3634
3635 return (keyspace);
3636 }
3637 }
3638
3639 time_t now = 0;
3640 time_t prev = 0;
3641
3642 u64 comp = 0;
3643 u64 cnt = 0;
3644 u64 cnt2 = 0;
3645
3646 while (!feof (fd))
3647 {
3648 load_segment (wl_data, fd);
3649
3650 comp += wl_data->cnt;
3651
3652 u32 i = 0;
3653
3654 while (i < wl_data->cnt)
3655 {
3656 u32 len;
3657 u32 off;
3658
3659 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3660
3661 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3662 {
3663 char rule_buf_out[BLOCK_SIZE] = { 0 };
3664
3665 int rule_len_out = -1;
3666
3667 if (len < BLOCK_SIZE)
3668 {
3669 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3670 }
3671
3672 if (rule_len_out < 0)
3673 {
3674 len = PW_MAX1;
3675 }
3676 else
3677 {
3678 len = rule_len_out;
3679 }
3680 }
3681
3682 if (len < PW_MAX1)
3683 {
3684 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3685 {
3686 cnt += data.kernel_rules_cnt;
3687 }
3688 else if (data.attack_kern == ATTACK_KERN_COMBI)
3689 {
3690 cnt += data.combs_cnt;
3691 }
3692
3693 d.cnt++;
3694 }
3695
3696 i += off;
3697
3698 cnt2++;
3699 }
3700
3701 time (&now);
3702
3703 if ((now - prev) == 0) continue;
3704
3705 float percent = (float) comp / (float) d.stat.st_size;
3706
3707 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);
3708
3709 time (&prev);
3710 }
3711
3712 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);
3713 if (data.quiet == 0) log_info ("");
3714
3715 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3716
3717 hc_signal (sigHandler_default);
3718
3719 return (cnt);
3720 }
3721
3722 static void *thread_monitor (void *p)
3723 {
3724 uint runtime_check = 0;
3725 uint remove_check = 0;
3726 uint status_check = 0;
3727 uint restore_check = 0;
3728
3729 uint restore_left = data.restore_timer;
3730 uint remove_left = data.remove_timer;
3731 uint status_left = data.status_timer;
3732
3733 #ifdef HAVE_HWMON
3734 uint hwmon_check = 0;
3735
3736 // these variables are mainly used for fan control (AMD only)
3737
3738 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3739
3740 // temperature controller "loopback" values
3741
3742 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3743 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3744
3745 #ifdef HAVE_ADL
3746 int temp_threshold = 1; // degrees celcius
3747
3748 int fan_speed_min = 15; // in percentage
3749 int fan_speed_max = 100;
3750 #endif // HAVE_ADL
3751
3752 time_t last_temp_check_time;
3753 #endif // HAVE_HWMON
3754
3755 uint sleep_time = 1;
3756
3757 if (data.runtime)
3758 {
3759 runtime_check = 1;
3760 }
3761
3762 if (data.restore_timer)
3763 {
3764 restore_check = 1;
3765 }
3766
3767 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3768 {
3769 remove_check = 1;
3770 }
3771
3772 if (data.status == 1)
3773 {
3774 status_check = 1;
3775 }
3776
3777 #ifdef HAVE_HWMON
3778 if (data.gpu_temp_disable == 0)
3779 {
3780 time (&last_temp_check_time);
3781
3782 hwmon_check = 1;
3783 }
3784 #endif
3785
3786 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3787 {
3788 #ifdef HAVE_HWMON
3789 if (hwmon_check == 0)
3790 #endif
3791 return (p);
3792 }
3793
3794 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3795 {
3796 hc_sleep (sleep_time);
3797
3798 if (data.devices_status != STATUS_RUNNING) continue;
3799
3800 #ifdef HAVE_HWMON
3801 if (hwmon_check == 1)
3802 {
3803 hc_thread_mutex_lock (mux_adl);
3804
3805 time_t temp_check_time;
3806
3807 time (&temp_check_time);
3808
3809 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3810
3811 if (Ta == 0) Ta = 1;
3812
3813 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3814 {
3815 hc_device_param_t *device_param = &data.devices_param[device_id];
3816
3817 if (device_param->skipped) continue;
3818
3819 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3820
3821 const int temperature = hm_get_temperature_with_device_id (device_id);
3822
3823 if (temperature > (int) data.gpu_temp_abort)
3824 {
3825 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3826
3827 if (data.devices_status != STATUS_QUIT) myabort ();
3828
3829 break;
3830 }
3831
3832 #ifdef HAVE_ADL
3833 const int gpu_temp_retain = data.gpu_temp_retain;
3834
3835 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3836 {
3837 if (data.hm_device[device_id].fan_supported == 1)
3838 {
3839 int temp_cur = temperature;
3840
3841 int temp_diff_new = gpu_temp_retain - temp_cur;
3842
3843 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3844
3845 // calculate Ta value (time difference in seconds between the last check and this check)
3846
3847 last_temp_check_time = temp_check_time;
3848
3849 float Kp = 1.8;
3850 float Ki = 0.005;
3851 float Kd = 6;
3852
3853 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3854
3855 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);
3856
3857 if (abs (fan_diff_required) >= temp_threshold)
3858 {
3859 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3860
3861 int fan_speed_level = fan_speed_cur;
3862
3863 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3864
3865 int fan_speed_new = fan_speed_level - fan_diff_required;
3866
3867 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3868 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3869
3870 if (fan_speed_new != fan_speed_cur)
3871 {
3872 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3873 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3874
3875 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3876 {
3877 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3878
3879 fan_speed_chgd[device_id] = 1;
3880 }
3881
3882 temp_diff_old[device_id] = temp_diff_new;
3883 }
3884 }
3885 }
3886 }
3887 #endif // HAVE_ADL
3888 }
3889
3890 hc_thread_mutex_unlock (mux_adl);
3891 }
3892 #endif // HAVE_HWMON
3893
3894 if (restore_check == 1)
3895 {
3896 restore_left--;
3897
3898 if (restore_left == 0)
3899 {
3900 if (data.restore_disable == 0) cycle_restore ();
3901
3902 restore_left = data.restore_timer;
3903 }
3904 }
3905
3906 if ((runtime_check == 1) && (data.runtime_start > 0))
3907 {
3908 time_t runtime_cur;
3909
3910 time (&runtime_cur);
3911
3912 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3913
3914 if (runtime_left <= 0)
3915 {
3916 if (data.benchmark == 0)
3917 {
3918 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3919 }
3920
3921 if (data.devices_status != STATUS_QUIT) myabort ();
3922 }
3923 }
3924
3925 if (remove_check == 1)
3926 {
3927 remove_left--;
3928
3929 if (remove_left == 0)
3930 {
3931 if (data.digests_saved != data.digests_done)
3932 {
3933 data.digests_saved = data.digests_done;
3934
3935 save_hash ();
3936 }
3937
3938 remove_left = data.remove_timer;
3939 }
3940 }
3941
3942 if (status_check == 1)
3943 {
3944 status_left--;
3945
3946 if (status_left == 0)
3947 {
3948 hc_thread_mutex_lock (mux_display);
3949
3950 if (data.quiet == 0) clear_prompt ();
3951
3952 if (data.quiet == 0) log_info ("");
3953
3954 status_display ();
3955
3956 if (data.quiet == 0) log_info ("");
3957
3958 hc_thread_mutex_unlock (mux_display);
3959
3960 status_left = data.status_timer;
3961 }
3962 }
3963 }
3964
3965 #ifdef HAVE_HWMON
3966 myfree (fan_speed_chgd);
3967
3968 myfree (temp_diff_old);
3969 myfree (temp_diff_sum);
3970 #endif
3971
3972 p = NULL;
3973
3974 return (p);
3975 }
3976
3977 static void *thread_outfile_remove (void *p)
3978 {
3979 // some hash-dependent constants
3980 char *outfile_dir = data.outfile_check_directory;
3981 uint dgst_size = data.dgst_size;
3982 uint isSalted = data.isSalted;
3983 uint esalt_size = data.esalt_size;
3984 uint hash_mode = data.hash_mode;
3985
3986 uint outfile_check_timer = data.outfile_check_timer;
3987
3988 char separator = data.separator;
3989
3990 // some hash-dependent functions
3991 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3992 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3993
3994 // buffers
3995 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3996
3997 hash_buf.digest = mymalloc (dgst_size);
3998
3999 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4000
4001 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4002
4003 uint digest_buf[64] = { 0 };
4004
4005 outfile_data_t *out_info = NULL;
4006
4007 char **out_files = NULL;
4008
4009 time_t folder_mtime = 0;
4010
4011 int out_cnt = 0;
4012
4013 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4014
4015 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4016 {
4017 hc_sleep (1);
4018
4019 if (data.devices_status != STATUS_RUNNING) continue;
4020
4021 check_left--;
4022
4023 if (check_left == 0)
4024 {
4025 struct stat outfile_check_stat;
4026
4027 if (stat (outfile_dir, &outfile_check_stat) == 0)
4028 {
4029 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4030
4031 if (is_dir == 1)
4032 {
4033 if (outfile_check_stat.st_mtime > folder_mtime)
4034 {
4035 char **out_files_new = scan_directory (outfile_dir);
4036
4037 int out_cnt_new = count_dictionaries (out_files_new);
4038
4039 outfile_data_t *out_info_new = NULL;
4040
4041 if (out_cnt_new > 0)
4042 {
4043 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4044
4045 for (int i = 0; i < out_cnt_new; i++)
4046 {
4047 out_info_new[i].file_name = out_files_new[i];
4048
4049 // check if there are files that we have seen/checked before (and not changed)
4050
4051 for (int j = 0; j < out_cnt; j++)
4052 {
4053 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4054 {
4055 struct stat outfile_stat;
4056
4057 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4058 {
4059 if (outfile_stat.st_ctime == out_info[j].ctime)
4060 {
4061 out_info_new[i].ctime = out_info[j].ctime;
4062 out_info_new[i].seek = out_info[j].seek;
4063 }
4064 }
4065 }
4066 }
4067 }
4068 }
4069
4070 local_free (out_info);
4071 local_free (out_files);
4072
4073 out_files = out_files_new;
4074 out_cnt = out_cnt_new;
4075 out_info = out_info_new;
4076
4077 folder_mtime = outfile_check_stat.st_mtime;
4078 }
4079
4080 for (int j = 0; j < out_cnt; j++)
4081 {
4082 FILE *fp = fopen (out_info[j].file_name, "rb");
4083
4084 if (fp != NULL)
4085 {
4086 //hc_thread_mutex_lock (mux_display);
4087
4088 #ifdef _POSIX
4089 struct stat outfile_stat;
4090
4091 fstat (fileno (fp), &outfile_stat);
4092 #endif
4093
4094 #ifdef _WIN
4095 struct stat64 outfile_stat;
4096
4097 _fstat64 (fileno (fp), &outfile_stat);
4098 #endif
4099
4100 if (outfile_stat.st_ctime > out_info[j].ctime)
4101 {
4102 out_info[j].ctime = outfile_stat.st_ctime;
4103 out_info[j].seek = 0;
4104 }
4105
4106 fseek (fp, out_info[j].seek, SEEK_SET);
4107
4108 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4109
4110 while (!feof (fp))
4111 {
4112 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4113
4114 if (ptr == NULL) break;
4115
4116 int line_len = strlen (line_buf);
4117
4118 if (line_len <= 0) continue;
4119
4120 int iter = MAX_CUT_TRIES;
4121
4122 for (uint i = line_len - 1; i && iter; i--, line_len--)
4123 {
4124 if (line_buf[i] != separator) continue;
4125
4126 int parser_status = PARSER_OK;
4127
4128 if ((hash_mode != 2500) && (hash_mode != 6800))
4129 {
4130 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4131 }
4132
4133 uint found = 0;
4134
4135 if (parser_status == PARSER_OK)
4136 {
4137 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4138 {
4139 if (data.salts_shown[salt_pos] == 1) continue;
4140
4141 salt_t *salt_buf = &data.salts_buf[salt_pos];
4142
4143 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4144 {
4145 uint idx = salt_buf->digests_offset + digest_pos;
4146
4147 if (data.digests_shown[idx] == 1) continue;
4148
4149 uint cracked = 0;
4150
4151 if (hash_mode == 6800)
4152 {
4153 if (i == salt_buf->salt_len)
4154 {
4155 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4156 }
4157 }
4158 else if (hash_mode == 2500)
4159 {
4160 // BSSID : MAC1 : MAC2 (:plain)
4161 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4162 {
4163 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4164
4165 if (!cracked) continue;
4166
4167 // now compare MAC1 and MAC2 too, since we have this additional info
4168 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4169 char *mac2_pos = mac1_pos + 12 + 1;
4170
4171 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4172 wpa_t *wpa = &wpas[salt_pos];
4173
4174 // compare hex string(s) vs binary MAC address(es)
4175
4176 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4177 {
4178 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4179 {
4180 cracked = 0;
4181
4182 break;
4183 }
4184 }
4185
4186 // early skip ;)
4187 if (!cracked) continue;
4188
4189 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4190 {
4191 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4192 {
4193 cracked = 0;
4194
4195 break;
4196 }
4197 }
4198 }
4199 }
4200 else
4201 {
4202 char *digests_buf_ptr = (char *) data.digests_buf;
4203
4204 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4205
4206 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4207 }
4208
4209 if (cracked == 1)
4210 {
4211 found = 1;
4212
4213 data.digests_shown[idx] = 1;
4214
4215 data.digests_done++;
4216
4217 salt_buf->digests_done++;
4218
4219 if (salt_buf->digests_done == salt_buf->digests_cnt)
4220 {
4221 data.salts_shown[salt_pos] = 1;
4222
4223 data.salts_done++;
4224
4225 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4226 }
4227 }
4228 }
4229
4230 if (data.devices_status == STATUS_CRACKED) break;
4231 }
4232 }
4233
4234 if (found) break;
4235
4236 if (data.devices_status == STATUS_CRACKED) break;
4237
4238 iter--;
4239 }
4240
4241 if (data.devices_status == STATUS_CRACKED) break;
4242 }
4243
4244 myfree (line_buf);
4245
4246 out_info[j].seek = ftell (fp);
4247
4248 //hc_thread_mutex_unlock (mux_display);
4249
4250 fclose (fp);
4251 }
4252 }
4253 }
4254 }
4255
4256 check_left = outfile_check_timer;
4257 }
4258 }
4259
4260 if (esalt_size) local_free (hash_buf.esalt);
4261
4262 if (isSalted) local_free (hash_buf.salt);
4263
4264 local_free (hash_buf.digest);
4265
4266 local_free (out_info);
4267
4268 local_free (out_files);
4269
4270 p = NULL;
4271
4272 return (p);
4273 }
4274
4275 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4276 {
4277 if (device_param->pws_cnt < device_param->kernel_power)
4278 {
4279 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4280
4281 u8 *ptr = (u8 *) pw->i;
4282
4283 memcpy (ptr, pw_buf, pw_len);
4284
4285 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4286
4287 pw->pw_len = pw_len;
4288
4289 device_param->pws_cnt++;
4290 }
4291 else
4292 {
4293 fprintf (stderr, "BUG pw_add()!!\n");
4294
4295 return;
4296 }
4297 }
4298
4299 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4300 {
4301 hc_thread_mutex_lock (mux_dispatcher);
4302
4303 const u64 words_cur = data.words_cur;
4304 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4305
4306 device_param->words_off = words_cur;
4307
4308 const u64 words_left = words_base - words_cur;
4309
4310 if (allow_div)
4311 {
4312 if (data.kernel_power_all > words_left)
4313 {
4314 if (data.kernel_power_div == 0)
4315 {
4316 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4317 }
4318 }
4319
4320 if (data.kernel_power_div)
4321 {
4322 if (device_param->kernel_power == device_param->kernel_power_user)
4323 {
4324 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4325
4326 if (kernel_power_new < device_param->kernel_power)
4327 {
4328 device_param->kernel_power = kernel_power_new;
4329 }
4330 }
4331 }
4332 }
4333
4334 const uint kernel_power = device_param->kernel_power;
4335
4336 uint work = MIN (words_left, kernel_power);
4337
4338 work = MIN (work, max);
4339
4340 data.words_cur += work;
4341
4342 hc_thread_mutex_unlock (mux_dispatcher);
4343
4344 return work;
4345 }
4346
4347 static void *thread_calc_stdin (void *p)
4348 {
4349 hc_device_param_t *device_param = (hc_device_param_t *) p;
4350
4351 if (device_param->skipped) return NULL;
4352
4353 autotune (device_param);
4354
4355 char *buf = (char *) mymalloc (HCBUFSIZ);
4356
4357 const uint attack_kern = data.attack_kern;
4358
4359 const uint kernel_power = device_param->kernel_power;
4360
4361 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4362 {
4363 hc_thread_mutex_lock (mux_dispatcher);
4364
4365 if (feof (stdin) != 0)
4366 {
4367 hc_thread_mutex_unlock (mux_dispatcher);
4368
4369 break;
4370 }
4371
4372 uint words_cur = 0;
4373
4374 while (words_cur < kernel_power)
4375 {
4376 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4377
4378 if (line_buf == NULL) break;
4379
4380 uint line_len = in_superchop (line_buf);
4381
4382 line_len = convert_from_hex (line_buf, line_len);
4383
4384 // post-process rule engine
4385
4386 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4387 {
4388 char rule_buf_out[BLOCK_SIZE] = { 0 };
4389
4390 int rule_len_out = -1;
4391
4392 if (line_len < BLOCK_SIZE)
4393 {
4394 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4395 }
4396
4397 if (rule_len_out < 0) continue;
4398
4399 line_buf = rule_buf_out;
4400 line_len = rule_len_out;
4401 }
4402
4403 if (line_len > PW_MAX)
4404 {
4405 continue;
4406 }
4407
4408 if (attack_kern == ATTACK_KERN_STRAIGHT)
4409 {
4410 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4411 {
4412 hc_thread_mutex_lock (mux_counter);
4413
4414 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4415 {
4416 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4417 }
4418
4419 hc_thread_mutex_unlock (mux_counter);
4420
4421 continue;
4422 }
4423 }
4424 else if (attack_kern == ATTACK_KERN_COMBI)
4425 {
4426 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4427 // since we still need to combine the plains
4428
4429 if (line_len > data.pw_max)
4430 {
4431 hc_thread_mutex_lock (mux_counter);
4432
4433 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4434 {
4435 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4436 }
4437
4438 hc_thread_mutex_unlock (mux_counter);
4439
4440 continue;
4441 }
4442 }
4443
4444 pw_add (device_param, (u8 *) line_buf, line_len);
4445
4446 words_cur++;
4447
4448 if (data.devices_status == STATUS_CRACKED) break;
4449 if (data.devices_status == STATUS_ABORTED) break;
4450 if (data.devices_status == STATUS_QUIT) break;
4451 if (data.devices_status == STATUS_BYPASS) break;
4452 }
4453
4454 hc_thread_mutex_unlock (mux_dispatcher);
4455
4456 if (data.devices_status == STATUS_CRACKED) break;
4457 if (data.devices_status == STATUS_ABORTED) break;
4458 if (data.devices_status == STATUS_QUIT) break;
4459 if (data.devices_status == STATUS_BYPASS) break;
4460
4461 // flush
4462
4463 const uint pws_cnt = device_param->pws_cnt;
4464
4465 if (pws_cnt)
4466 {
4467 run_copy (device_param, pws_cnt);
4468
4469 run_cracker (device_param, pws_cnt);
4470
4471 device_param->pws_cnt = 0;
4472
4473 if (attack_kern == ATTACK_KERN_STRAIGHT)
4474 {
4475 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4476 }
4477 else if (attack_kern == ATTACK_KERN_COMBI)
4478 {
4479 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4480 }
4481 }
4482 }
4483
4484 device_param->kernel_accel = 0;
4485 device_param->kernel_loops = 0;
4486
4487 myfree (buf);
4488
4489 return NULL;
4490 }
4491
4492 static void *thread_calc (void *p)
4493 {
4494 hc_device_param_t *device_param = (hc_device_param_t *) p;
4495
4496 if (device_param->skipped) return NULL;
4497
4498 autotune (device_param);
4499
4500 const uint attack_mode = data.attack_mode;
4501 const uint attack_kern = data.attack_kern;
4502
4503 if (attack_mode == ATTACK_MODE_BF)
4504 {
4505 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4506 {
4507 const uint work = get_work (device_param, -1, true);
4508
4509 if (work == 0) break;
4510
4511 const u64 words_off = device_param->words_off;
4512 const u64 words_fin = words_off + work;
4513
4514 const uint pws_cnt = work;
4515
4516 device_param->pws_cnt = pws_cnt;
4517
4518 if (pws_cnt)
4519 {
4520 run_copy (device_param, pws_cnt);
4521
4522 run_cracker (device_param, pws_cnt);
4523
4524 device_param->pws_cnt = 0;
4525
4526 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4527 }
4528
4529 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4530
4531 if (data.devices_status == STATUS_CRACKED) break;
4532 if (data.devices_status == STATUS_ABORTED) break;
4533 if (data.devices_status == STATUS_QUIT) break;
4534 if (data.devices_status == STATUS_BYPASS) break;
4535
4536 if (data.benchmark == 1) break;
4537
4538 device_param->words_done = words_fin;
4539 }
4540 }
4541 else
4542 {
4543 const uint segment_size = data.segment_size;
4544
4545 char *dictfile = data.dictfile;
4546
4547 if (attack_mode == ATTACK_MODE_COMBI)
4548 {
4549 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4550 {
4551 dictfile = data.dictfile2;
4552 }
4553 }
4554
4555 FILE *fd = fopen (dictfile, "rb");
4556
4557 if (fd == NULL)
4558 {
4559 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4560
4561 return NULL;
4562 }
4563
4564 if (attack_mode == ATTACK_MODE_COMBI)
4565 {
4566 const uint combs_mode = data.combs_mode;
4567
4568 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4569 {
4570 const char *dictfilec = data.dictfile2;
4571
4572 FILE *combs_fp = fopen (dictfilec, "rb");
4573
4574 if (combs_fp == NULL)
4575 {
4576 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4577
4578 fclose (fd);
4579
4580 return NULL;
4581 }
4582
4583 device_param->combs_fp = combs_fp;
4584 }
4585 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4586 {
4587 const char *dictfilec = data.dictfile;
4588
4589 FILE *combs_fp = fopen (dictfilec, "rb");
4590
4591 if (combs_fp == NULL)
4592 {
4593 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4594
4595 fclose (fd);
4596
4597 return NULL;
4598 }
4599
4600 device_param->combs_fp = combs_fp;
4601 }
4602 }
4603
4604 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4605
4606 wl_data->buf = (char *) mymalloc (segment_size);
4607 wl_data->avail = segment_size;
4608 wl_data->incr = segment_size;
4609 wl_data->cnt = 0;
4610 wl_data->pos = 0;
4611
4612 u64 words_cur = 0;
4613
4614 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4615 {
4616 u64 words_off = 0;
4617 u64 words_fin = 0;
4618
4619 bool allow_div = true;
4620
4621 u64 max = -1;
4622
4623 while (max)
4624 {
4625 const uint work = get_work (device_param, max, allow_div);
4626
4627 allow_div = false;
4628
4629 if (work == 0) break;
4630
4631 words_off = device_param->words_off;
4632 words_fin = words_off + work;
4633
4634 char *line_buf;
4635 uint line_len;
4636
4637 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4638
4639 max = 0;
4640
4641 for ( ; words_cur < words_fin; words_cur++)
4642 {
4643 get_next_word (wl_data, fd, &line_buf, &line_len);
4644
4645 line_len = convert_from_hex (line_buf, line_len);
4646
4647 // post-process rule engine
4648
4649 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4650 {
4651 char rule_buf_out[BLOCK_SIZE] = { 0 };
4652
4653 int rule_len_out = -1;
4654
4655 if (line_len < BLOCK_SIZE)
4656 {
4657 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4658 }
4659
4660 if (rule_len_out < 0) continue;
4661
4662 line_buf = rule_buf_out;
4663 line_len = rule_len_out;
4664 }
4665
4666 if (attack_kern == ATTACK_KERN_STRAIGHT)
4667 {
4668 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4669 {
4670 max++;
4671
4672 hc_thread_mutex_lock (mux_counter);
4673
4674 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4675 {
4676 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4677 }
4678
4679 hc_thread_mutex_unlock (mux_counter);
4680
4681 continue;
4682 }
4683 }
4684 else if (attack_kern == ATTACK_KERN_COMBI)
4685 {
4686 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4687 // since we still need to combine the plains
4688
4689 if (line_len > data.pw_max)
4690 {
4691 max++;
4692
4693 hc_thread_mutex_lock (mux_counter);
4694
4695 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4696 {
4697 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4698 }
4699
4700 hc_thread_mutex_unlock (mux_counter);
4701
4702 continue;
4703 }
4704 }
4705
4706 pw_add (device_param, (u8 *) line_buf, line_len);
4707
4708 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4709
4710 if (data.devices_status == STATUS_CRACKED) break;
4711 if (data.devices_status == STATUS_ABORTED) break;
4712 if (data.devices_status == STATUS_QUIT) break;
4713 if (data.devices_status == STATUS_BYPASS) break;
4714 }
4715
4716 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4717
4718 if (data.devices_status == STATUS_CRACKED) break;
4719 if (data.devices_status == STATUS_ABORTED) break;
4720 if (data.devices_status == STATUS_QUIT) break;
4721 if (data.devices_status == STATUS_BYPASS) break;
4722 }
4723
4724 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4725
4726 if (data.devices_status == STATUS_CRACKED) break;
4727 if (data.devices_status == STATUS_ABORTED) break;
4728 if (data.devices_status == STATUS_QUIT) break;
4729 if (data.devices_status == STATUS_BYPASS) break;
4730
4731 //
4732 // flush
4733 //
4734
4735 const uint pws_cnt = device_param->pws_cnt;
4736
4737 if (pws_cnt)
4738 {
4739 run_copy (device_param, pws_cnt);
4740
4741 run_cracker (device_param, pws_cnt);
4742
4743 device_param->pws_cnt = 0;
4744
4745 if (attack_kern == ATTACK_KERN_STRAIGHT)
4746 {
4747 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4748 }
4749 else if (attack_kern == ATTACK_KERN_COMBI)
4750 {
4751 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4752 }
4753 }
4754
4755 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4756
4757 if (data.devices_status == STATUS_CRACKED) break;
4758 if (data.devices_status == STATUS_ABORTED) break;
4759 if (data.devices_status == STATUS_QUIT) break;
4760 if (data.devices_status == STATUS_BYPASS) break;
4761
4762 if (words_fin == 0) break;
4763
4764 device_param->words_done = words_fin;
4765 }
4766
4767 if (attack_mode == ATTACK_MODE_COMBI)
4768 {
4769 fclose (device_param->combs_fp);
4770 }
4771
4772 free (wl_data->buf);
4773 free (wl_data);
4774
4775 fclose (fd);
4776 }
4777
4778 device_param->kernel_accel = 0;
4779 device_param->kernel_loops = 0;
4780
4781 return NULL;
4782 }
4783
4784 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4785 {
4786 if (!device_param)
4787 {
4788 log_error ("ERROR: %s : Invalid argument", __func__);
4789
4790 exit (-1);
4791 }
4792
4793 salt_t *salt_buf = &data.salts_buf[salt_pos];
4794
4795 device_param->kernel_params_buf32[24] = salt_pos;
4796 device_param->kernel_params_buf32[27] = 1;
4797 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4798 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4799 device_param->kernel_params_buf32[30] = 0;
4800 device_param->kernel_params_buf32[31] = 1;
4801
4802 char *dictfile_old = data.dictfile;
4803
4804 const char *weak_hash_check = "weak-hash-check";
4805
4806 data.dictfile = (char *) weak_hash_check;
4807
4808 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4809
4810 data.kernel_rules_buf[0].cmds[0] = 0;
4811
4812 /**
4813 * run the kernel
4814 */
4815
4816 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4817 {
4818 run_kernel (KERN_RUN_1, device_param, 1, false);
4819 }
4820 else
4821 {
4822 run_kernel (KERN_RUN_1, device_param, 1, false);
4823
4824 uint loop_step = 16;
4825
4826 const uint iter = salt_buf->salt_iter;
4827
4828 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4829 {
4830 uint loop_left = iter - loop_pos;
4831
4832 loop_left = MIN (loop_left, loop_step);
4833
4834 device_param->kernel_params_buf32[25] = loop_pos;
4835 device_param->kernel_params_buf32[26] = loop_left;
4836
4837 run_kernel (KERN_RUN_2, device_param, 1, false);
4838 }
4839
4840 run_kernel (KERN_RUN_3, device_param, 1, false);
4841 }
4842
4843 /**
4844 * result
4845 */
4846
4847 check_cracked (device_param, salt_pos);
4848
4849 /**
4850 * cleanup
4851 */
4852
4853 device_param->kernel_params_buf32[24] = 0;
4854 device_param->kernel_params_buf32[25] = 0;
4855 device_param->kernel_params_buf32[26] = 0;
4856 device_param->kernel_params_buf32[27] = 0;
4857 device_param->kernel_params_buf32[28] = 0;
4858 device_param->kernel_params_buf32[29] = 0;
4859 device_param->kernel_params_buf32[30] = 0;
4860 device_param->kernel_params_buf32[31] = 0;
4861
4862 data.dictfile = dictfile_old;
4863
4864 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4865 }
4866
4867 // hlfmt hashcat
4868
4869 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4870 {
4871 if (data.username == 0)
4872 {
4873 *hashbuf_pos = line_buf;
4874 *hashbuf_len = line_len;
4875 }
4876 else
4877 {
4878 char *pos = line_buf;
4879 int len = line_len;
4880
4881 for (int i = 0; i < line_len; i++, pos++, len--)
4882 {
4883 if (line_buf[i] == data.separator)
4884 {
4885 pos++;
4886
4887 len--;
4888
4889 break;
4890 }
4891 }
4892
4893 *hashbuf_pos = pos;
4894 *hashbuf_len = len;
4895 }
4896 }
4897
4898 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4899 {
4900 char *pos = NULL;
4901 int len = 0;
4902
4903 int sep_cnt = 0;
4904
4905 for (int i = 0; i < line_len; i++)
4906 {
4907 if (line_buf[i] == data.separator)
4908 {
4909 sep_cnt++;
4910
4911 continue;
4912 }
4913
4914 if (sep_cnt == 0)
4915 {
4916 if (pos == NULL) pos = line_buf + i;
4917
4918 len++;
4919 }
4920 }
4921
4922 *userbuf_pos = pos;
4923 *userbuf_len = len;
4924 }
4925
4926 // hlfmt pwdump
4927
4928 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4929 {
4930 int sep_cnt = 0;
4931
4932 int sep2_len = 0;
4933 int sep3_len = 0;
4934
4935 for (int i = 0; i < line_len; i++)
4936 {
4937 if (line_buf[i] == ':')
4938 {
4939 sep_cnt++;
4940
4941 continue;
4942 }
4943
4944 if (sep_cnt == 2) sep2_len++;
4945 if (sep_cnt == 3) sep3_len++;
4946 }
4947
4948 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4949
4950 return 0;
4951 }
4952
4953 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4954 {
4955 char *pos = NULL;
4956 int len = 0;
4957
4958 int sep_cnt = 0;
4959
4960 for (int i = 0; i < line_len; i++)
4961 {
4962 if (line_buf[i] == ':')
4963 {
4964 sep_cnt++;
4965
4966 continue;
4967 }
4968
4969 if (data.hash_mode == 1000)
4970 {
4971 if (sep_cnt == 3)
4972 {
4973 if (pos == NULL) pos = line_buf + i;
4974
4975 len++;
4976 }
4977 }
4978 else if (data.hash_mode == 3000)
4979 {
4980 if (sep_cnt == 2)
4981 {
4982 if (pos == NULL) pos = line_buf + i;
4983
4984 len++;
4985 }
4986 }
4987 }
4988
4989 *hashbuf_pos = pos;
4990 *hashbuf_len = len;
4991 }
4992
4993 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4994 {
4995 char *pos = NULL;
4996 int len = 0;
4997
4998 int sep_cnt = 0;
4999
5000 for (int i = 0; i < line_len; i++)
5001 {
5002 if (line_buf[i] == ':')
5003 {
5004 sep_cnt++;
5005
5006 continue;
5007 }
5008
5009 if (sep_cnt == 0)
5010 {
5011 if (pos == NULL) pos = line_buf + i;
5012
5013 len++;
5014 }
5015 }
5016
5017 *userbuf_pos = pos;
5018 *userbuf_len = len;
5019 }
5020
5021 // hlfmt passwd
5022
5023 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5024 {
5025 int sep_cnt = 0;
5026
5027 char sep5_first = 0;
5028 char sep6_first = 0;
5029
5030 for (int i = 0; i < line_len; i++)
5031 {
5032 if (line_buf[i] == ':')
5033 {
5034 sep_cnt++;
5035
5036 continue;
5037 }
5038
5039 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5040 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5041 }
5042
5043 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5044
5045 return 0;
5046 }
5047
5048 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5049 {
5050 char *pos = NULL;
5051 int len = 0;
5052
5053 int sep_cnt = 0;
5054
5055 for (int i = 0; i < line_len; i++)
5056 {
5057 if (line_buf[i] == ':')
5058 {
5059 sep_cnt++;
5060
5061 continue;
5062 }
5063
5064 if (sep_cnt == 1)
5065 {
5066 if (pos == NULL) pos = line_buf + i;
5067
5068 len++;
5069 }
5070 }
5071
5072 *hashbuf_pos = pos;
5073 *hashbuf_len = len;
5074 }
5075
5076 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5077 {
5078 char *pos = NULL;
5079 int len = 0;
5080
5081 int sep_cnt = 0;
5082
5083 for (int i = 0; i < line_len; i++)
5084 {
5085 if (line_buf[i] == ':')
5086 {
5087 sep_cnt++;
5088
5089 continue;
5090 }
5091
5092 if (sep_cnt == 0)
5093 {
5094 if (pos == NULL) pos = line_buf + i;
5095
5096 len++;
5097 }
5098 }
5099
5100 *userbuf_pos = pos;
5101 *userbuf_len = len;
5102 }
5103
5104 // hlfmt shadow
5105
5106 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5107 {
5108 int sep_cnt = 0;
5109
5110 for (int i = 0; i < line_len; i++)
5111 {
5112 if (line_buf[i] == ':') sep_cnt++;
5113 }
5114
5115 if (sep_cnt == 8) return 1;
5116
5117 return 0;
5118 }
5119
5120 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5121 {
5122 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5123 }
5124
5125 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5126 {
5127 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5128 }
5129
5130 // hlfmt main
5131
5132 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5133 {
5134 switch (hashfile_format)
5135 {
5136 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5137 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5138 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5139 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5140 }
5141 }
5142
5143 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5144 {
5145 switch (hashfile_format)
5146 {
5147 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5148 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5149 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5150 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5151 }
5152 }
5153
5154 char *strhlfmt (const uint hashfile_format)
5155 {
5156 switch (hashfile_format)
5157 {
5158 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5159 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5160 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5161 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5162 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5163 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5164 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5165 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5166 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5167 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5168 }
5169
5170 return ((char *) "Unknown");
5171 }
5172
5173 static uint hlfmt_detect (FILE *fp, uint max_check)
5174 {
5175 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5176
5177 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5178 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5179
5180 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5181
5182 uint num_check = 0;
5183
5184 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5185
5186 while (!feof (fp))
5187 {
5188 int line_len = fgetl (fp, line_buf);
5189
5190 if (line_len == 0) continue;
5191
5192 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5193 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5194 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5195
5196 if (num_check == max_check) break;
5197
5198 num_check++;
5199 }
5200
5201 myfree (line_buf);
5202
5203 uint hashlist_format = HLFMT_HASHCAT;
5204
5205 for (int i = 1; i < HLFMTS_CNT; i++)
5206 {
5207 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5208
5209 hashlist_format = i;
5210 }
5211
5212 free (formats_cnt);
5213
5214 return hashlist_format;
5215 }
5216
5217 /**
5218 * some further helper function
5219 */
5220
5221 // wrapper around mymalloc for ADL
5222
5223 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5224 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5225 {
5226 return mymalloc (iSize);
5227 }
5228 #endif
5229
5230 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)
5231 {
5232 u64 collisions = 0;
5233
5234 const uint dgst_pos0 = data.dgst_pos0;
5235 const uint dgst_pos1 = data.dgst_pos1;
5236 const uint dgst_pos2 = data.dgst_pos2;
5237 const uint dgst_pos3 = data.dgst_pos3;
5238
5239 memset (bitmap_a, 0, bitmap_size);
5240 memset (bitmap_b, 0, bitmap_size);
5241 memset (bitmap_c, 0, bitmap_size);
5242 memset (bitmap_d, 0, bitmap_size);
5243
5244 for (uint i = 0; i < digests_cnt; i++)
5245 {
5246 uint *digest_ptr = (uint *) digests_buf_ptr;
5247
5248 digests_buf_ptr += dgst_size;
5249
5250 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5251 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5252 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5253 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5254
5255 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5256 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5257 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5258 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5259
5260 if (bitmap_a[idx0] & val0) collisions++;
5261 if (bitmap_b[idx1] & val1) collisions++;
5262 if (bitmap_c[idx2] & val2) collisions++;
5263 if (bitmap_d[idx3] & val3) collisions++;
5264
5265 bitmap_a[idx0] |= val0;
5266 bitmap_b[idx1] |= val1;
5267 bitmap_c[idx2] |= val2;
5268 bitmap_d[idx3] |= val3;
5269
5270 if (collisions >= collisions_max) return 0x7fffffff;
5271 }
5272
5273 return collisions;
5274 }
5275
5276 /**
5277 * main
5278 */
5279
5280 int main (int argc, char **argv)
5281 {
5282 /**
5283 * To help users a bit
5284 */
5285
5286 char *compute = getenv ("COMPUTE");
5287
5288 if (compute)
5289 {
5290 static char display[100];
5291
5292 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5293
5294 putenv (display);
5295 }
5296 else
5297 {
5298 if (getenv ("DISPLAY") == NULL)
5299 putenv ((char *) "DISPLAY=:0");
5300 }
5301
5302 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5303 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5304
5305 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5306 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5307
5308 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5309 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5310
5311 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5312 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5313
5314 /**
5315 * Real init
5316 */
5317
5318 memset (&data, 0, sizeof (hc_global_data_t));
5319
5320 time_t proc_start;
5321
5322 time (&proc_start);
5323
5324 data.proc_start = proc_start;
5325
5326 int myargc = argc;
5327 char **myargv = argv;
5328
5329 hc_thread_mutex_init (mux_dispatcher);
5330 hc_thread_mutex_init (mux_counter);
5331 hc_thread_mutex_init (mux_display);
5332 hc_thread_mutex_init (mux_adl);
5333
5334 /**
5335 * commandline parameters
5336 */
5337
5338 uint usage = USAGE;
5339 uint version = VERSION;
5340 uint quiet = QUIET;
5341 uint benchmark = BENCHMARK;
5342 uint benchmark_repeats = BENCHMARK_REPEATS;
5343 uint show = SHOW;
5344 uint left = LEFT;
5345 uint username = USERNAME;
5346 uint remove = REMOVE;
5347 uint remove_timer = REMOVE_TIMER;
5348 u64 skip = SKIP;
5349 u64 limit = LIMIT;
5350 uint keyspace = KEYSPACE;
5351 uint potfile_disable = POTFILE_DISABLE;
5352 char *potfile_path = NULL;
5353 uint debug_mode = DEBUG_MODE;
5354 char *debug_file = NULL;
5355 char *induction_dir = NULL;
5356 char *outfile_check_dir = NULL;
5357 uint force = FORCE;
5358 uint runtime = RUNTIME;
5359 uint hash_mode = HASH_MODE;
5360 uint attack_mode = ATTACK_MODE;
5361 uint markov_disable = MARKOV_DISABLE;
5362 uint markov_classic = MARKOV_CLASSIC;
5363 uint markov_threshold = MARKOV_THRESHOLD;
5364 char *markov_hcstat = NULL;
5365 char *outfile = NULL;
5366 uint outfile_format = OUTFILE_FORMAT;
5367 uint outfile_autohex = OUTFILE_AUTOHEX;
5368 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5369 uint restore = RESTORE;
5370 uint restore_timer = RESTORE_TIMER;
5371 uint restore_disable = RESTORE_DISABLE;
5372 uint status = STATUS;
5373 uint status_timer = STATUS_TIMER;
5374 uint status_automat = STATUS_AUTOMAT;
5375 uint loopback = LOOPBACK;
5376 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5377 char *session = NULL;
5378 uint hex_charset = HEX_CHARSET;
5379 uint hex_salt = HEX_SALT;
5380 uint hex_wordlist = HEX_WORDLIST;
5381 uint rp_gen = RP_GEN;
5382 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5383 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5384 uint rp_gen_seed = RP_GEN_SEED;
5385 char *rule_buf_l = (char *) RULE_BUF_L;
5386 char *rule_buf_r = (char *) RULE_BUF_R;
5387 uint increment = INCREMENT;
5388 uint increment_min = INCREMENT_MIN;
5389 uint increment_max = INCREMENT_MAX;
5390 char *cpu_affinity = NULL;
5391 OCL_PTR *ocl = NULL;
5392 char *opencl_devices = NULL;
5393 char *opencl_platforms = NULL;
5394 char *opencl_device_types = NULL;
5395 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5396 char *truecrypt_keyfiles = NULL;
5397 uint workload_profile = WORKLOAD_PROFILE;
5398 uint kernel_accel = KERNEL_ACCEL;
5399 uint kernel_loops = KERNEL_LOOPS;
5400 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5401 #ifdef HAVE_HWMON
5402 uint gpu_temp_abort = GPU_TEMP_ABORT;
5403 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5404 #ifdef HAVE_ADL
5405 uint powertune_enable = POWERTUNE_ENABLE;
5406 #endif
5407 #endif
5408 uint logfile_disable = LOGFILE_DISABLE;
5409 uint segment_size = SEGMENT_SIZE;
5410 uint scrypt_tmto = SCRYPT_TMTO;
5411 char separator = SEPARATOR;
5412 uint bitmap_min = BITMAP_MIN;
5413 uint bitmap_max = BITMAP_MAX;
5414 char *custom_charset_1 = NULL;
5415 char *custom_charset_2 = NULL;
5416 char *custom_charset_3 = NULL;
5417 char *custom_charset_4 = NULL;
5418
5419 #define IDX_HELP 'h'
5420 #define IDX_VERSION 'V'
5421 #define IDX_VERSION_LOWER 'v'
5422 #define IDX_QUIET 0xff02
5423 #define IDX_SHOW 0xff03
5424 #define IDX_LEFT 0xff04
5425 #define IDX_REMOVE 0xff05
5426 #define IDX_REMOVE_TIMER 0xff37
5427 #define IDX_SKIP 's'
5428 #define IDX_LIMIT 'l'
5429 #define IDX_KEYSPACE 0xff35
5430 #define IDX_POTFILE_DISABLE 0xff06
5431 #define IDX_POTFILE_PATH 0xffe0
5432 #define IDX_DEBUG_MODE 0xff43
5433 #define IDX_DEBUG_FILE 0xff44
5434 #define IDX_INDUCTION_DIR 0xff46
5435 #define IDX_OUTFILE_CHECK_DIR 0xff47
5436 #define IDX_USERNAME 0xff07
5437 #define IDX_FORCE 0xff08
5438 #define IDX_RUNTIME 0xff09
5439 #define IDX_BENCHMARK 'b'
5440 #define IDX_BENCHMARK_REPEATS 0xff78
5441 #define IDX_HASH_MODE 'm'
5442 #define IDX_ATTACK_MODE 'a'
5443 #define IDX_RP_FILE 'r'
5444 #define IDX_RP_GEN 'g'
5445 #define IDX_RP_GEN_FUNC_MIN 0xff10
5446 #define IDX_RP_GEN_FUNC_MAX 0xff11
5447 #define IDX_RP_GEN_SEED 0xff34
5448 #define IDX_RULE_BUF_L 'j'
5449 #define IDX_RULE_BUF_R 'k'
5450 #define IDX_INCREMENT 'i'
5451 #define IDX_INCREMENT_MIN 0xff12
5452 #define IDX_INCREMENT_MAX 0xff13
5453 #define IDX_OUTFILE 'o'
5454 #define IDX_OUTFILE_FORMAT 0xff14
5455 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5456 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5457 #define IDX_RESTORE 0xff15
5458 #define IDX_RESTORE_DISABLE 0xff27
5459 #define IDX_STATUS 0xff17
5460 #define IDX_STATUS_TIMER 0xff18
5461 #define IDX_STATUS_AUTOMAT 0xff50
5462 #define IDX_LOOPBACK 0xff38
5463 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5464 #define IDX_SESSION 0xff19
5465 #define IDX_HEX_CHARSET 0xff20
5466 #define IDX_HEX_SALT 0xff21
5467 #define IDX_HEX_WORDLIST 0xff40
5468 #define IDX_MARKOV_DISABLE 0xff22
5469 #define IDX_MARKOV_CLASSIC 0xff23
5470 #define IDX_MARKOV_THRESHOLD 't'
5471 #define IDX_MARKOV_HCSTAT 0xff24
5472 #define IDX_CPU_AFFINITY 0xff25
5473 #define IDX_OPENCL_DEVICES 'd'
5474 #define IDX_OPENCL_PLATFORMS 0xff72
5475 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5476 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5477 #define IDX_WORKLOAD_PROFILE 'w'
5478 #define IDX_KERNEL_ACCEL 'n'
5479 #define IDX_KERNEL_LOOPS 'u'
5480 #define IDX_GPU_TEMP_DISABLE 0xff29
5481 #define IDX_GPU_TEMP_ABORT 0xff30
5482 #define IDX_GPU_TEMP_RETAIN 0xff31
5483 #define IDX_POWERTUNE_ENABLE 0xff41
5484 #define IDX_LOGFILE_DISABLE 0xff51
5485 #define IDX_TRUECRYPT_KEYFILES 0xff52
5486 #define IDX_SCRYPT_TMTO 0xff61
5487 #define IDX_SEGMENT_SIZE 'c'
5488 #define IDX_SEPARATOR 'p'
5489 #define IDX_BITMAP_MIN 0xff70
5490 #define IDX_BITMAP_MAX 0xff71
5491 #define IDX_CUSTOM_CHARSET_1 '1'
5492 #define IDX_CUSTOM_CHARSET_2 '2'
5493 #define IDX_CUSTOM_CHARSET_3 '3'
5494 #define IDX_CUSTOM_CHARSET_4 '4'
5495
5496 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5497
5498 struct option long_options[] =
5499 {
5500 {"help", no_argument, 0, IDX_HELP},
5501 {"version", no_argument, 0, IDX_VERSION},
5502 {"quiet", no_argument, 0, IDX_QUIET},
5503 {"show", no_argument, 0, IDX_SHOW},
5504 {"left", no_argument, 0, IDX_LEFT},
5505 {"username", no_argument, 0, IDX_USERNAME},
5506 {"remove", no_argument, 0, IDX_REMOVE},
5507 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5508 {"skip", required_argument, 0, IDX_SKIP},
5509 {"limit", required_argument, 0, IDX_LIMIT},
5510 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5511 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5512 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5513 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5514 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5515 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5516 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5517 {"force", no_argument, 0, IDX_FORCE},
5518 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5519 {"benchmark-repeats", required_argument, 0, IDX_BENCHMARK_REPEATS},
5520 {"restore", no_argument, 0, IDX_RESTORE},
5521 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5522 {"status", no_argument, 0, IDX_STATUS},
5523 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5524 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5525 {"loopback", no_argument, 0, IDX_LOOPBACK},
5526 {"weak-hash-threshold",
5527 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5528 {"session", required_argument, 0, IDX_SESSION},
5529 {"runtime", required_argument, 0, IDX_RUNTIME},
5530 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5531 {"generate-rules-func-min",
5532 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5533 {"generate-rules-func-max",
5534 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5535 {"generate-rules-seed",
5536 required_argument, 0, IDX_RP_GEN_SEED},
5537 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5538 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5539 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5540 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5541 {"rules-file", required_argument, 0, IDX_RP_FILE},
5542 {"outfile", required_argument, 0, IDX_OUTFILE},
5543 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5544 {"outfile-autohex-disable",
5545 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5546 {"outfile-check-timer",
5547 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5548 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5549 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5550 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5551 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5552 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5553 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5554 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5555 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5556 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5557 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5558 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5559 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5560 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5561 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5562 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5563 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5564 #ifdef HAVE_HWMON
5565 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5566 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5567 #ifdef HAVE_ADL
5568 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5569 #endif
5570 #endif // HAVE_HWMON
5571 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5572 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5573 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5574 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5575 // deprecated
5576 {"seperator", required_argument, 0, IDX_SEPARATOR},
5577 {"separator", required_argument, 0, IDX_SEPARATOR},
5578 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5579 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5580 {"increment", no_argument, 0, IDX_INCREMENT},
5581 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5582 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5583 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5584 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5585 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5586 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5587
5588 {0, 0, 0, 0}
5589 };
5590
5591 uint rp_files_cnt = 0;
5592
5593 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5594
5595 int option_index = 0;
5596 int c = -1;
5597
5598 optind = 1;
5599 optopt = 0;
5600
5601 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5602 {
5603 switch (c)
5604 {
5605 case IDX_HELP: usage = 1; break;
5606 case IDX_VERSION:
5607 case IDX_VERSION_LOWER: version = 1; break;
5608 case IDX_RESTORE: restore = 1; break;
5609 case IDX_SESSION: session = optarg; break;
5610 case IDX_SHOW: show = 1; break;
5611 case IDX_LEFT: left = 1; break;
5612 case '?': return (-1);
5613 }
5614 }
5615
5616 if (optopt != 0)
5617 {
5618 log_error ("ERROR: Invalid argument specified");
5619
5620 return (-1);
5621 }
5622
5623 /**
5624 * exit functions
5625 */
5626
5627 if (version)
5628 {
5629 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5630
5631 return (0);
5632 }
5633
5634 if (usage)
5635 {
5636 usage_big_print (PROGNAME);
5637
5638 return (0);
5639 }
5640
5641 /**
5642 * session needs to be set, always!
5643 */
5644
5645 if (session == NULL) session = (char *) PROGNAME;
5646
5647 /**
5648 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5649 */
5650
5651 char *exec_path = get_exec_path ();
5652
5653 #ifdef LINUX
5654
5655 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5656 char *resolved_exec_path = realpath (exec_path, NULL);
5657
5658 char *install_dir = get_install_dir (resolved_exec_path);
5659 char *profile_dir = NULL;
5660 char *session_dir = NULL;
5661 char *shared_dir = NULL;
5662
5663 if (strcmp (install_dir, resolved_install_folder) == 0)
5664 {
5665 struct passwd *pw = getpwuid (getuid ());
5666
5667 const char *homedir = pw->pw_dir;
5668
5669 profile_dir = get_profile_dir (homedir);
5670 session_dir = get_session_dir (profile_dir);
5671 shared_dir = strdup (SHARED_FOLDER);
5672
5673 mkdir (profile_dir, 0700);
5674 mkdir (session_dir, 0700);
5675 }
5676 else
5677 {
5678 profile_dir = install_dir;
5679 session_dir = install_dir;
5680 shared_dir = install_dir;
5681 }
5682
5683 myfree (resolved_install_folder);
5684 myfree (resolved_exec_path);
5685
5686 #else
5687
5688 char *install_dir = get_install_dir (exec_path);
5689 char *profile_dir = install_dir;
5690 char *session_dir = install_dir;
5691 char *shared_dir = install_dir;
5692
5693 #endif
5694
5695 data.install_dir = install_dir;
5696 data.profile_dir = profile_dir;
5697 data.session_dir = session_dir;
5698 data.shared_dir = shared_dir;
5699
5700 myfree (exec_path);
5701
5702 /**
5703 * kernel cache, we need to make sure folder exist
5704 */
5705
5706 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5707
5708 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5709
5710 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5711
5712 mkdir (kernels_folder, 0700);
5713
5714 myfree (kernels_folder);
5715
5716 /**
5717 * session
5718 */
5719
5720 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5721
5722 data.session = session;
5723
5724 char *eff_restore_file = (char *) mymalloc (session_size);
5725 char *new_restore_file = (char *) mymalloc (session_size);
5726
5727 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5728 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5729
5730 data.eff_restore_file = eff_restore_file;
5731 data.new_restore_file = new_restore_file;
5732
5733 if (((show == 1) || (left == 1)) && (restore == 1))
5734 {
5735 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5736 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5737
5738 return (-1);
5739 }
5740
5741 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5742 if ((show == 1) || (left == 1))
5743 {
5744 restore_disable = 1;
5745
5746 restore = 0;
5747 }
5748
5749 data.restore_disable = restore_disable;
5750
5751 restore_data_t *rd = init_restore (argc, argv);
5752
5753 data.rd = rd;
5754
5755 /**
5756 * restore file
5757 */
5758
5759 if (restore == 1)
5760 {
5761 read_restore (eff_restore_file, rd);
5762
5763 if (rd->version_bin < RESTORE_MIN)
5764 {
5765 log_error ("ERROR: Incompatible restore-file version");
5766
5767 return (-1);
5768 }
5769
5770 myargc = rd->argc;
5771 myargv = rd->argv;
5772
5773 #ifdef _POSIX
5774 rd->pid = getpid ();
5775 #elif _WIN
5776 rd->pid = GetCurrentProcessId ();
5777 #endif
5778 }
5779
5780 uint hash_mode_chgd = 0;
5781 uint runtime_chgd = 0;
5782 uint kernel_loops_chgd = 0;
5783 uint kernel_accel_chgd = 0;
5784 uint attack_mode_chgd = 0;
5785 uint outfile_format_chgd = 0;
5786 uint rp_gen_seed_chgd = 0;
5787 uint remove_timer_chgd = 0;
5788 uint increment_min_chgd = 0;
5789 uint increment_max_chgd = 0;
5790 uint workload_profile_chgd = 0;
5791 uint opencl_vector_width_chgd = 0;
5792
5793 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5794 uint gpu_temp_retain_chgd = 0;
5795 uint gpu_temp_abort_chgd = 0;
5796 #endif
5797
5798 optind = 1;
5799 optopt = 0;
5800 option_index = 0;
5801
5802 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5803 {
5804 switch (c)
5805 {
5806 //case IDX_HELP: usage = 1; break;
5807 //case IDX_VERSION: version = 1; break;
5808 //case IDX_RESTORE: restore = 1; break;
5809 case IDX_QUIET: quiet = 1; break;
5810 //case IDX_SHOW: show = 1; break;
5811 case IDX_SHOW: break;
5812 //case IDX_LEFT: left = 1; break;
5813 case IDX_LEFT: break;
5814 case IDX_USERNAME: username = 1; break;
5815 case IDX_REMOVE: remove = 1; break;
5816 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5817 remove_timer_chgd = 1; break;
5818 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5819 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5820 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5821 case IDX_DEBUG_FILE: debug_file = optarg; break;
5822 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5823 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5824 case IDX_FORCE: force = 1; break;
5825 case IDX_SKIP: skip = atoll (optarg); break;
5826 case IDX_LIMIT: limit = atoll (optarg); break;
5827 case IDX_KEYSPACE: keyspace = 1; break;
5828 case IDX_BENCHMARK: benchmark = 1; break;
5829 case IDX_BENCHMARK_REPEATS: benchmark_repeats = atoi (optarg); break;
5830 case IDX_RESTORE: break;
5831 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5832 case IDX_STATUS: status = 1; break;
5833 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5834 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5835 case IDX_LOOPBACK: loopback = 1; break;
5836 case IDX_WEAK_HASH_THRESHOLD:
5837 weak_hash_threshold = atoi (optarg); break;
5838 //case IDX_SESSION: session = optarg; break;
5839 case IDX_SESSION: break;
5840 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5841 hash_mode_chgd = 1; break;
5842 case IDX_RUNTIME: runtime = atoi (optarg);
5843 runtime_chgd = 1; break;
5844 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5845 attack_mode_chgd = 1; break;
5846 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5847 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5848 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5849 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5850 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5851 rp_gen_seed_chgd = 1; break;
5852 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5853 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5854 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5855 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5856 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5857 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5858 case IDX_OUTFILE: outfile = optarg; break;
5859 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5860 outfile_format_chgd = 1; break;
5861 case IDX_OUTFILE_AUTOHEX_DISABLE:
5862 outfile_autohex = 0; break;
5863 case IDX_OUTFILE_CHECK_TIMER:
5864 outfile_check_timer = atoi (optarg); break;
5865 case IDX_HEX_CHARSET: hex_charset = 1; break;
5866 case IDX_HEX_SALT: hex_salt = 1; break;
5867 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5868 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5869 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5870 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5871 case IDX_OPENCL_DEVICE_TYPES:
5872 opencl_device_types = optarg; break;
5873 case IDX_OPENCL_VECTOR_WIDTH:
5874 opencl_vector_width = atoi (optarg);
5875 opencl_vector_width_chgd = 1; break;
5876 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5877 workload_profile_chgd = 1; break;
5878 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5879 kernel_accel_chgd = 1; break;
5880 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5881 kernel_loops_chgd = 1; break;
5882 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5883 #ifdef HAVE_HWMON
5884 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5885 #ifdef HAVE_ADL
5886 gpu_temp_abort_chgd = 1;
5887 #endif
5888 break;
5889 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5890 #ifdef HAVE_ADL
5891 gpu_temp_retain_chgd = 1;
5892 #endif
5893 break;
5894 #ifdef HAVE_ADL
5895 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5896 #endif
5897 #endif // HAVE_HWMON
5898 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5899 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5900 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5901 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5902 case IDX_SEPARATOR: separator = optarg[0]; break;
5903 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5904 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5905 case IDX_INCREMENT: increment = 1; break;
5906 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5907 increment_min_chgd = 1; break;
5908 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5909 increment_max_chgd = 1; break;
5910 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5911 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5912 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5913 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5914
5915 default:
5916 log_error ("ERROR: Invalid argument specified");
5917 return (-1);
5918 }
5919 }
5920
5921 if (optopt != 0)
5922 {
5923 log_error ("ERROR: Invalid argument specified");
5924
5925 return (-1);
5926 }
5927
5928 /**
5929 * Inform user things getting started,
5930 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5931 * - we do not need to check algorithm_pos
5932 */
5933
5934 if (quiet == 0)
5935 {
5936 if (benchmark == 1)
5937 {
5938 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5939
5940 log_info ("");
5941 }
5942 else if (restore == 1)
5943 {
5944 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5945
5946 log_info ("");
5947 }
5948 else
5949 {
5950 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5951
5952 log_info ("");
5953 }
5954 }
5955
5956 /**
5957 * sanity check
5958 */
5959
5960 if (attack_mode > 7)
5961 {
5962 log_error ("ERROR: Invalid attack-mode specified");
5963
5964 return (-1);
5965 }
5966
5967 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5968 {
5969 log_error ("ERROR: Invalid runtime specified");
5970
5971 return (-1);
5972 }
5973
5974 if (hash_mode_chgd && hash_mode > 13400) // just added to remove compiler warnings for hash_mode_chgd
5975 {
5976 log_error ("ERROR: Invalid hash-type specified");
5977
5978 return (-1);
5979 }
5980
5981 // renamed hash modes
5982
5983 if (hash_mode_chgd)
5984 {
5985 int n = -1;
5986
5987 switch (hash_mode)
5988 {
5989 case 123: n = 124;
5990 break;
5991 }
5992
5993 if (n >= 0)
5994 {
5995 log_error ("Old -m specified, use -m %d instead", n);
5996
5997 return (-1);
5998 }
5999 }
6000
6001 if (username == 1)
6002 {
6003 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
6004 {
6005 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6006
6007 return (-1);
6008 }
6009 }
6010
6011 if (outfile_format > 16)
6012 {
6013 log_error ("ERROR: Invalid outfile-format specified");
6014
6015 return (-1);
6016 }
6017
6018 if (left == 1)
6019 {
6020 if (outfile_format_chgd == 1)
6021 {
6022 if (outfile_format > 1)
6023 {
6024 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6025
6026 return (-1);
6027 }
6028 }
6029 else
6030 {
6031 outfile_format = OUTFILE_FMT_HASH;
6032 }
6033 }
6034
6035 if (show == 1)
6036 {
6037 if (outfile_format_chgd == 1)
6038 {
6039 if ((outfile_format > 7) && (outfile_format < 16))
6040 {
6041 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6042
6043 return (-1);
6044 }
6045 }
6046 }
6047
6048 if (increment_min < INCREMENT_MIN)
6049 {
6050 log_error ("ERROR: Invalid increment-min specified");
6051
6052 return (-1);
6053 }
6054
6055 if (increment_max > INCREMENT_MAX)
6056 {
6057 log_error ("ERROR: Invalid increment-max specified");
6058
6059 return (-1);
6060 }
6061
6062 if (increment_min > increment_max)
6063 {
6064 log_error ("ERROR: Invalid increment-min specified");
6065
6066 return (-1);
6067 }
6068
6069 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6070 {
6071 log_error ("ERROR: increment is not allowed in attack-mode 0");
6072
6073 return (-1);
6074 }
6075
6076 if ((increment == 0) && (increment_min_chgd == 1))
6077 {
6078 log_error ("ERROR: increment-min is only supported together with increment switch");
6079
6080 return (-1);
6081 }
6082
6083 if ((increment == 0) && (increment_max_chgd == 1))
6084 {
6085 log_error ("ERROR: increment-max is only supported together with increment switch");
6086
6087 return (-1);
6088 }
6089
6090 if (rp_files_cnt && rp_gen)
6091 {
6092 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6093
6094 return (-1);
6095 }
6096
6097 if (rp_files_cnt || rp_gen)
6098 {
6099 if (attack_mode != ATTACK_MODE_STRAIGHT)
6100 {
6101 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6102
6103 return (-1);
6104 }
6105 }
6106
6107 if (rp_gen_func_min > rp_gen_func_max)
6108 {
6109 log_error ("ERROR: Invalid rp-gen-func-min specified");
6110
6111 return (-1);
6112 }
6113
6114 if (kernel_accel_chgd == 1)
6115 {
6116 if (kernel_accel < 1)
6117 {
6118 log_error ("ERROR: Invalid kernel-accel specified");
6119
6120 return (-1);
6121 }
6122
6123 if (kernel_accel > 1024)
6124 {
6125 log_error ("ERROR: Invalid kernel-accel specified");
6126
6127 return (-1);
6128 }
6129 }
6130
6131 if (kernel_loops_chgd == 1)
6132 {
6133 if (kernel_loops < 1)
6134 {
6135 log_error ("ERROR: Invalid kernel-loops specified");
6136
6137 return (-1);
6138 }
6139
6140 if (kernel_loops > 1024)
6141 {
6142 log_error ("ERROR: Invalid kernel-loops specified");
6143
6144 return (-1);
6145 }
6146 }
6147
6148 if ((workload_profile < 1) || (workload_profile > 3))
6149 {
6150 log_error ("ERROR: workload-profile %i not available", workload_profile);
6151
6152 return (-1);
6153 }
6154
6155 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6156 {
6157 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6158
6159 return (-1);
6160 }
6161
6162 if (show == 1 || left == 1)
6163 {
6164 attack_mode = ATTACK_MODE_NONE;
6165
6166 if (remove == 1)
6167 {
6168 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6169
6170 return (-1);
6171 }
6172
6173 if (potfile_disable == 1)
6174 {
6175 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6176
6177 return (-1);
6178 }
6179 }
6180
6181 uint attack_kern = ATTACK_KERN_NONE;
6182
6183 switch (attack_mode)
6184 {
6185 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6186 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6187 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6188 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6189 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6190 }
6191
6192 if (benchmark == 0)
6193 {
6194 if (keyspace == 1)
6195 {
6196 int num_additional_params = 1;
6197
6198 if (attack_kern == ATTACK_KERN_COMBI)
6199 {
6200 num_additional_params = 2;
6201 }
6202
6203 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6204
6205 if (keyspace_wordlist_specified == 0) optind--;
6206 }
6207
6208 if (attack_kern == ATTACK_KERN_NONE)
6209 {
6210 if ((optind + 1) != myargc)
6211 {
6212 usage_mini_print (myargv[0]);
6213
6214 return (-1);
6215 }
6216 }
6217 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6218 {
6219 if ((optind + 1) > myargc)
6220 {
6221 usage_mini_print (myargv[0]);
6222
6223 return (-1);
6224 }
6225 }
6226 else if (attack_kern == ATTACK_KERN_COMBI)
6227 {
6228 if ((optind + 3) != myargc)
6229 {
6230 usage_mini_print (myargv[0]);
6231
6232 return (-1);
6233 }
6234 }
6235 else if (attack_kern == ATTACK_KERN_BF)
6236 {
6237 if ((optind + 1) > myargc)
6238 {
6239 usage_mini_print (myargv[0]);
6240
6241 return (-1);
6242 }
6243 }
6244 else
6245 {
6246 usage_mini_print (myargv[0]);
6247
6248 return (-1);
6249 }
6250 }
6251 else
6252 {
6253 if (myargv[optind] != 0)
6254 {
6255 log_error ("ERROR: Invalid argument for benchmark mode specified");
6256
6257 return (-1);
6258 }
6259
6260 if (attack_mode_chgd == 1)
6261 {
6262 if (attack_mode != ATTACK_MODE_BF)
6263 {
6264 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6265
6266 return (-1);
6267 }
6268 }
6269 }
6270
6271 if (skip != 0 && limit != 0)
6272 {
6273 limit += skip;
6274 }
6275
6276 if (keyspace == 1)
6277 {
6278 if (show == 1)
6279 {
6280 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6281
6282 return (-1);
6283 }
6284 else if (left == 1)
6285 {
6286 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6287
6288 return (-1);
6289 }
6290
6291 potfile_disable = 1;
6292
6293 restore_disable = 1;
6294
6295 restore = 0;
6296
6297 weak_hash_threshold = 0;
6298
6299 quiet = 1;
6300 }
6301
6302 if (remove_timer_chgd == 1)
6303 {
6304 if (remove == 0)
6305 {
6306 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6307
6308 return (-1);
6309 }
6310
6311 if (remove_timer < 1)
6312 {
6313 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6314
6315 return (-1);
6316 }
6317 }
6318
6319 if (loopback == 1)
6320 {
6321 if (attack_mode == ATTACK_MODE_BF)
6322 {
6323 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6324
6325 return (-1);
6326 }
6327 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6328 {
6329 if ((rp_files_cnt == 0) && (rp_gen == 0))
6330 {
6331 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6332
6333 return (-1);
6334 }
6335 }
6336 }
6337
6338 if (debug_mode > 0)
6339 {
6340 if (attack_mode != ATTACK_MODE_STRAIGHT)
6341 {
6342 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6343
6344 return (-1);
6345 }
6346
6347 if ((rp_files_cnt == 0) && (rp_gen == 0))
6348 {
6349 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6350
6351 return (-1);
6352 }
6353 }
6354
6355 if (debug_mode > 4)
6356 {
6357 log_error ("ERROR: Invalid debug-mode specified");
6358
6359 return (-1);
6360 }
6361
6362 if (debug_file != NULL)
6363 {
6364 if (debug_mode < 1)
6365 {
6366 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6367
6368 return (-1);
6369 }
6370 }
6371
6372 if (induction_dir != NULL)
6373 {
6374 if (attack_mode == ATTACK_MODE_BF)
6375 {
6376 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6377
6378 return (-1);
6379 }
6380 }
6381
6382 if (attack_mode != ATTACK_MODE_STRAIGHT)
6383 {
6384 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6385 {
6386 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6387
6388 return (-1);
6389 }
6390
6391 weak_hash_threshold = 0;
6392 }
6393
6394 /**
6395 * induction directory
6396 */
6397
6398 char *induction_directory = NULL;
6399
6400 if (attack_mode != ATTACK_MODE_BF)
6401 {
6402 if (induction_dir == NULL)
6403 {
6404 induction_directory = (char *) mymalloc (session_size);
6405
6406 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6407
6408 // create induction folder if it does not already exist
6409
6410 if (keyspace == 0)
6411 {
6412 if (rmdir (induction_directory) == -1)
6413 {
6414 if (errno == ENOENT)
6415 {
6416 // good, we can ignore
6417 }
6418 else if (errno == ENOTEMPTY)
6419 {
6420 char *induction_directory_mv = (char *) mymalloc (session_size);
6421
6422 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6423
6424 if (rename (induction_directory, induction_directory_mv) != 0)
6425 {
6426 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6427
6428 return (-1);
6429 }
6430 }
6431 else
6432 {
6433 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6434
6435 return (-1);
6436 }
6437 }
6438
6439 if (mkdir (induction_directory, 0700) == -1)
6440 {
6441 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6442
6443 return (-1);
6444 }
6445 }
6446 }
6447 else
6448 {
6449 induction_directory = induction_dir;
6450 }
6451 }
6452
6453 data.induction_directory = induction_directory;
6454
6455 /**
6456 * loopback
6457 */
6458
6459 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6460
6461 char *loopback_file = (char *) mymalloc (loopback_size);
6462
6463 /**
6464 * tuning db
6465 */
6466
6467 char tuning_db_file[256] = { 0 };
6468
6469 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6470
6471 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6472
6473 /**
6474 * outfile-check directory
6475 */
6476
6477 char *outfile_check_directory = NULL;
6478
6479 if (outfile_check_dir == NULL)
6480 {
6481 outfile_check_directory = (char *) mymalloc (session_size);
6482
6483 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6484 }
6485 else
6486 {
6487 outfile_check_directory = outfile_check_dir;
6488 }
6489
6490 data.outfile_check_directory = outfile_check_directory;
6491
6492 if (keyspace == 0)
6493 {
6494 struct stat outfile_check_stat;
6495
6496 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6497 {
6498 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6499
6500 if (is_dir == 0)
6501 {
6502 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6503
6504 return (-1);
6505 }
6506 }
6507 else if (outfile_check_dir == NULL)
6508 {
6509 if (mkdir (outfile_check_directory, 0700) == -1)
6510 {
6511 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6512
6513 return (-1);
6514 }
6515 }
6516 }
6517
6518 /**
6519 * special other stuff
6520 */
6521
6522 if (hash_mode == 9710)
6523 {
6524 outfile_format = 5;
6525 outfile_format_chgd = 1;
6526 }
6527
6528 if (hash_mode == 9810)
6529 {
6530 outfile_format = 5;
6531 outfile_format_chgd = 1;
6532 }
6533
6534 if (hash_mode == 10410)
6535 {
6536 outfile_format = 5;
6537 outfile_format_chgd = 1;
6538 }
6539
6540 /**
6541 * store stuff
6542 */
6543
6544 data.hash_mode = hash_mode;
6545 data.restore = restore;
6546 data.restore_timer = restore_timer;
6547 data.restore_disable = restore_disable;
6548 data.status = status;
6549 data.status_timer = status_timer;
6550 data.status_automat = status_automat;
6551 data.loopback = loopback;
6552 data.runtime = runtime;
6553 data.remove = remove;
6554 data.remove_timer = remove_timer;
6555 data.debug_mode = debug_mode;
6556 data.debug_file = debug_file;
6557 data.username = username;
6558 data.quiet = quiet;
6559 data.outfile = outfile;
6560 data.outfile_format = outfile_format;
6561 data.outfile_autohex = outfile_autohex;
6562 data.hex_charset = hex_charset;
6563 data.hex_salt = hex_salt;
6564 data.hex_wordlist = hex_wordlist;
6565 data.separator = separator;
6566 data.rp_files = rp_files;
6567 data.rp_files_cnt = rp_files_cnt;
6568 data.rp_gen = rp_gen;
6569 data.rp_gen_seed = rp_gen_seed;
6570 data.force = force;
6571 data.benchmark = benchmark;
6572 data.benchmark_repeats = benchmark_repeats;
6573 data.skip = skip;
6574 data.limit = limit;
6575 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6576 data.powertune_enable = powertune_enable;
6577 #endif
6578 data.logfile_disable = logfile_disable;
6579 data.truecrypt_keyfiles = truecrypt_keyfiles;
6580 data.scrypt_tmto = scrypt_tmto;
6581 data.workload_profile = workload_profile;
6582
6583 /**
6584 * cpu affinity
6585 */
6586
6587 if (cpu_affinity)
6588 {
6589 set_cpu_affinity (cpu_affinity);
6590 }
6591
6592 if (rp_gen_seed_chgd == 0)
6593 {
6594 srand (proc_start);
6595 }
6596 else
6597 {
6598 srand (rp_gen_seed);
6599 }
6600
6601 /**
6602 * logfile init
6603 */
6604
6605 if (logfile_disable == 0)
6606 {
6607 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6608
6609 char *logfile = (char *) mymalloc (logfile_size);
6610
6611 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6612
6613 data.logfile = logfile;
6614
6615 char *topid = logfile_generate_topid ();
6616
6617 data.topid = topid;
6618 }
6619
6620 // logfile_append() checks for logfile_disable internally to make it easier from here
6621
6622 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6623 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6624 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6625 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6626 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6627 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6628 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6629 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6630 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6631 #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));
6632
6633 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6634 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6635 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6636 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6637 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6638 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6639 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6640 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6641
6642 logfile_top_msg ("START");
6643
6644 logfile_top_uint (attack_mode);
6645 logfile_top_uint (attack_kern);
6646 logfile_top_uint (benchmark);
6647 logfile_top_uint (benchmark_repeats);
6648 logfile_top_uint (bitmap_min);
6649 logfile_top_uint (bitmap_max);
6650 logfile_top_uint (debug_mode);
6651 logfile_top_uint (force);
6652 logfile_top_uint (kernel_accel);
6653 logfile_top_uint (kernel_loops);
6654 logfile_top_uint (gpu_temp_disable);
6655 #ifdef HAVE_HWMON
6656 logfile_top_uint (gpu_temp_abort);
6657 logfile_top_uint (gpu_temp_retain);
6658 #endif
6659 logfile_top_uint (hash_mode);
6660 logfile_top_uint (hex_charset);
6661 logfile_top_uint (hex_salt);
6662 logfile_top_uint (hex_wordlist);
6663 logfile_top_uint (increment);
6664 logfile_top_uint (increment_max);
6665 logfile_top_uint (increment_min);
6666 logfile_top_uint (keyspace);
6667 logfile_top_uint (left);
6668 logfile_top_uint (logfile_disable);
6669 logfile_top_uint (loopback);
6670 logfile_top_uint (markov_classic);
6671 logfile_top_uint (markov_disable);
6672 logfile_top_uint (markov_threshold);
6673 logfile_top_uint (outfile_autohex);
6674 logfile_top_uint (outfile_check_timer);
6675 logfile_top_uint (outfile_format);
6676 logfile_top_uint (potfile_disable);
6677 logfile_top_string (potfile_path);
6678 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6679 logfile_top_uint (powertune_enable);
6680 #endif
6681 logfile_top_uint (scrypt_tmto);
6682 logfile_top_uint (quiet);
6683 logfile_top_uint (remove);
6684 logfile_top_uint (remove_timer);
6685 logfile_top_uint (restore);
6686 logfile_top_uint (restore_disable);
6687 logfile_top_uint (restore_timer);
6688 logfile_top_uint (rp_gen);
6689 logfile_top_uint (rp_gen_func_max);
6690 logfile_top_uint (rp_gen_func_min);
6691 logfile_top_uint (rp_gen_seed);
6692 logfile_top_uint (runtime);
6693 logfile_top_uint (segment_size);
6694 logfile_top_uint (show);
6695 logfile_top_uint (status);
6696 logfile_top_uint (status_automat);
6697 logfile_top_uint (status_timer);
6698 logfile_top_uint (usage);
6699 logfile_top_uint (username);
6700 logfile_top_uint (version);
6701 logfile_top_uint (weak_hash_threshold);
6702 logfile_top_uint (workload_profile);
6703 logfile_top_uint64 (limit);
6704 logfile_top_uint64 (skip);
6705 logfile_top_char (separator);
6706 logfile_top_string (cpu_affinity);
6707 logfile_top_string (custom_charset_1);
6708 logfile_top_string (custom_charset_2);
6709 logfile_top_string (custom_charset_3);
6710 logfile_top_string (custom_charset_4);
6711 logfile_top_string (debug_file);
6712 logfile_top_string (opencl_devices);
6713 logfile_top_string (opencl_platforms);
6714 logfile_top_string (opencl_device_types);
6715 logfile_top_uint (opencl_vector_width);
6716 logfile_top_string (induction_dir);
6717 logfile_top_string (markov_hcstat);
6718 logfile_top_string (outfile);
6719 logfile_top_string (outfile_check_dir);
6720 logfile_top_string (rule_buf_l);
6721 logfile_top_string (rule_buf_r);
6722 logfile_top_string (session);
6723 logfile_top_string (truecrypt_keyfiles);
6724
6725 /**
6726 * Init OpenCL library loader
6727 */
6728
6729 if (keyspace == 0)
6730 {
6731 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6732
6733 ocl_init (ocl);
6734
6735 data.ocl = ocl;
6736 }
6737
6738 /**
6739 * OpenCL platform selection
6740 */
6741
6742 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6743
6744 /**
6745 * OpenCL device selection
6746 */
6747
6748 u32 devices_filter = setup_devices_filter (opencl_devices);
6749
6750 /**
6751 * OpenCL device type selection
6752 */
6753
6754 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6755
6756 /**
6757 * benchmark
6758 */
6759
6760 if (benchmark == 1)
6761 {
6762 /**
6763 * disable useless stuff for benchmark
6764 */
6765
6766 status_timer = 0;
6767 restore_timer = 0;
6768 restore_disable = 1;
6769 potfile_disable = 1;
6770 weak_hash_threshold = 0;
6771 gpu_temp_disable = 1;
6772
6773 data.status_timer = status_timer;
6774 data.restore_timer = restore_timer;
6775 data.restore_disable = restore_disable;
6776
6777 /**
6778 * force attack mode to be bruteforce
6779 */
6780
6781 attack_mode = ATTACK_MODE_BF;
6782 attack_kern = ATTACK_KERN_BF;
6783
6784 if (workload_profile_chgd == 0)
6785 {
6786 workload_profile = 3;
6787
6788 data.workload_profile = workload_profile;
6789 }
6790 }
6791
6792 /**
6793 * config
6794 */
6795
6796 uint hash_type = 0;
6797 uint salt_type = 0;
6798 uint attack_exec = 0;
6799 uint opts_type = 0;
6800 uint kern_type = 0;
6801 uint dgst_size = 0;
6802 uint esalt_size = 0;
6803 uint opti_type = 0;
6804 uint dgst_pos0 = -1;
6805 uint dgst_pos1 = -1;
6806 uint dgst_pos2 = -1;
6807 uint dgst_pos3 = -1;
6808
6809 int (*parse_func) (char *, uint, hash_t *);
6810 int (*sort_by_digest) (const void *, const void *);
6811
6812 uint algorithm_pos = 0;
6813 uint algorithm_max = 1;
6814
6815 uint *algorithms = default_benchmark_algorithms;
6816
6817 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6818
6819 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6820 {
6821 /*
6822 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6823 * the following algos are skipped entirely
6824 */
6825
6826 if (algorithm_pos > 0)
6827 {
6828 local_free (rd);
6829
6830 rd = init_restore (argc, argv);
6831
6832 data.rd = rd;
6833 }
6834
6835 /**
6836 * update hash_mode in case of multihash benchmark
6837 */
6838
6839 if (benchmark == 1)
6840 {
6841 if (hash_mode_chgd == 0)
6842 {
6843 hash_mode = algorithms[algorithm_pos];
6844
6845 data.hash_mode = hash_mode;
6846 }
6847
6848 quiet = 1;
6849
6850 data.quiet = quiet;
6851 }
6852
6853 switch (hash_mode)
6854 {
6855 case 0: hash_type = HASH_TYPE_MD5;
6856 salt_type = SALT_TYPE_NONE;
6857 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6858 opts_type = OPTS_TYPE_PT_GENERATE_LE
6859 | OPTS_TYPE_PT_ADD80
6860 | OPTS_TYPE_PT_ADDBITS14;
6861 kern_type = KERN_TYPE_MD5;
6862 dgst_size = DGST_SIZE_4_4;
6863 parse_func = md5_parse_hash;
6864 sort_by_digest = sort_by_digest_4_4;
6865 opti_type = OPTI_TYPE_ZERO_BYTE
6866 | OPTI_TYPE_PRECOMPUTE_INIT
6867 | OPTI_TYPE_PRECOMPUTE_MERKLE
6868 | OPTI_TYPE_MEET_IN_MIDDLE
6869 | OPTI_TYPE_EARLY_SKIP
6870 | OPTI_TYPE_NOT_ITERATED
6871 | OPTI_TYPE_NOT_SALTED
6872 | OPTI_TYPE_RAW_HASH;
6873 dgst_pos0 = 0;
6874 dgst_pos1 = 3;
6875 dgst_pos2 = 2;
6876 dgst_pos3 = 1;
6877 break;
6878
6879 case 10: hash_type = HASH_TYPE_MD5;
6880 salt_type = SALT_TYPE_INTERN;
6881 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6882 opts_type = OPTS_TYPE_PT_GENERATE_LE
6883 | OPTS_TYPE_ST_ADD80
6884 | OPTS_TYPE_ST_ADDBITS14;
6885 kern_type = KERN_TYPE_MD5_PWSLT;
6886 dgst_size = DGST_SIZE_4_4;
6887 parse_func = md5s_parse_hash;
6888 sort_by_digest = sort_by_digest_4_4;
6889 opti_type = OPTI_TYPE_ZERO_BYTE
6890 | OPTI_TYPE_PRECOMPUTE_INIT
6891 | OPTI_TYPE_PRECOMPUTE_MERKLE
6892 | OPTI_TYPE_MEET_IN_MIDDLE
6893 | OPTI_TYPE_EARLY_SKIP
6894 | OPTI_TYPE_NOT_ITERATED
6895 | OPTI_TYPE_APPENDED_SALT
6896 | OPTI_TYPE_RAW_HASH;
6897 dgst_pos0 = 0;
6898 dgst_pos1 = 3;
6899 dgst_pos2 = 2;
6900 dgst_pos3 = 1;
6901 break;
6902
6903 case 11: hash_type = HASH_TYPE_MD5;
6904 salt_type = SALT_TYPE_INTERN;
6905 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6906 opts_type = OPTS_TYPE_PT_GENERATE_LE
6907 | OPTS_TYPE_ST_ADD80
6908 | OPTS_TYPE_ST_ADDBITS14;
6909 kern_type = KERN_TYPE_MD5_PWSLT;
6910 dgst_size = DGST_SIZE_4_4;
6911 parse_func = joomla_parse_hash;
6912 sort_by_digest = sort_by_digest_4_4;
6913 opti_type = OPTI_TYPE_ZERO_BYTE
6914 | OPTI_TYPE_PRECOMPUTE_INIT
6915 | OPTI_TYPE_PRECOMPUTE_MERKLE
6916 | OPTI_TYPE_MEET_IN_MIDDLE
6917 | OPTI_TYPE_EARLY_SKIP
6918 | OPTI_TYPE_NOT_ITERATED
6919 | OPTI_TYPE_APPENDED_SALT
6920 | OPTI_TYPE_RAW_HASH;
6921 dgst_pos0 = 0;
6922 dgst_pos1 = 3;
6923 dgst_pos2 = 2;
6924 dgst_pos3 = 1;
6925 break;
6926
6927 case 12: hash_type = HASH_TYPE_MD5;
6928 salt_type = SALT_TYPE_INTERN;
6929 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6930 opts_type = OPTS_TYPE_PT_GENERATE_LE
6931 | OPTS_TYPE_ST_ADD80
6932 | OPTS_TYPE_ST_ADDBITS14;
6933 kern_type = KERN_TYPE_MD5_PWSLT;
6934 dgst_size = DGST_SIZE_4_4;
6935 parse_func = postgresql_parse_hash;
6936 sort_by_digest = sort_by_digest_4_4;
6937 opti_type = OPTI_TYPE_ZERO_BYTE
6938 | OPTI_TYPE_PRECOMPUTE_INIT
6939 | OPTI_TYPE_PRECOMPUTE_MERKLE
6940 | OPTI_TYPE_MEET_IN_MIDDLE
6941 | OPTI_TYPE_EARLY_SKIP
6942 | OPTI_TYPE_NOT_ITERATED
6943 | OPTI_TYPE_APPENDED_SALT
6944 | OPTI_TYPE_RAW_HASH;
6945 dgst_pos0 = 0;
6946 dgst_pos1 = 3;
6947 dgst_pos2 = 2;
6948 dgst_pos3 = 1;
6949 break;
6950
6951 case 20: hash_type = HASH_TYPE_MD5;
6952 salt_type = SALT_TYPE_INTERN;
6953 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6954 opts_type = OPTS_TYPE_PT_GENERATE_LE
6955 | OPTS_TYPE_PT_ADD80
6956 | OPTS_TYPE_PT_ADDBITS14;
6957 kern_type = KERN_TYPE_MD5_SLTPW;
6958 dgst_size = DGST_SIZE_4_4;
6959 parse_func = md5s_parse_hash;
6960 sort_by_digest = sort_by_digest_4_4;
6961 opti_type = OPTI_TYPE_ZERO_BYTE
6962 | OPTI_TYPE_PRECOMPUTE_INIT
6963 | OPTI_TYPE_PRECOMPUTE_MERKLE
6964 | OPTI_TYPE_EARLY_SKIP
6965 | OPTI_TYPE_NOT_ITERATED
6966 | OPTI_TYPE_PREPENDED_SALT
6967 | OPTI_TYPE_RAW_HASH;
6968 dgst_pos0 = 0;
6969 dgst_pos1 = 3;
6970 dgst_pos2 = 2;
6971 dgst_pos3 = 1;
6972 break;
6973
6974 case 21: hash_type = HASH_TYPE_MD5;
6975 salt_type = SALT_TYPE_INTERN;
6976 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6977 opts_type = OPTS_TYPE_PT_GENERATE_LE
6978 | OPTS_TYPE_PT_ADD80
6979 | OPTS_TYPE_PT_ADDBITS14;
6980 kern_type = KERN_TYPE_MD5_SLTPW;
6981 dgst_size = DGST_SIZE_4_4;
6982 parse_func = osc_parse_hash;
6983 sort_by_digest = sort_by_digest_4_4;
6984 opti_type = OPTI_TYPE_ZERO_BYTE
6985 | OPTI_TYPE_PRECOMPUTE_INIT
6986 | OPTI_TYPE_PRECOMPUTE_MERKLE
6987 | OPTI_TYPE_EARLY_SKIP
6988 | OPTI_TYPE_NOT_ITERATED
6989 | OPTI_TYPE_PREPENDED_SALT
6990 | OPTI_TYPE_RAW_HASH;
6991 dgst_pos0 = 0;
6992 dgst_pos1 = 3;
6993 dgst_pos2 = 2;
6994 dgst_pos3 = 1;
6995 break;
6996
6997 case 22: hash_type = HASH_TYPE_MD5;
6998 salt_type = SALT_TYPE_EMBEDDED;
6999 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7000 opts_type = OPTS_TYPE_PT_GENERATE_LE
7001 | OPTS_TYPE_PT_ADD80
7002 | OPTS_TYPE_PT_ADDBITS14;
7003 kern_type = KERN_TYPE_MD5_SLTPW;
7004 dgst_size = DGST_SIZE_4_4;
7005 parse_func = netscreen_parse_hash;
7006 sort_by_digest = sort_by_digest_4_4;
7007 opti_type = OPTI_TYPE_ZERO_BYTE
7008 | OPTI_TYPE_PRECOMPUTE_INIT
7009 | OPTI_TYPE_PRECOMPUTE_MERKLE
7010 | OPTI_TYPE_EARLY_SKIP
7011 | OPTI_TYPE_NOT_ITERATED
7012 | OPTI_TYPE_PREPENDED_SALT
7013 | OPTI_TYPE_RAW_HASH;
7014 dgst_pos0 = 0;
7015 dgst_pos1 = 3;
7016 dgst_pos2 = 2;
7017 dgst_pos3 = 1;
7018 break;
7019
7020 case 23: hash_type = HASH_TYPE_MD5;
7021 salt_type = SALT_TYPE_EMBEDDED;
7022 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7023 opts_type = OPTS_TYPE_PT_GENERATE_LE
7024 | OPTS_TYPE_PT_ADD80
7025 | OPTS_TYPE_PT_ADDBITS14;
7026 kern_type = KERN_TYPE_MD5_SLTPW;
7027 dgst_size = DGST_SIZE_4_4;
7028 parse_func = skype_parse_hash;
7029 sort_by_digest = sort_by_digest_4_4;
7030 opti_type = OPTI_TYPE_ZERO_BYTE
7031 | OPTI_TYPE_PRECOMPUTE_INIT
7032 | OPTI_TYPE_PRECOMPUTE_MERKLE
7033 | OPTI_TYPE_EARLY_SKIP
7034 | OPTI_TYPE_NOT_ITERATED
7035 | OPTI_TYPE_PREPENDED_SALT
7036 | OPTI_TYPE_RAW_HASH;
7037 dgst_pos0 = 0;
7038 dgst_pos1 = 3;
7039 dgst_pos2 = 2;
7040 dgst_pos3 = 1;
7041 break;
7042
7043 case 30: hash_type = HASH_TYPE_MD5;
7044 salt_type = SALT_TYPE_INTERN;
7045 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7046 opts_type = OPTS_TYPE_PT_GENERATE_LE
7047 | OPTS_TYPE_PT_UNICODE
7048 | OPTS_TYPE_ST_ADD80
7049 | OPTS_TYPE_ST_ADDBITS14;
7050 kern_type = KERN_TYPE_MD5_PWUSLT;
7051 dgst_size = DGST_SIZE_4_4;
7052 parse_func = md5s_parse_hash;
7053 sort_by_digest = sort_by_digest_4_4;
7054 opti_type = OPTI_TYPE_ZERO_BYTE
7055 | OPTI_TYPE_PRECOMPUTE_INIT
7056 | OPTI_TYPE_PRECOMPUTE_MERKLE
7057 | OPTI_TYPE_MEET_IN_MIDDLE
7058 | OPTI_TYPE_EARLY_SKIP
7059 | OPTI_TYPE_NOT_ITERATED
7060 | OPTI_TYPE_APPENDED_SALT
7061 | OPTI_TYPE_RAW_HASH;
7062 dgst_pos0 = 0;
7063 dgst_pos1 = 3;
7064 dgst_pos2 = 2;
7065 dgst_pos3 = 1;
7066 break;
7067
7068 case 40: hash_type = HASH_TYPE_MD5;
7069 salt_type = SALT_TYPE_INTERN;
7070 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7071 opts_type = OPTS_TYPE_PT_GENERATE_LE
7072 | OPTS_TYPE_PT_ADD80
7073 | OPTS_TYPE_PT_ADDBITS14
7074 | OPTS_TYPE_PT_UNICODE;
7075 kern_type = KERN_TYPE_MD5_SLTPWU;
7076 dgst_size = DGST_SIZE_4_4;
7077 parse_func = md5s_parse_hash;
7078 sort_by_digest = sort_by_digest_4_4;
7079 opti_type = OPTI_TYPE_ZERO_BYTE
7080 | OPTI_TYPE_PRECOMPUTE_INIT
7081 | OPTI_TYPE_PRECOMPUTE_MERKLE
7082 | OPTI_TYPE_EARLY_SKIP
7083 | OPTI_TYPE_NOT_ITERATED
7084 | OPTI_TYPE_PREPENDED_SALT
7085 | OPTI_TYPE_RAW_HASH;
7086 dgst_pos0 = 0;
7087 dgst_pos1 = 3;
7088 dgst_pos2 = 2;
7089 dgst_pos3 = 1;
7090 break;
7091
7092 case 50: hash_type = HASH_TYPE_MD5;
7093 salt_type = SALT_TYPE_INTERN;
7094 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7095 opts_type = OPTS_TYPE_PT_GENERATE_LE
7096 | OPTS_TYPE_ST_ADD80
7097 | OPTS_TYPE_ST_ADDBITS14;
7098 kern_type = KERN_TYPE_HMACMD5_PW;
7099 dgst_size = DGST_SIZE_4_4;
7100 parse_func = hmacmd5_parse_hash;
7101 sort_by_digest = sort_by_digest_4_4;
7102 opti_type = OPTI_TYPE_ZERO_BYTE
7103 | OPTI_TYPE_NOT_ITERATED;
7104 dgst_pos0 = 0;
7105 dgst_pos1 = 3;
7106 dgst_pos2 = 2;
7107 dgst_pos3 = 1;
7108 break;
7109
7110 case 60: hash_type = HASH_TYPE_MD5;
7111 salt_type = SALT_TYPE_INTERN;
7112 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7113 opts_type = OPTS_TYPE_PT_GENERATE_LE
7114 | OPTS_TYPE_PT_ADD80
7115 | OPTS_TYPE_PT_ADDBITS14;
7116 kern_type = KERN_TYPE_HMACMD5_SLT;
7117 dgst_size = DGST_SIZE_4_4;
7118 parse_func = hmacmd5_parse_hash;
7119 sort_by_digest = sort_by_digest_4_4;
7120 opti_type = OPTI_TYPE_ZERO_BYTE
7121 | OPTI_TYPE_NOT_ITERATED;
7122 dgst_pos0 = 0;
7123 dgst_pos1 = 3;
7124 dgst_pos2 = 2;
7125 dgst_pos3 = 1;
7126 break;
7127
7128 case 100: hash_type = HASH_TYPE_SHA1;
7129 salt_type = SALT_TYPE_NONE;
7130 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7131 opts_type = OPTS_TYPE_PT_GENERATE_BE
7132 | OPTS_TYPE_PT_ADD80
7133 | OPTS_TYPE_PT_ADDBITS15;
7134 kern_type = KERN_TYPE_SHA1;
7135 dgst_size = DGST_SIZE_4_5;
7136 parse_func = sha1_parse_hash;
7137 sort_by_digest = sort_by_digest_4_5;
7138 opti_type = OPTI_TYPE_ZERO_BYTE
7139 | OPTI_TYPE_PRECOMPUTE_INIT
7140 | OPTI_TYPE_PRECOMPUTE_MERKLE
7141 | OPTI_TYPE_EARLY_SKIP
7142 | OPTI_TYPE_NOT_ITERATED
7143 | OPTI_TYPE_NOT_SALTED
7144 | OPTI_TYPE_RAW_HASH;
7145 dgst_pos0 = 3;
7146 dgst_pos1 = 4;
7147 dgst_pos2 = 2;
7148 dgst_pos3 = 1;
7149 break;
7150
7151 case 101: hash_type = HASH_TYPE_SHA1;
7152 salt_type = SALT_TYPE_NONE;
7153 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7154 opts_type = OPTS_TYPE_PT_GENERATE_BE
7155 | OPTS_TYPE_PT_ADD80
7156 | OPTS_TYPE_PT_ADDBITS15;
7157 kern_type = KERN_TYPE_SHA1;
7158 dgst_size = DGST_SIZE_4_5;
7159 parse_func = sha1b64_parse_hash;
7160 sort_by_digest = sort_by_digest_4_5;
7161 opti_type = OPTI_TYPE_ZERO_BYTE
7162 | OPTI_TYPE_PRECOMPUTE_INIT
7163 | OPTI_TYPE_PRECOMPUTE_MERKLE
7164 | OPTI_TYPE_EARLY_SKIP
7165 | OPTI_TYPE_NOT_ITERATED
7166 | OPTI_TYPE_NOT_SALTED
7167 | OPTI_TYPE_RAW_HASH;
7168 dgst_pos0 = 3;
7169 dgst_pos1 = 4;
7170 dgst_pos2 = 2;
7171 dgst_pos3 = 1;
7172 break;
7173
7174 case 110: hash_type = HASH_TYPE_SHA1;
7175 salt_type = SALT_TYPE_INTERN;
7176 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7177 opts_type = OPTS_TYPE_PT_GENERATE_BE
7178 | OPTS_TYPE_ST_ADD80
7179 | OPTS_TYPE_ST_ADDBITS15;
7180 kern_type = KERN_TYPE_SHA1_PWSLT;
7181 dgst_size = DGST_SIZE_4_5;
7182 parse_func = sha1s_parse_hash;
7183 sort_by_digest = sort_by_digest_4_5;
7184 opti_type = OPTI_TYPE_ZERO_BYTE
7185 | OPTI_TYPE_PRECOMPUTE_INIT
7186 | OPTI_TYPE_PRECOMPUTE_MERKLE
7187 | OPTI_TYPE_EARLY_SKIP
7188 | OPTI_TYPE_NOT_ITERATED
7189 | OPTI_TYPE_APPENDED_SALT
7190 | OPTI_TYPE_RAW_HASH;
7191 dgst_pos0 = 3;
7192 dgst_pos1 = 4;
7193 dgst_pos2 = 2;
7194 dgst_pos3 = 1;
7195 break;
7196
7197 case 111: hash_type = HASH_TYPE_SHA1;
7198 salt_type = SALT_TYPE_EMBEDDED;
7199 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7200 opts_type = OPTS_TYPE_PT_GENERATE_BE
7201 | OPTS_TYPE_ST_ADD80
7202 | OPTS_TYPE_ST_ADDBITS15;
7203 kern_type = KERN_TYPE_SHA1_PWSLT;
7204 dgst_size = DGST_SIZE_4_5;
7205 parse_func = sha1b64s_parse_hash;
7206 sort_by_digest = sort_by_digest_4_5;
7207 opti_type = OPTI_TYPE_ZERO_BYTE
7208 | OPTI_TYPE_PRECOMPUTE_INIT
7209 | OPTI_TYPE_PRECOMPUTE_MERKLE
7210 | OPTI_TYPE_EARLY_SKIP
7211 | OPTI_TYPE_NOT_ITERATED
7212 | OPTI_TYPE_APPENDED_SALT
7213 | OPTI_TYPE_RAW_HASH;
7214 dgst_pos0 = 3;
7215 dgst_pos1 = 4;
7216 dgst_pos2 = 2;
7217 dgst_pos3 = 1;
7218 break;
7219
7220 case 112: hash_type = HASH_TYPE_SHA1;
7221 salt_type = SALT_TYPE_INTERN;
7222 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7223 opts_type = OPTS_TYPE_PT_GENERATE_BE
7224 | OPTS_TYPE_ST_ADD80
7225 | OPTS_TYPE_ST_ADDBITS15
7226 | OPTS_TYPE_ST_HEX;
7227 kern_type = KERN_TYPE_SHA1_PWSLT;
7228 dgst_size = DGST_SIZE_4_5;
7229 parse_func = oracles_parse_hash;
7230 sort_by_digest = sort_by_digest_4_5;
7231 opti_type = OPTI_TYPE_ZERO_BYTE
7232 | OPTI_TYPE_PRECOMPUTE_INIT
7233 | OPTI_TYPE_PRECOMPUTE_MERKLE
7234 | OPTI_TYPE_EARLY_SKIP
7235 | OPTI_TYPE_NOT_ITERATED
7236 | OPTI_TYPE_APPENDED_SALT
7237 | OPTI_TYPE_RAW_HASH;
7238 dgst_pos0 = 3;
7239 dgst_pos1 = 4;
7240 dgst_pos2 = 2;
7241 dgst_pos3 = 1;
7242 break;
7243
7244 case 120: hash_type = HASH_TYPE_SHA1;
7245 salt_type = SALT_TYPE_INTERN;
7246 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7247 opts_type = OPTS_TYPE_PT_GENERATE_BE
7248 | OPTS_TYPE_PT_ADD80
7249 | OPTS_TYPE_PT_ADDBITS15;
7250 kern_type = KERN_TYPE_SHA1_SLTPW;
7251 dgst_size = DGST_SIZE_4_5;
7252 parse_func = sha1s_parse_hash;
7253 sort_by_digest = sort_by_digest_4_5;
7254 opti_type = OPTI_TYPE_ZERO_BYTE
7255 | OPTI_TYPE_PRECOMPUTE_INIT
7256 | OPTI_TYPE_PRECOMPUTE_MERKLE
7257 | OPTI_TYPE_EARLY_SKIP
7258 | OPTI_TYPE_NOT_ITERATED
7259 | OPTI_TYPE_PREPENDED_SALT
7260 | OPTI_TYPE_RAW_HASH;
7261 dgst_pos0 = 3;
7262 dgst_pos1 = 4;
7263 dgst_pos2 = 2;
7264 dgst_pos3 = 1;
7265 break;
7266
7267 case 121: hash_type = HASH_TYPE_SHA1;
7268 salt_type = SALT_TYPE_INTERN;
7269 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7270 opts_type = OPTS_TYPE_PT_GENERATE_BE
7271 | OPTS_TYPE_PT_ADD80
7272 | OPTS_TYPE_PT_ADDBITS15
7273 | OPTS_TYPE_ST_LOWER;
7274 kern_type = KERN_TYPE_SHA1_SLTPW;
7275 dgst_size = DGST_SIZE_4_5;
7276 parse_func = smf_parse_hash;
7277 sort_by_digest = sort_by_digest_4_5;
7278 opti_type = OPTI_TYPE_ZERO_BYTE
7279 | OPTI_TYPE_PRECOMPUTE_INIT
7280 | OPTI_TYPE_PRECOMPUTE_MERKLE
7281 | OPTI_TYPE_EARLY_SKIP
7282 | OPTI_TYPE_NOT_ITERATED
7283 | OPTI_TYPE_PREPENDED_SALT
7284 | OPTI_TYPE_RAW_HASH;
7285 dgst_pos0 = 3;
7286 dgst_pos1 = 4;
7287 dgst_pos2 = 2;
7288 dgst_pos3 = 1;
7289 break;
7290
7291 case 122: hash_type = HASH_TYPE_SHA1;
7292 salt_type = SALT_TYPE_EMBEDDED;
7293 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7294 opts_type = OPTS_TYPE_PT_GENERATE_BE
7295 | OPTS_TYPE_PT_ADD80
7296 | OPTS_TYPE_PT_ADDBITS15
7297 | OPTS_TYPE_ST_HEX;
7298 kern_type = KERN_TYPE_SHA1_SLTPW;
7299 dgst_size = DGST_SIZE_4_5;
7300 parse_func = osx1_parse_hash;
7301 sort_by_digest = sort_by_digest_4_5;
7302 opti_type = OPTI_TYPE_ZERO_BYTE
7303 | OPTI_TYPE_PRECOMPUTE_INIT
7304 | OPTI_TYPE_PRECOMPUTE_MERKLE
7305 | OPTI_TYPE_EARLY_SKIP
7306 | OPTI_TYPE_NOT_ITERATED
7307 | OPTI_TYPE_PREPENDED_SALT
7308 | OPTI_TYPE_RAW_HASH;
7309 dgst_pos0 = 3;
7310 dgst_pos1 = 4;
7311 dgst_pos2 = 2;
7312 dgst_pos3 = 1;
7313 break;
7314
7315 case 124: hash_type = HASH_TYPE_SHA1;
7316 salt_type = SALT_TYPE_EMBEDDED;
7317 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7318 opts_type = OPTS_TYPE_PT_GENERATE_BE
7319 | OPTS_TYPE_PT_ADD80
7320 | OPTS_TYPE_PT_ADDBITS15;
7321 kern_type = KERN_TYPE_SHA1_SLTPW;
7322 dgst_size = DGST_SIZE_4_5;
7323 parse_func = djangosha1_parse_hash;
7324 sort_by_digest = sort_by_digest_4_5;
7325 opti_type = OPTI_TYPE_ZERO_BYTE
7326 | OPTI_TYPE_PRECOMPUTE_INIT
7327 | OPTI_TYPE_PRECOMPUTE_MERKLE
7328 | OPTI_TYPE_EARLY_SKIP
7329 | OPTI_TYPE_NOT_ITERATED
7330 | OPTI_TYPE_PREPENDED_SALT
7331 | OPTI_TYPE_RAW_HASH;
7332 dgst_pos0 = 3;
7333 dgst_pos1 = 4;
7334 dgst_pos2 = 2;
7335 dgst_pos3 = 1;
7336 break;
7337
7338 case 125: hash_type = HASH_TYPE_SHA1;
7339 salt_type = SALT_TYPE_EMBEDDED;
7340 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7341 opts_type = OPTS_TYPE_PT_GENERATE_BE
7342 | OPTS_TYPE_PT_ADD80
7343 | OPTS_TYPE_PT_ADDBITS15
7344 | OPTS_TYPE_ST_HEX;
7345 kern_type = KERN_TYPE_SHA1_SLTPW;
7346 dgst_size = DGST_SIZE_4_5;
7347 parse_func = arubaos_parse_hash;
7348 sort_by_digest = sort_by_digest_4_5;
7349 opti_type = OPTI_TYPE_ZERO_BYTE
7350 | OPTI_TYPE_PRECOMPUTE_INIT
7351 | OPTI_TYPE_PRECOMPUTE_MERKLE
7352 | OPTI_TYPE_EARLY_SKIP
7353 | OPTI_TYPE_NOT_ITERATED
7354 | OPTI_TYPE_PREPENDED_SALT
7355 | OPTI_TYPE_RAW_HASH;
7356 dgst_pos0 = 3;
7357 dgst_pos1 = 4;
7358 dgst_pos2 = 2;
7359 dgst_pos3 = 1;
7360 break;
7361
7362 case 130: hash_type = HASH_TYPE_SHA1;
7363 salt_type = SALT_TYPE_INTERN;
7364 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7365 opts_type = OPTS_TYPE_PT_GENERATE_BE
7366 | OPTS_TYPE_PT_UNICODE
7367 | OPTS_TYPE_ST_ADD80
7368 | OPTS_TYPE_ST_ADDBITS15;
7369 kern_type = KERN_TYPE_SHA1_PWUSLT;
7370 dgst_size = DGST_SIZE_4_5;
7371 parse_func = sha1s_parse_hash;
7372 sort_by_digest = sort_by_digest_4_5;
7373 opti_type = OPTI_TYPE_ZERO_BYTE
7374 | OPTI_TYPE_PRECOMPUTE_INIT
7375 | OPTI_TYPE_PRECOMPUTE_MERKLE
7376 | OPTI_TYPE_EARLY_SKIP
7377 | OPTI_TYPE_NOT_ITERATED
7378 | OPTI_TYPE_APPENDED_SALT
7379 | OPTI_TYPE_RAW_HASH;
7380 dgst_pos0 = 3;
7381 dgst_pos1 = 4;
7382 dgst_pos2 = 2;
7383 dgst_pos3 = 1;
7384 break;
7385
7386 case 131: hash_type = HASH_TYPE_SHA1;
7387 salt_type = SALT_TYPE_EMBEDDED;
7388 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7389 opts_type = OPTS_TYPE_PT_GENERATE_BE
7390 | OPTS_TYPE_PT_UNICODE
7391 | OPTS_TYPE_PT_UPPER
7392 | OPTS_TYPE_ST_ADD80
7393 | OPTS_TYPE_ST_ADDBITS15
7394 | OPTS_TYPE_ST_HEX;
7395 kern_type = KERN_TYPE_SHA1_PWUSLT;
7396 dgst_size = DGST_SIZE_4_5;
7397 parse_func = mssql2000_parse_hash;
7398 sort_by_digest = sort_by_digest_4_5;
7399 opti_type = OPTI_TYPE_ZERO_BYTE
7400 | OPTI_TYPE_PRECOMPUTE_INIT
7401 | OPTI_TYPE_PRECOMPUTE_MERKLE
7402 | OPTI_TYPE_EARLY_SKIP
7403 | OPTI_TYPE_NOT_ITERATED
7404 | OPTI_TYPE_APPENDED_SALT
7405 | OPTI_TYPE_RAW_HASH;
7406 dgst_pos0 = 3;
7407 dgst_pos1 = 4;
7408 dgst_pos2 = 2;
7409 dgst_pos3 = 1;
7410 break;
7411
7412 case 132: hash_type = HASH_TYPE_SHA1;
7413 salt_type = SALT_TYPE_EMBEDDED;
7414 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7415 opts_type = OPTS_TYPE_PT_GENERATE_BE
7416 | OPTS_TYPE_PT_UNICODE
7417 | OPTS_TYPE_ST_ADD80
7418 | OPTS_TYPE_ST_ADDBITS15
7419 | OPTS_TYPE_ST_HEX;
7420 kern_type = KERN_TYPE_SHA1_PWUSLT;
7421 dgst_size = DGST_SIZE_4_5;
7422 parse_func = mssql2005_parse_hash;
7423 sort_by_digest = sort_by_digest_4_5;
7424 opti_type = OPTI_TYPE_ZERO_BYTE
7425 | OPTI_TYPE_PRECOMPUTE_INIT
7426 | OPTI_TYPE_PRECOMPUTE_MERKLE
7427 | OPTI_TYPE_EARLY_SKIP
7428 | OPTI_TYPE_NOT_ITERATED
7429 | OPTI_TYPE_APPENDED_SALT
7430 | OPTI_TYPE_RAW_HASH;
7431 dgst_pos0 = 3;
7432 dgst_pos1 = 4;
7433 dgst_pos2 = 2;
7434 dgst_pos3 = 1;
7435 break;
7436
7437 case 133: hash_type = HASH_TYPE_SHA1;
7438 salt_type = SALT_TYPE_EMBEDDED;
7439 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7440 opts_type = OPTS_TYPE_PT_GENERATE_BE
7441 | OPTS_TYPE_PT_UNICODE
7442 | OPTS_TYPE_ST_ADD80
7443 | OPTS_TYPE_ST_ADDBITS15;
7444 kern_type = KERN_TYPE_SHA1_PWUSLT;
7445 dgst_size = DGST_SIZE_4_5;
7446 parse_func = peoplesoft_parse_hash;
7447 sort_by_digest = sort_by_digest_4_5;
7448 opti_type = OPTI_TYPE_ZERO_BYTE
7449 | OPTI_TYPE_PRECOMPUTE_INIT
7450 | OPTI_TYPE_PRECOMPUTE_MERKLE
7451 | OPTI_TYPE_EARLY_SKIP
7452 | OPTI_TYPE_NOT_ITERATED
7453 | OPTI_TYPE_APPENDED_SALT
7454 | OPTI_TYPE_RAW_HASH;
7455 dgst_pos0 = 3;
7456 dgst_pos1 = 4;
7457 dgst_pos2 = 2;
7458 dgst_pos3 = 1;
7459 break;
7460
7461 case 140: hash_type = HASH_TYPE_SHA1;
7462 salt_type = SALT_TYPE_INTERN;
7463 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7464 opts_type = OPTS_TYPE_PT_GENERATE_BE
7465 | OPTS_TYPE_PT_ADD80
7466 | OPTS_TYPE_PT_ADDBITS15
7467 | OPTS_TYPE_PT_UNICODE;
7468 kern_type = KERN_TYPE_SHA1_SLTPWU;
7469 dgst_size = DGST_SIZE_4_5;
7470 parse_func = sha1s_parse_hash;
7471 sort_by_digest = sort_by_digest_4_5;
7472 opti_type = OPTI_TYPE_ZERO_BYTE
7473 | OPTI_TYPE_PRECOMPUTE_INIT
7474 | OPTI_TYPE_PRECOMPUTE_MERKLE
7475 | OPTI_TYPE_EARLY_SKIP
7476 | OPTI_TYPE_NOT_ITERATED
7477 | OPTI_TYPE_PREPENDED_SALT
7478 | OPTI_TYPE_RAW_HASH;
7479 dgst_pos0 = 3;
7480 dgst_pos1 = 4;
7481 dgst_pos2 = 2;
7482 dgst_pos3 = 1;
7483 break;
7484
7485 case 141: hash_type = HASH_TYPE_SHA1;
7486 salt_type = SALT_TYPE_EMBEDDED;
7487 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7488 opts_type = OPTS_TYPE_PT_GENERATE_BE
7489 | OPTS_TYPE_PT_ADD80
7490 | OPTS_TYPE_PT_ADDBITS15
7491 | OPTS_TYPE_PT_UNICODE
7492 | OPTS_TYPE_ST_BASE64;
7493 kern_type = KERN_TYPE_SHA1_SLTPWU;
7494 dgst_size = DGST_SIZE_4_5;
7495 parse_func = episerver_parse_hash;
7496 sort_by_digest = sort_by_digest_4_5;
7497 opti_type = OPTI_TYPE_ZERO_BYTE
7498 | OPTI_TYPE_PRECOMPUTE_INIT
7499 | OPTI_TYPE_PRECOMPUTE_MERKLE
7500 | OPTI_TYPE_EARLY_SKIP
7501 | OPTI_TYPE_NOT_ITERATED
7502 | OPTI_TYPE_PREPENDED_SALT
7503 | OPTI_TYPE_RAW_HASH;
7504 dgst_pos0 = 3;
7505 dgst_pos1 = 4;
7506 dgst_pos2 = 2;
7507 dgst_pos3 = 1;
7508 break;
7509
7510 case 150: hash_type = HASH_TYPE_SHA1;
7511 salt_type = SALT_TYPE_INTERN;
7512 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7513 opts_type = OPTS_TYPE_PT_GENERATE_BE
7514 | OPTS_TYPE_ST_ADD80
7515 | OPTS_TYPE_ST_ADDBITS15;
7516 kern_type = KERN_TYPE_HMACSHA1_PW;
7517 dgst_size = DGST_SIZE_4_5;
7518 parse_func = hmacsha1_parse_hash;
7519 sort_by_digest = sort_by_digest_4_5;
7520 opti_type = OPTI_TYPE_ZERO_BYTE
7521 | OPTI_TYPE_NOT_ITERATED;
7522 dgst_pos0 = 3;
7523 dgst_pos1 = 4;
7524 dgst_pos2 = 2;
7525 dgst_pos3 = 1;
7526 break;
7527
7528 case 160: hash_type = HASH_TYPE_SHA1;
7529 salt_type = SALT_TYPE_INTERN;
7530 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7531 opts_type = OPTS_TYPE_PT_GENERATE_BE
7532 | OPTS_TYPE_PT_ADD80
7533 | OPTS_TYPE_PT_ADDBITS15;
7534 kern_type = KERN_TYPE_HMACSHA1_SLT;
7535 dgst_size = DGST_SIZE_4_5;
7536 parse_func = hmacsha1_parse_hash;
7537 sort_by_digest = sort_by_digest_4_5;
7538 opti_type = OPTI_TYPE_ZERO_BYTE
7539 | OPTI_TYPE_NOT_ITERATED;
7540 dgst_pos0 = 3;
7541 dgst_pos1 = 4;
7542 dgst_pos2 = 2;
7543 dgst_pos3 = 1;
7544 break;
7545
7546 case 190: hash_type = HASH_TYPE_SHA1;
7547 salt_type = SALT_TYPE_NONE;
7548 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7549 opts_type = OPTS_TYPE_PT_GENERATE_BE
7550 | OPTS_TYPE_PT_ADD80
7551 | OPTS_TYPE_PT_ADDBITS15;
7552 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7553 dgst_size = DGST_SIZE_4_5;
7554 parse_func = sha1linkedin_parse_hash;
7555 sort_by_digest = sort_by_digest_4_5;
7556 opti_type = OPTI_TYPE_ZERO_BYTE
7557 | OPTI_TYPE_PRECOMPUTE_INIT
7558 | OPTI_TYPE_EARLY_SKIP
7559 | OPTI_TYPE_NOT_ITERATED
7560 | OPTI_TYPE_NOT_SALTED;
7561 dgst_pos0 = 0;
7562 dgst_pos1 = 4;
7563 dgst_pos2 = 3;
7564 dgst_pos3 = 2;
7565 break;
7566
7567 case 200: hash_type = HASH_TYPE_MYSQL;
7568 salt_type = SALT_TYPE_NONE;
7569 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7570 opts_type = 0;
7571 kern_type = KERN_TYPE_MYSQL;
7572 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7573 parse_func = mysql323_parse_hash;
7574 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7575 opti_type = OPTI_TYPE_ZERO_BYTE;
7576 dgst_pos0 = 0;
7577 dgst_pos1 = 1;
7578 dgst_pos2 = 2;
7579 dgst_pos3 = 3;
7580 break;
7581
7582 case 300: hash_type = HASH_TYPE_SHA1;
7583 salt_type = SALT_TYPE_NONE;
7584 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7585 opts_type = OPTS_TYPE_PT_GENERATE_BE
7586 | OPTS_TYPE_PT_ADD80
7587 | OPTS_TYPE_PT_ADDBITS15;
7588 kern_type = KERN_TYPE_MYSQL41;
7589 dgst_size = DGST_SIZE_4_5;
7590 parse_func = sha1_parse_hash;
7591 sort_by_digest = sort_by_digest_4_5;
7592 opti_type = OPTI_TYPE_ZERO_BYTE
7593 | OPTI_TYPE_PRECOMPUTE_INIT
7594 | OPTI_TYPE_PRECOMPUTE_MERKLE
7595 | OPTI_TYPE_EARLY_SKIP
7596 | OPTI_TYPE_NOT_ITERATED
7597 | OPTI_TYPE_NOT_SALTED;
7598 dgst_pos0 = 3;
7599 dgst_pos1 = 4;
7600 dgst_pos2 = 2;
7601 dgst_pos3 = 1;
7602 break;
7603
7604 case 400: hash_type = HASH_TYPE_MD5;
7605 salt_type = SALT_TYPE_EMBEDDED;
7606 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7607 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7608 kern_type = KERN_TYPE_PHPASS;
7609 dgst_size = DGST_SIZE_4_4;
7610 parse_func = phpass_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 500: hash_type = HASH_TYPE_MD5;
7620 salt_type = SALT_TYPE_EMBEDDED;
7621 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7622 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7623 kern_type = KERN_TYPE_MD5CRYPT;
7624 dgst_size = DGST_SIZE_4_4;
7625 parse_func = md5crypt_parse_hash;
7626 sort_by_digest = sort_by_digest_4_4;
7627 opti_type = OPTI_TYPE_ZERO_BYTE;
7628 dgst_pos0 = 0;
7629 dgst_pos1 = 1;
7630 dgst_pos2 = 2;
7631 dgst_pos3 = 3;
7632 break;
7633
7634 case 501: hash_type = HASH_TYPE_MD5;
7635 salt_type = SALT_TYPE_EMBEDDED;
7636 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7637 opts_type = OPTS_TYPE_PT_GENERATE_LE
7638 | OPTS_TYPE_HASH_COPY;
7639 kern_type = KERN_TYPE_MD5CRYPT;
7640 dgst_size = DGST_SIZE_4_4;
7641 parse_func = juniper_parse_hash;
7642 sort_by_digest = sort_by_digest_4_4;
7643 opti_type = OPTI_TYPE_ZERO_BYTE;
7644 dgst_pos0 = 0;
7645 dgst_pos1 = 1;
7646 dgst_pos2 = 2;
7647 dgst_pos3 = 3;
7648 break;
7649
7650 case 900: hash_type = HASH_TYPE_MD4;
7651 salt_type = SALT_TYPE_NONE;
7652 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7653 opts_type = OPTS_TYPE_PT_GENERATE_LE
7654 | OPTS_TYPE_PT_ADD80
7655 | OPTS_TYPE_PT_ADDBITS14;
7656 kern_type = KERN_TYPE_MD4;
7657 dgst_size = DGST_SIZE_4_4;
7658 parse_func = md4_parse_hash;
7659 sort_by_digest = sort_by_digest_4_4;
7660 opti_type = OPTI_TYPE_ZERO_BYTE
7661 | OPTI_TYPE_PRECOMPUTE_INIT
7662 | OPTI_TYPE_PRECOMPUTE_MERKLE
7663 | OPTI_TYPE_MEET_IN_MIDDLE
7664 | OPTI_TYPE_EARLY_SKIP
7665 | OPTI_TYPE_NOT_ITERATED
7666 | OPTI_TYPE_NOT_SALTED
7667 | OPTI_TYPE_RAW_HASH;
7668 dgst_pos0 = 0;
7669 dgst_pos1 = 3;
7670 dgst_pos2 = 2;
7671 dgst_pos3 = 1;
7672 break;
7673
7674 case 1000: hash_type = HASH_TYPE_MD4;
7675 salt_type = SALT_TYPE_NONE;
7676 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7677 opts_type = OPTS_TYPE_PT_GENERATE_LE
7678 | OPTS_TYPE_PT_ADD80
7679 | OPTS_TYPE_PT_ADDBITS14
7680 | OPTS_TYPE_PT_UNICODE;
7681 kern_type = KERN_TYPE_MD4_PWU;
7682 dgst_size = DGST_SIZE_4_4;
7683 parse_func = md4_parse_hash;
7684 sort_by_digest = sort_by_digest_4_4;
7685 opti_type = OPTI_TYPE_ZERO_BYTE
7686 | OPTI_TYPE_PRECOMPUTE_INIT
7687 | OPTI_TYPE_PRECOMPUTE_MERKLE
7688 | OPTI_TYPE_MEET_IN_MIDDLE
7689 | OPTI_TYPE_EARLY_SKIP
7690 | OPTI_TYPE_NOT_ITERATED
7691 | OPTI_TYPE_NOT_SALTED
7692 | OPTI_TYPE_RAW_HASH;
7693 dgst_pos0 = 0;
7694 dgst_pos1 = 3;
7695 dgst_pos2 = 2;
7696 dgst_pos3 = 1;
7697 break;
7698
7699 case 1100: hash_type = HASH_TYPE_MD4;
7700 salt_type = SALT_TYPE_INTERN;
7701 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7702 opts_type = OPTS_TYPE_PT_GENERATE_LE
7703 | OPTS_TYPE_PT_ADD80
7704 | OPTS_TYPE_PT_ADDBITS14
7705 | OPTS_TYPE_PT_UNICODE
7706 | OPTS_TYPE_ST_ADD80
7707 | OPTS_TYPE_ST_UNICODE
7708 | OPTS_TYPE_ST_LOWER;
7709 kern_type = KERN_TYPE_MD44_PWUSLT;
7710 dgst_size = DGST_SIZE_4_4;
7711 parse_func = dcc_parse_hash;
7712 sort_by_digest = sort_by_digest_4_4;
7713 opti_type = OPTI_TYPE_ZERO_BYTE
7714 | OPTI_TYPE_PRECOMPUTE_INIT
7715 | OPTI_TYPE_PRECOMPUTE_MERKLE
7716 | OPTI_TYPE_EARLY_SKIP
7717 | OPTI_TYPE_NOT_ITERATED;
7718 dgst_pos0 = 0;
7719 dgst_pos1 = 3;
7720 dgst_pos2 = 2;
7721 dgst_pos3 = 1;
7722 break;
7723
7724 case 1400: hash_type = HASH_TYPE_SHA256;
7725 salt_type = SALT_TYPE_NONE;
7726 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7727 opts_type = OPTS_TYPE_PT_GENERATE_BE
7728 | OPTS_TYPE_PT_ADD80
7729 | OPTS_TYPE_PT_ADDBITS15;
7730 kern_type = KERN_TYPE_SHA256;
7731 dgst_size = DGST_SIZE_4_8;
7732 parse_func = sha256_parse_hash;
7733 sort_by_digest = sort_by_digest_4_8;
7734 opti_type = OPTI_TYPE_ZERO_BYTE
7735 | OPTI_TYPE_PRECOMPUTE_INIT
7736 | OPTI_TYPE_PRECOMPUTE_MERKLE
7737 | OPTI_TYPE_EARLY_SKIP
7738 | OPTI_TYPE_NOT_ITERATED
7739 | OPTI_TYPE_NOT_SALTED
7740 | OPTI_TYPE_RAW_HASH;
7741 dgst_pos0 = 3;
7742 dgst_pos1 = 7;
7743 dgst_pos2 = 2;
7744 dgst_pos3 = 6;
7745 break;
7746
7747 case 1410: hash_type = HASH_TYPE_SHA256;
7748 salt_type = SALT_TYPE_INTERN;
7749 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7750 opts_type = OPTS_TYPE_PT_GENERATE_BE
7751 | OPTS_TYPE_ST_ADD80
7752 | OPTS_TYPE_ST_ADDBITS15;
7753 kern_type = KERN_TYPE_SHA256_PWSLT;
7754 dgst_size = DGST_SIZE_4_8;
7755 parse_func = sha256s_parse_hash;
7756 sort_by_digest = sort_by_digest_4_8;
7757 opti_type = OPTI_TYPE_ZERO_BYTE
7758 | OPTI_TYPE_PRECOMPUTE_INIT
7759 | OPTI_TYPE_PRECOMPUTE_MERKLE
7760 | OPTI_TYPE_EARLY_SKIP
7761 | OPTI_TYPE_NOT_ITERATED
7762 | OPTI_TYPE_APPENDED_SALT
7763 | OPTI_TYPE_RAW_HASH;
7764 dgst_pos0 = 3;
7765 dgst_pos1 = 7;
7766 dgst_pos2 = 2;
7767 dgst_pos3 = 6;
7768 break;
7769
7770 case 1420: hash_type = HASH_TYPE_SHA256;
7771 salt_type = SALT_TYPE_INTERN;
7772 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7773 opts_type = OPTS_TYPE_PT_GENERATE_BE
7774 | OPTS_TYPE_PT_ADD80
7775 | OPTS_TYPE_PT_ADDBITS15;
7776 kern_type = KERN_TYPE_SHA256_SLTPW;
7777 dgst_size = DGST_SIZE_4_8;
7778 parse_func = sha256s_parse_hash;
7779 sort_by_digest = sort_by_digest_4_8;
7780 opti_type = OPTI_TYPE_ZERO_BYTE
7781 | OPTI_TYPE_PRECOMPUTE_INIT
7782 | OPTI_TYPE_PRECOMPUTE_MERKLE
7783 | OPTI_TYPE_EARLY_SKIP
7784 | OPTI_TYPE_NOT_ITERATED
7785 | OPTI_TYPE_PREPENDED_SALT
7786 | OPTI_TYPE_RAW_HASH;
7787 dgst_pos0 = 3;
7788 dgst_pos1 = 7;
7789 dgst_pos2 = 2;
7790 dgst_pos3 = 6;
7791 break;
7792
7793 case 1421: hash_type = HASH_TYPE_SHA256;
7794 salt_type = SALT_TYPE_EMBEDDED;
7795 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7796 opts_type = OPTS_TYPE_PT_GENERATE_BE
7797 | OPTS_TYPE_PT_ADD80
7798 | OPTS_TYPE_PT_ADDBITS15;
7799 kern_type = KERN_TYPE_SHA256_SLTPW;
7800 dgst_size = DGST_SIZE_4_8;
7801 parse_func = hmailserver_parse_hash;
7802 sort_by_digest = sort_by_digest_4_8;
7803 opti_type = OPTI_TYPE_ZERO_BYTE
7804 | OPTI_TYPE_PRECOMPUTE_INIT
7805 | OPTI_TYPE_PRECOMPUTE_MERKLE
7806 | OPTI_TYPE_EARLY_SKIP
7807 | OPTI_TYPE_NOT_ITERATED
7808 | OPTI_TYPE_PREPENDED_SALT
7809 | OPTI_TYPE_RAW_HASH;
7810 dgst_pos0 = 3;
7811 dgst_pos1 = 7;
7812 dgst_pos2 = 2;
7813 dgst_pos3 = 6;
7814 break;
7815
7816 case 1430: hash_type = HASH_TYPE_SHA256;
7817 salt_type = SALT_TYPE_INTERN;
7818 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7819 opts_type = OPTS_TYPE_PT_GENERATE_BE
7820 | OPTS_TYPE_PT_UNICODE
7821 | OPTS_TYPE_ST_ADD80
7822 | OPTS_TYPE_ST_ADDBITS15;
7823 kern_type = KERN_TYPE_SHA256_PWUSLT;
7824 dgst_size = DGST_SIZE_4_8;
7825 parse_func = sha256s_parse_hash;
7826 sort_by_digest = sort_by_digest_4_8;
7827 opti_type = OPTI_TYPE_ZERO_BYTE
7828 | OPTI_TYPE_PRECOMPUTE_INIT
7829 | OPTI_TYPE_PRECOMPUTE_MERKLE
7830 | OPTI_TYPE_EARLY_SKIP
7831 | OPTI_TYPE_NOT_ITERATED
7832 | OPTI_TYPE_APPENDED_SALT
7833 | OPTI_TYPE_RAW_HASH;
7834 dgst_pos0 = 3;
7835 dgst_pos1 = 7;
7836 dgst_pos2 = 2;
7837 dgst_pos3 = 6;
7838 break;
7839
7840 case 1440: hash_type = HASH_TYPE_SHA256;
7841 salt_type = SALT_TYPE_INTERN;
7842 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7843 opts_type = OPTS_TYPE_PT_GENERATE_BE
7844 | OPTS_TYPE_PT_ADD80
7845 | OPTS_TYPE_PT_ADDBITS15
7846 | OPTS_TYPE_PT_UNICODE;
7847 kern_type = KERN_TYPE_SHA256_SLTPWU;
7848 dgst_size = DGST_SIZE_4_8;
7849 parse_func = sha256s_parse_hash;
7850 sort_by_digest = sort_by_digest_4_8;
7851 opti_type = OPTI_TYPE_ZERO_BYTE
7852 | OPTI_TYPE_PRECOMPUTE_INIT
7853 | OPTI_TYPE_PRECOMPUTE_MERKLE
7854 | OPTI_TYPE_EARLY_SKIP
7855 | OPTI_TYPE_NOT_ITERATED
7856 | OPTI_TYPE_PREPENDED_SALT
7857 | OPTI_TYPE_RAW_HASH;
7858 dgst_pos0 = 3;
7859 dgst_pos1 = 7;
7860 dgst_pos2 = 2;
7861 dgst_pos3 = 6;
7862 break;
7863
7864 case 1441: hash_type = HASH_TYPE_SHA256;
7865 salt_type = SALT_TYPE_EMBEDDED;
7866 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7867 opts_type = OPTS_TYPE_PT_GENERATE_BE
7868 | OPTS_TYPE_PT_ADD80
7869 | OPTS_TYPE_PT_ADDBITS15
7870 | OPTS_TYPE_PT_UNICODE
7871 | OPTS_TYPE_ST_BASE64;
7872 kern_type = KERN_TYPE_SHA256_SLTPWU;
7873 dgst_size = DGST_SIZE_4_8;
7874 parse_func = episerver4_parse_hash;
7875 sort_by_digest = sort_by_digest_4_8;
7876 opti_type = OPTI_TYPE_ZERO_BYTE
7877 | OPTI_TYPE_PRECOMPUTE_INIT
7878 | OPTI_TYPE_PRECOMPUTE_MERKLE
7879 | OPTI_TYPE_EARLY_SKIP
7880 | OPTI_TYPE_NOT_ITERATED
7881 | OPTI_TYPE_PREPENDED_SALT
7882 | OPTI_TYPE_RAW_HASH;
7883 dgst_pos0 = 3;
7884 dgst_pos1 = 7;
7885 dgst_pos2 = 2;
7886 dgst_pos3 = 6;
7887 break;
7888
7889 case 1450: hash_type = HASH_TYPE_SHA256;
7890 salt_type = SALT_TYPE_INTERN;
7891 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7892 opts_type = OPTS_TYPE_PT_GENERATE_BE
7893 | OPTS_TYPE_ST_ADD80;
7894 kern_type = KERN_TYPE_HMACSHA256_PW;
7895 dgst_size = DGST_SIZE_4_8;
7896 parse_func = hmacsha256_parse_hash;
7897 sort_by_digest = sort_by_digest_4_8;
7898 opti_type = OPTI_TYPE_ZERO_BYTE
7899 | OPTI_TYPE_NOT_ITERATED;
7900 dgst_pos0 = 3;
7901 dgst_pos1 = 7;
7902 dgst_pos2 = 2;
7903 dgst_pos3 = 6;
7904 break;
7905
7906 case 1460: hash_type = HASH_TYPE_SHA256;
7907 salt_type = SALT_TYPE_INTERN;
7908 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7909 opts_type = OPTS_TYPE_PT_GENERATE_BE
7910 | OPTS_TYPE_PT_ADD80
7911 | OPTS_TYPE_PT_ADDBITS15;
7912 kern_type = KERN_TYPE_HMACSHA256_SLT;
7913 dgst_size = DGST_SIZE_4_8;
7914 parse_func = hmacsha256_parse_hash;
7915 sort_by_digest = sort_by_digest_4_8;
7916 opti_type = OPTI_TYPE_ZERO_BYTE
7917 | OPTI_TYPE_NOT_ITERATED;
7918 dgst_pos0 = 3;
7919 dgst_pos1 = 7;
7920 dgst_pos2 = 2;
7921 dgst_pos3 = 6;
7922 break;
7923
7924 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7925 salt_type = SALT_TYPE_EMBEDDED;
7926 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7927 opts_type = OPTS_TYPE_PT_GENERATE_LE
7928 | OPTS_TYPE_PT_BITSLICE;
7929 kern_type = KERN_TYPE_DESCRYPT;
7930 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7931 parse_func = descrypt_parse_hash;
7932 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7933 opti_type = OPTI_TYPE_ZERO_BYTE
7934 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7935 dgst_pos0 = 0;
7936 dgst_pos1 = 1;
7937 dgst_pos2 = 2;
7938 dgst_pos3 = 3;
7939 break;
7940
7941 case 1600: hash_type = HASH_TYPE_MD5;
7942 salt_type = SALT_TYPE_EMBEDDED;
7943 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7944 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7945 kern_type = KERN_TYPE_APR1CRYPT;
7946 dgst_size = DGST_SIZE_4_4;
7947 parse_func = md5apr1_parse_hash;
7948 sort_by_digest = sort_by_digest_4_4;
7949 opti_type = OPTI_TYPE_ZERO_BYTE;
7950 dgst_pos0 = 0;
7951 dgst_pos1 = 1;
7952 dgst_pos2 = 2;
7953 dgst_pos3 = 3;
7954 break;
7955
7956 case 1700: hash_type = HASH_TYPE_SHA512;
7957 salt_type = SALT_TYPE_NONE;
7958 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7959 opts_type = OPTS_TYPE_PT_GENERATE_BE
7960 | OPTS_TYPE_PT_ADD80
7961 | OPTS_TYPE_PT_ADDBITS15;
7962 kern_type = KERN_TYPE_SHA512;
7963 dgst_size = DGST_SIZE_8_8;
7964 parse_func = sha512_parse_hash;
7965 sort_by_digest = sort_by_digest_8_8;
7966 opti_type = OPTI_TYPE_ZERO_BYTE
7967 | OPTI_TYPE_PRECOMPUTE_INIT
7968 | OPTI_TYPE_PRECOMPUTE_MERKLE
7969 | OPTI_TYPE_EARLY_SKIP
7970 | OPTI_TYPE_NOT_ITERATED
7971 | OPTI_TYPE_NOT_SALTED
7972 | OPTI_TYPE_USES_BITS_64
7973 | OPTI_TYPE_RAW_HASH;
7974 dgst_pos0 = 14;
7975 dgst_pos1 = 15;
7976 dgst_pos2 = 6;
7977 dgst_pos3 = 7;
7978 break;
7979
7980 case 1710: hash_type = HASH_TYPE_SHA512;
7981 salt_type = SALT_TYPE_INTERN;
7982 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7983 opts_type = OPTS_TYPE_PT_GENERATE_BE
7984 | OPTS_TYPE_ST_ADD80
7985 | OPTS_TYPE_ST_ADDBITS15;
7986 kern_type = KERN_TYPE_SHA512_PWSLT;
7987 dgst_size = DGST_SIZE_8_8;
7988 parse_func = sha512s_parse_hash;
7989 sort_by_digest = sort_by_digest_8_8;
7990 opti_type = OPTI_TYPE_ZERO_BYTE
7991 | OPTI_TYPE_PRECOMPUTE_INIT
7992 | OPTI_TYPE_PRECOMPUTE_MERKLE
7993 | OPTI_TYPE_EARLY_SKIP
7994 | OPTI_TYPE_NOT_ITERATED
7995 | OPTI_TYPE_APPENDED_SALT
7996 | OPTI_TYPE_USES_BITS_64
7997 | OPTI_TYPE_RAW_HASH;
7998 dgst_pos0 = 14;
7999 dgst_pos1 = 15;
8000 dgst_pos2 = 6;
8001 dgst_pos3 = 7;
8002 break;
8003
8004 case 1711: hash_type = HASH_TYPE_SHA512;
8005 salt_type = SALT_TYPE_EMBEDDED;
8006 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8007 opts_type = OPTS_TYPE_PT_GENERATE_BE
8008 | OPTS_TYPE_ST_ADD80
8009 | OPTS_TYPE_ST_ADDBITS15;
8010 kern_type = KERN_TYPE_SHA512_PWSLT;
8011 dgst_size = DGST_SIZE_8_8;
8012 parse_func = sha512b64s_parse_hash;
8013 sort_by_digest = sort_by_digest_8_8;
8014 opti_type = OPTI_TYPE_ZERO_BYTE
8015 | OPTI_TYPE_PRECOMPUTE_INIT
8016 | OPTI_TYPE_PRECOMPUTE_MERKLE
8017 | OPTI_TYPE_EARLY_SKIP
8018 | OPTI_TYPE_NOT_ITERATED
8019 | OPTI_TYPE_APPENDED_SALT
8020 | OPTI_TYPE_USES_BITS_64
8021 | OPTI_TYPE_RAW_HASH;
8022 dgst_pos0 = 14;
8023 dgst_pos1 = 15;
8024 dgst_pos2 = 6;
8025 dgst_pos3 = 7;
8026 break;
8027
8028 case 1720: hash_type = HASH_TYPE_SHA512;
8029 salt_type = SALT_TYPE_INTERN;
8030 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8031 opts_type = OPTS_TYPE_PT_GENERATE_BE
8032 | OPTS_TYPE_PT_ADD80
8033 | OPTS_TYPE_PT_ADDBITS15;
8034 kern_type = KERN_TYPE_SHA512_SLTPW;
8035 dgst_size = DGST_SIZE_8_8;
8036 parse_func = sha512s_parse_hash;
8037 sort_by_digest = sort_by_digest_8_8;
8038 opti_type = OPTI_TYPE_ZERO_BYTE
8039 | OPTI_TYPE_PRECOMPUTE_INIT
8040 | OPTI_TYPE_PRECOMPUTE_MERKLE
8041 | OPTI_TYPE_EARLY_SKIP
8042 | OPTI_TYPE_NOT_ITERATED
8043 | OPTI_TYPE_PREPENDED_SALT
8044 | OPTI_TYPE_USES_BITS_64
8045 | OPTI_TYPE_RAW_HASH;
8046 dgst_pos0 = 14;
8047 dgst_pos1 = 15;
8048 dgst_pos2 = 6;
8049 dgst_pos3 = 7;
8050 break;
8051
8052 case 1722: hash_type = HASH_TYPE_SHA512;
8053 salt_type = SALT_TYPE_EMBEDDED;
8054 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8055 opts_type = OPTS_TYPE_PT_GENERATE_BE
8056 | OPTS_TYPE_PT_ADD80
8057 | OPTS_TYPE_PT_ADDBITS15
8058 | OPTS_TYPE_ST_HEX;
8059 kern_type = KERN_TYPE_SHA512_SLTPW;
8060 dgst_size = DGST_SIZE_8_8;
8061 parse_func = osx512_parse_hash;
8062 sort_by_digest = sort_by_digest_8_8;
8063 opti_type = OPTI_TYPE_ZERO_BYTE
8064 | OPTI_TYPE_PRECOMPUTE_INIT
8065 | OPTI_TYPE_PRECOMPUTE_MERKLE
8066 | OPTI_TYPE_EARLY_SKIP
8067 | OPTI_TYPE_NOT_ITERATED
8068 | OPTI_TYPE_PREPENDED_SALT
8069 | OPTI_TYPE_USES_BITS_64
8070 | OPTI_TYPE_RAW_HASH;
8071 dgst_pos0 = 14;
8072 dgst_pos1 = 15;
8073 dgst_pos2 = 6;
8074 dgst_pos3 = 7;
8075 break;
8076
8077 case 1730: hash_type = HASH_TYPE_SHA512;
8078 salt_type = SALT_TYPE_INTERN;
8079 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8080 opts_type = OPTS_TYPE_PT_GENERATE_BE
8081 | OPTS_TYPE_PT_UNICODE
8082 | OPTS_TYPE_ST_ADD80
8083 | OPTS_TYPE_ST_ADDBITS15;
8084 kern_type = KERN_TYPE_SHA512_PWSLTU;
8085 dgst_size = DGST_SIZE_8_8;
8086 parse_func = sha512s_parse_hash;
8087 sort_by_digest = sort_by_digest_8_8;
8088 opti_type = OPTI_TYPE_ZERO_BYTE
8089 | OPTI_TYPE_PRECOMPUTE_INIT
8090 | OPTI_TYPE_PRECOMPUTE_MERKLE
8091 | OPTI_TYPE_EARLY_SKIP
8092 | OPTI_TYPE_NOT_ITERATED
8093 | OPTI_TYPE_APPENDED_SALT
8094 | OPTI_TYPE_USES_BITS_64
8095 | OPTI_TYPE_RAW_HASH;
8096 dgst_pos0 = 14;
8097 dgst_pos1 = 15;
8098 dgst_pos2 = 6;
8099 dgst_pos3 = 7;
8100 break;
8101
8102 case 1731: hash_type = HASH_TYPE_SHA512;
8103 salt_type = SALT_TYPE_EMBEDDED;
8104 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8105 opts_type = OPTS_TYPE_PT_GENERATE_BE
8106 | OPTS_TYPE_PT_UNICODE
8107 | OPTS_TYPE_ST_ADD80
8108 | OPTS_TYPE_ST_ADDBITS15
8109 | OPTS_TYPE_ST_HEX;
8110 kern_type = KERN_TYPE_SHA512_PWSLTU;
8111 dgst_size = DGST_SIZE_8_8;
8112 parse_func = mssql2012_parse_hash;
8113 sort_by_digest = sort_by_digest_8_8;
8114 opti_type = OPTI_TYPE_ZERO_BYTE
8115 | OPTI_TYPE_PRECOMPUTE_INIT
8116 | OPTI_TYPE_PRECOMPUTE_MERKLE
8117 | OPTI_TYPE_EARLY_SKIP
8118 | OPTI_TYPE_NOT_ITERATED
8119 | OPTI_TYPE_APPENDED_SALT
8120 | OPTI_TYPE_USES_BITS_64
8121 | OPTI_TYPE_RAW_HASH;
8122 dgst_pos0 = 14;
8123 dgst_pos1 = 15;
8124 dgst_pos2 = 6;
8125 dgst_pos3 = 7;
8126 break;
8127
8128 case 1740: hash_type = HASH_TYPE_SHA512;
8129 salt_type = SALT_TYPE_INTERN;
8130 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8131 opts_type = OPTS_TYPE_PT_GENERATE_BE
8132 | OPTS_TYPE_PT_ADD80
8133 | OPTS_TYPE_PT_ADDBITS15
8134 | OPTS_TYPE_PT_UNICODE;
8135 kern_type = KERN_TYPE_SHA512_SLTPWU;
8136 dgst_size = DGST_SIZE_8_8;
8137 parse_func = sha512s_parse_hash;
8138 sort_by_digest = sort_by_digest_8_8;
8139 opti_type = OPTI_TYPE_ZERO_BYTE
8140 | OPTI_TYPE_PRECOMPUTE_INIT
8141 | OPTI_TYPE_PRECOMPUTE_MERKLE
8142 | OPTI_TYPE_EARLY_SKIP
8143 | OPTI_TYPE_NOT_ITERATED
8144 | OPTI_TYPE_PREPENDED_SALT
8145 | OPTI_TYPE_USES_BITS_64
8146 | OPTI_TYPE_RAW_HASH;
8147 dgst_pos0 = 14;
8148 dgst_pos1 = 15;
8149 dgst_pos2 = 6;
8150 dgst_pos3 = 7;
8151 break;
8152
8153 case 1750: hash_type = HASH_TYPE_SHA512;
8154 salt_type = SALT_TYPE_INTERN;
8155 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8156 opts_type = OPTS_TYPE_PT_GENERATE_BE
8157 | OPTS_TYPE_ST_ADD80;
8158 kern_type = KERN_TYPE_HMACSHA512_PW;
8159 dgst_size = DGST_SIZE_8_8;
8160 parse_func = hmacsha512_parse_hash;
8161 sort_by_digest = sort_by_digest_8_8;
8162 opti_type = OPTI_TYPE_ZERO_BYTE
8163 | OPTI_TYPE_USES_BITS_64
8164 | OPTI_TYPE_NOT_ITERATED;
8165 dgst_pos0 = 14;
8166 dgst_pos1 = 15;
8167 dgst_pos2 = 6;
8168 dgst_pos3 = 7;
8169 break;
8170
8171 case 1760: hash_type = HASH_TYPE_SHA512;
8172 salt_type = SALT_TYPE_INTERN;
8173 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8174 opts_type = OPTS_TYPE_PT_GENERATE_BE
8175 | OPTS_TYPE_PT_ADD80
8176 | OPTS_TYPE_PT_ADDBITS15;
8177 kern_type = KERN_TYPE_HMACSHA512_SLT;
8178 dgst_size = DGST_SIZE_8_8;
8179 parse_func = hmacsha512_parse_hash;
8180 sort_by_digest = sort_by_digest_8_8;
8181 opti_type = OPTI_TYPE_ZERO_BYTE
8182 | OPTI_TYPE_USES_BITS_64
8183 | OPTI_TYPE_NOT_ITERATED;
8184 dgst_pos0 = 14;
8185 dgst_pos1 = 15;
8186 dgst_pos2 = 6;
8187 dgst_pos3 = 7;
8188 break;
8189
8190 case 1800: hash_type = HASH_TYPE_SHA512;
8191 salt_type = SALT_TYPE_EMBEDDED;
8192 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8193 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8194 kern_type = KERN_TYPE_SHA512CRYPT;
8195 dgst_size = DGST_SIZE_8_8;
8196 parse_func = sha512crypt_parse_hash;
8197 sort_by_digest = sort_by_digest_8_8;
8198 opti_type = OPTI_TYPE_ZERO_BYTE
8199 | OPTI_TYPE_USES_BITS_64;
8200 dgst_pos0 = 0;
8201 dgst_pos1 = 1;
8202 dgst_pos2 = 2;
8203 dgst_pos3 = 3;
8204 break;
8205
8206 case 2100: hash_type = HASH_TYPE_DCC2;
8207 salt_type = SALT_TYPE_EMBEDDED;
8208 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8209 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8210 | OPTS_TYPE_ST_LOWER
8211 | OPTS_TYPE_ST_UNICODE;
8212 kern_type = KERN_TYPE_DCC2;
8213 dgst_size = DGST_SIZE_4_4;
8214 parse_func = dcc2_parse_hash;
8215 sort_by_digest = sort_by_digest_4_4;
8216 opti_type = OPTI_TYPE_ZERO_BYTE;
8217 dgst_pos0 = 0;
8218 dgst_pos1 = 1;
8219 dgst_pos2 = 2;
8220 dgst_pos3 = 3;
8221 break;
8222
8223 case 2400: hash_type = HASH_TYPE_MD5;
8224 salt_type = SALT_TYPE_NONE;
8225 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8226 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8227 kern_type = KERN_TYPE_MD5PIX;
8228 dgst_size = DGST_SIZE_4_4;
8229 parse_func = md5pix_parse_hash;
8230 sort_by_digest = sort_by_digest_4_4;
8231 opti_type = OPTI_TYPE_ZERO_BYTE
8232 | OPTI_TYPE_PRECOMPUTE_INIT
8233 | OPTI_TYPE_PRECOMPUTE_MERKLE
8234 | OPTI_TYPE_EARLY_SKIP
8235 | OPTI_TYPE_NOT_ITERATED
8236 | OPTI_TYPE_NOT_SALTED;
8237 dgst_pos0 = 0;
8238 dgst_pos1 = 3;
8239 dgst_pos2 = 2;
8240 dgst_pos3 = 1;
8241 break;
8242
8243 case 2410: hash_type = HASH_TYPE_MD5;
8244 salt_type = SALT_TYPE_INTERN;
8245 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8246 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8247 kern_type = KERN_TYPE_MD5ASA;
8248 dgst_size = DGST_SIZE_4_4;
8249 parse_func = md5asa_parse_hash;
8250 sort_by_digest = sort_by_digest_4_4;
8251 opti_type = OPTI_TYPE_ZERO_BYTE
8252 | OPTI_TYPE_PRECOMPUTE_INIT
8253 | OPTI_TYPE_PRECOMPUTE_MERKLE
8254 | OPTI_TYPE_EARLY_SKIP
8255 | OPTI_TYPE_NOT_ITERATED;
8256 dgst_pos0 = 0;
8257 dgst_pos1 = 3;
8258 dgst_pos2 = 2;
8259 dgst_pos3 = 1;
8260 break;
8261
8262 case 2500: hash_type = HASH_TYPE_WPA;
8263 salt_type = SALT_TYPE_EMBEDDED;
8264 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8265 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8266 kern_type = KERN_TYPE_WPA;
8267 dgst_size = DGST_SIZE_4_4;
8268 parse_func = wpa_parse_hash;
8269 sort_by_digest = sort_by_digest_4_4;
8270 opti_type = OPTI_TYPE_ZERO_BYTE;
8271 dgst_pos0 = 0;
8272 dgst_pos1 = 1;
8273 dgst_pos2 = 2;
8274 dgst_pos3 = 3;
8275 break;
8276
8277 case 2600: hash_type = HASH_TYPE_MD5;
8278 salt_type = SALT_TYPE_VIRTUAL;
8279 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8280 opts_type = OPTS_TYPE_PT_GENERATE_LE
8281 | OPTS_TYPE_PT_ADD80
8282 | OPTS_TYPE_PT_ADDBITS14
8283 | OPTS_TYPE_ST_ADD80;
8284 kern_type = KERN_TYPE_MD55_PWSLT1;
8285 dgst_size = DGST_SIZE_4_4;
8286 parse_func = md5md5_parse_hash;
8287 sort_by_digest = sort_by_digest_4_4;
8288 opti_type = OPTI_TYPE_ZERO_BYTE
8289 | OPTI_TYPE_PRECOMPUTE_INIT
8290 | OPTI_TYPE_PRECOMPUTE_MERKLE
8291 | OPTI_TYPE_EARLY_SKIP;
8292 dgst_pos0 = 0;
8293 dgst_pos1 = 3;
8294 dgst_pos2 = 2;
8295 dgst_pos3 = 1;
8296 break;
8297
8298 case 2611: hash_type = HASH_TYPE_MD5;
8299 salt_type = SALT_TYPE_INTERN;
8300 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8301 opts_type = OPTS_TYPE_PT_GENERATE_LE
8302 | OPTS_TYPE_PT_ADD80
8303 | OPTS_TYPE_PT_ADDBITS14
8304 | OPTS_TYPE_ST_ADD80;
8305 kern_type = KERN_TYPE_MD55_PWSLT1;
8306 dgst_size = DGST_SIZE_4_4;
8307 parse_func = vb3_parse_hash;
8308 sort_by_digest = sort_by_digest_4_4;
8309 opti_type = OPTI_TYPE_ZERO_BYTE
8310 | OPTI_TYPE_PRECOMPUTE_INIT
8311 | OPTI_TYPE_PRECOMPUTE_MERKLE
8312 | OPTI_TYPE_EARLY_SKIP;
8313 dgst_pos0 = 0;
8314 dgst_pos1 = 3;
8315 dgst_pos2 = 2;
8316 dgst_pos3 = 1;
8317 break;
8318
8319 case 2612: hash_type = HASH_TYPE_MD5;
8320 salt_type = SALT_TYPE_EMBEDDED;
8321 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8322 opts_type = OPTS_TYPE_PT_GENERATE_LE
8323 | OPTS_TYPE_PT_ADD80
8324 | OPTS_TYPE_PT_ADDBITS14
8325 | OPTS_TYPE_ST_ADD80
8326 | OPTS_TYPE_ST_HEX;
8327 kern_type = KERN_TYPE_MD55_PWSLT1;
8328 dgst_size = DGST_SIZE_4_4;
8329 parse_func = phps_parse_hash;
8330 sort_by_digest = sort_by_digest_4_4;
8331 opti_type = OPTI_TYPE_ZERO_BYTE
8332 | OPTI_TYPE_PRECOMPUTE_INIT
8333 | OPTI_TYPE_PRECOMPUTE_MERKLE
8334 | OPTI_TYPE_EARLY_SKIP;
8335 dgst_pos0 = 0;
8336 dgst_pos1 = 3;
8337 dgst_pos2 = 2;
8338 dgst_pos3 = 1;
8339 break;
8340
8341 case 2711: hash_type = HASH_TYPE_MD5;
8342 salt_type = SALT_TYPE_INTERN;
8343 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8344 opts_type = OPTS_TYPE_PT_GENERATE_LE
8345 | OPTS_TYPE_PT_ADD80
8346 | OPTS_TYPE_PT_ADDBITS14
8347 | OPTS_TYPE_ST_ADD80;
8348 kern_type = KERN_TYPE_MD55_PWSLT2;
8349 dgst_size = DGST_SIZE_4_4;
8350 parse_func = vb30_parse_hash;
8351 sort_by_digest = sort_by_digest_4_4;
8352 opti_type = OPTI_TYPE_ZERO_BYTE
8353 | OPTI_TYPE_PRECOMPUTE_INIT
8354 | OPTI_TYPE_EARLY_SKIP;
8355 dgst_pos0 = 0;
8356 dgst_pos1 = 3;
8357 dgst_pos2 = 2;
8358 dgst_pos3 = 1;
8359 break;
8360
8361 case 2811: hash_type = HASH_TYPE_MD5;
8362 salt_type = SALT_TYPE_INTERN;
8363 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8364 opts_type = OPTS_TYPE_PT_GENERATE_LE
8365 | OPTS_TYPE_PT_ADD80
8366 | OPTS_TYPE_PT_ADDBITS14;
8367 kern_type = KERN_TYPE_MD55_SLTPW;
8368 dgst_size = DGST_SIZE_4_4;
8369 parse_func = ipb2_parse_hash;
8370 sort_by_digest = sort_by_digest_4_4;
8371 opti_type = OPTI_TYPE_ZERO_BYTE
8372 | OPTI_TYPE_PRECOMPUTE_INIT
8373 | OPTI_TYPE_EARLY_SKIP;
8374 dgst_pos0 = 0;
8375 dgst_pos1 = 3;
8376 dgst_pos2 = 2;
8377 dgst_pos3 = 1;
8378 break;
8379
8380 case 3000: hash_type = HASH_TYPE_LM;
8381 salt_type = SALT_TYPE_NONE;
8382 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8383 opts_type = OPTS_TYPE_PT_GENERATE_LE
8384 | OPTS_TYPE_PT_UPPER
8385 | OPTS_TYPE_PT_BITSLICE;
8386 kern_type = KERN_TYPE_LM;
8387 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8388 parse_func = lm_parse_hash;
8389 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8390 opti_type = OPTI_TYPE_ZERO_BYTE
8391 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8392 dgst_pos0 = 0;
8393 dgst_pos1 = 1;
8394 dgst_pos2 = 2;
8395 dgst_pos3 = 3;
8396 break;
8397
8398 case 3100: hash_type = HASH_TYPE_ORACLEH;
8399 salt_type = SALT_TYPE_INTERN;
8400 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8401 opts_type = OPTS_TYPE_PT_GENERATE_LE
8402 | OPTS_TYPE_PT_UPPER
8403 | OPTS_TYPE_ST_UPPER;
8404 kern_type = KERN_TYPE_ORACLEH;
8405 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8406 parse_func = oracleh_parse_hash;
8407 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8408 opti_type = OPTI_TYPE_ZERO_BYTE;
8409 dgst_pos0 = 0;
8410 dgst_pos1 = 1;
8411 dgst_pos2 = 2;
8412 dgst_pos3 = 3;
8413 break;
8414
8415 case 3200: hash_type = HASH_TYPE_BCRYPT;
8416 salt_type = SALT_TYPE_EMBEDDED;
8417 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8418 opts_type = OPTS_TYPE_PT_GENERATE_LE
8419 | OPTS_TYPE_ST_GENERATE_LE;
8420 kern_type = KERN_TYPE_BCRYPT;
8421 dgst_size = DGST_SIZE_4_6;
8422 parse_func = bcrypt_parse_hash;
8423 sort_by_digest = sort_by_digest_4_6;
8424 opti_type = OPTI_TYPE_ZERO_BYTE;
8425 dgst_pos0 = 0;
8426 dgst_pos1 = 1;
8427 dgst_pos2 = 2;
8428 dgst_pos3 = 3;
8429 break;
8430
8431 case 3710: hash_type = HASH_TYPE_MD5;
8432 salt_type = SALT_TYPE_INTERN;
8433 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8434 opts_type = OPTS_TYPE_PT_GENERATE_LE
8435 | OPTS_TYPE_PT_ADD80
8436 | OPTS_TYPE_PT_ADDBITS14;
8437 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8438 dgst_size = DGST_SIZE_4_4;
8439 parse_func = md5s_parse_hash;
8440 sort_by_digest = sort_by_digest_4_4;
8441 opti_type = OPTI_TYPE_ZERO_BYTE
8442 | OPTI_TYPE_PRECOMPUTE_INIT
8443 | OPTI_TYPE_PRECOMPUTE_MERKLE
8444 | OPTI_TYPE_EARLY_SKIP;
8445 dgst_pos0 = 0;
8446 dgst_pos1 = 3;
8447 dgst_pos2 = 2;
8448 dgst_pos3 = 1;
8449 break;
8450
8451 case 3711: hash_type = HASH_TYPE_MD5;
8452 salt_type = SALT_TYPE_EMBEDDED;
8453 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8454 opts_type = OPTS_TYPE_PT_GENERATE_LE
8455 | OPTS_TYPE_PT_ADD80
8456 | OPTS_TYPE_PT_ADDBITS14;
8457 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8458 dgst_size = DGST_SIZE_4_4;
8459 parse_func = mediawiki_b_parse_hash;
8460 sort_by_digest = sort_by_digest_4_4;
8461 opti_type = OPTI_TYPE_ZERO_BYTE
8462 | OPTI_TYPE_PRECOMPUTE_INIT
8463 | OPTI_TYPE_PRECOMPUTE_MERKLE
8464 | OPTI_TYPE_EARLY_SKIP;
8465 dgst_pos0 = 0;
8466 dgst_pos1 = 3;
8467 dgst_pos2 = 2;
8468 dgst_pos3 = 1;
8469 break;
8470
8471 case 3800: hash_type = HASH_TYPE_MD5;
8472 salt_type = SALT_TYPE_INTERN;
8473 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8474 opts_type = OPTS_TYPE_PT_GENERATE_LE
8475 | OPTS_TYPE_ST_ADDBITS14;
8476 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8477 dgst_size = DGST_SIZE_4_4;
8478 parse_func = md5s_parse_hash;
8479 sort_by_digest = sort_by_digest_4_4;
8480 opti_type = OPTI_TYPE_ZERO_BYTE
8481 | OPTI_TYPE_PRECOMPUTE_INIT
8482 | OPTI_TYPE_PRECOMPUTE_MERKLE
8483 | OPTI_TYPE_EARLY_SKIP
8484 | OPTI_TYPE_NOT_ITERATED
8485 | OPTI_TYPE_RAW_HASH;
8486 dgst_pos0 = 0;
8487 dgst_pos1 = 3;
8488 dgst_pos2 = 2;
8489 dgst_pos3 = 1;
8490 break;
8491
8492 case 4300: hash_type = HASH_TYPE_MD5;
8493 salt_type = SALT_TYPE_VIRTUAL;
8494 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8495 opts_type = OPTS_TYPE_PT_GENERATE_LE
8496 | OPTS_TYPE_PT_ADD80
8497 | OPTS_TYPE_PT_ADDBITS14
8498 | OPTS_TYPE_ST_ADD80;
8499 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8500 dgst_size = DGST_SIZE_4_4;
8501 parse_func = md5md5_parse_hash;
8502 sort_by_digest = sort_by_digest_4_4;
8503 opti_type = OPTI_TYPE_ZERO_BYTE
8504 | OPTI_TYPE_PRECOMPUTE_INIT
8505 | OPTI_TYPE_PRECOMPUTE_MERKLE
8506 | OPTI_TYPE_EARLY_SKIP;
8507 dgst_pos0 = 0;
8508 dgst_pos1 = 3;
8509 dgst_pos2 = 2;
8510 dgst_pos3 = 1;
8511 break;
8512
8513
8514 case 4400: hash_type = HASH_TYPE_MD5;
8515 salt_type = SALT_TYPE_NONE;
8516 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8517 opts_type = OPTS_TYPE_PT_GENERATE_BE
8518 | OPTS_TYPE_PT_ADD80
8519 | OPTS_TYPE_PT_ADDBITS15;
8520 kern_type = KERN_TYPE_MD5_SHA1;
8521 dgst_size = DGST_SIZE_4_4;
8522 parse_func = md5_parse_hash;
8523 sort_by_digest = sort_by_digest_4_4;
8524 opti_type = OPTI_TYPE_ZERO_BYTE
8525 | OPTI_TYPE_PRECOMPUTE_INIT
8526 | OPTI_TYPE_PRECOMPUTE_MERKLE
8527 | OPTI_TYPE_EARLY_SKIP
8528 | OPTI_TYPE_NOT_ITERATED
8529 | OPTI_TYPE_NOT_SALTED
8530 | OPTI_TYPE_RAW_HASH;
8531 dgst_pos0 = 0;
8532 dgst_pos1 = 3;
8533 dgst_pos2 = 2;
8534 dgst_pos3 = 1;
8535 break;
8536
8537 case 4500: hash_type = HASH_TYPE_SHA1;
8538 salt_type = SALT_TYPE_NONE;
8539 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8540 opts_type = OPTS_TYPE_PT_GENERATE_BE
8541 | OPTS_TYPE_PT_ADD80
8542 | OPTS_TYPE_PT_ADDBITS15;
8543 kern_type = KERN_TYPE_SHA11;
8544 dgst_size = DGST_SIZE_4_5;
8545 parse_func = sha1_parse_hash;
8546 sort_by_digest = sort_by_digest_4_5;
8547 opti_type = OPTI_TYPE_ZERO_BYTE
8548 | OPTI_TYPE_PRECOMPUTE_INIT
8549 | OPTI_TYPE_PRECOMPUTE_MERKLE
8550 | OPTI_TYPE_EARLY_SKIP
8551 | OPTI_TYPE_NOT_SALTED;
8552 dgst_pos0 = 3;
8553 dgst_pos1 = 4;
8554 dgst_pos2 = 2;
8555 dgst_pos3 = 1;
8556 break;
8557
8558 case 4700: hash_type = HASH_TYPE_SHA1;
8559 salt_type = SALT_TYPE_NONE;
8560 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8561 opts_type = OPTS_TYPE_PT_GENERATE_LE
8562 | OPTS_TYPE_PT_ADD80
8563 | OPTS_TYPE_PT_ADDBITS14;
8564 kern_type = KERN_TYPE_SHA1_MD5;
8565 dgst_size = DGST_SIZE_4_5;
8566 parse_func = sha1_parse_hash;
8567 sort_by_digest = sort_by_digest_4_5;
8568 opti_type = OPTI_TYPE_ZERO_BYTE
8569 | OPTI_TYPE_PRECOMPUTE_INIT
8570 | OPTI_TYPE_PRECOMPUTE_MERKLE
8571 | OPTI_TYPE_EARLY_SKIP
8572 | OPTI_TYPE_NOT_ITERATED
8573 | OPTI_TYPE_NOT_SALTED
8574 | OPTI_TYPE_RAW_HASH;
8575 dgst_pos0 = 3;
8576 dgst_pos1 = 4;
8577 dgst_pos2 = 2;
8578 dgst_pos3 = 1;
8579 break;
8580
8581 case 4800: hash_type = HASH_TYPE_MD5;
8582 salt_type = SALT_TYPE_EMBEDDED;
8583 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8584 opts_type = OPTS_TYPE_PT_GENERATE_LE
8585 | OPTS_TYPE_PT_ADDBITS14;
8586 kern_type = KERN_TYPE_MD5_CHAP;
8587 dgst_size = DGST_SIZE_4_4;
8588 parse_func = chap_parse_hash;
8589 sort_by_digest = sort_by_digest_4_4;
8590 opti_type = OPTI_TYPE_ZERO_BYTE
8591 | OPTI_TYPE_PRECOMPUTE_INIT
8592 | OPTI_TYPE_PRECOMPUTE_MERKLE
8593 | OPTI_TYPE_MEET_IN_MIDDLE
8594 | OPTI_TYPE_EARLY_SKIP
8595 | OPTI_TYPE_NOT_ITERATED
8596 | OPTI_TYPE_RAW_HASH;
8597 dgst_pos0 = 0;
8598 dgst_pos1 = 3;
8599 dgst_pos2 = 2;
8600 dgst_pos3 = 1;
8601 break;
8602
8603 case 4900: hash_type = HASH_TYPE_SHA1;
8604 salt_type = SALT_TYPE_INTERN;
8605 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8606 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8607 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8608 dgst_size = DGST_SIZE_4_5;
8609 parse_func = sha1s_parse_hash;
8610 sort_by_digest = sort_by_digest_4_5;
8611 opti_type = OPTI_TYPE_ZERO_BYTE
8612 | OPTI_TYPE_PRECOMPUTE_INIT
8613 | OPTI_TYPE_PRECOMPUTE_MERKLE
8614 | OPTI_TYPE_EARLY_SKIP;
8615 dgst_pos0 = 3;
8616 dgst_pos1 = 4;
8617 dgst_pos2 = 2;
8618 dgst_pos3 = 1;
8619 break;
8620
8621 case 5000: hash_type = HASH_TYPE_KECCAK;
8622 salt_type = SALT_TYPE_EMBEDDED;
8623 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8624 opts_type = OPTS_TYPE_PT_GENERATE_LE
8625 | OPTS_TYPE_PT_ADD01;
8626 kern_type = KERN_TYPE_KECCAK;
8627 dgst_size = DGST_SIZE_8_25;
8628 parse_func = keccak_parse_hash;
8629 sort_by_digest = sort_by_digest_8_25;
8630 opti_type = OPTI_TYPE_ZERO_BYTE
8631 | OPTI_TYPE_USES_BITS_64
8632 | OPTI_TYPE_RAW_HASH;
8633 dgst_pos0 = 2;
8634 dgst_pos1 = 3;
8635 dgst_pos2 = 4;
8636 dgst_pos3 = 5;
8637 break;
8638
8639 case 5100: hash_type = HASH_TYPE_MD5H;
8640 salt_type = SALT_TYPE_NONE;
8641 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8642 opts_type = OPTS_TYPE_PT_GENERATE_LE
8643 | OPTS_TYPE_PT_ADD80
8644 | OPTS_TYPE_PT_ADDBITS14;
8645 kern_type = KERN_TYPE_MD5H;
8646 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8647 parse_func = md5half_parse_hash;
8648 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8649 opti_type = OPTI_TYPE_ZERO_BYTE
8650 | OPTI_TYPE_RAW_HASH;
8651 dgst_pos0 = 0;
8652 dgst_pos1 = 1;
8653 dgst_pos2 = 2;
8654 dgst_pos3 = 3;
8655 break;
8656
8657 case 5200: hash_type = HASH_TYPE_SHA256;
8658 salt_type = SALT_TYPE_EMBEDDED;
8659 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8660 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8661 kern_type = KERN_TYPE_PSAFE3;
8662 dgst_size = DGST_SIZE_4_8;
8663 parse_func = psafe3_parse_hash;
8664 sort_by_digest = sort_by_digest_4_8;
8665 opti_type = OPTI_TYPE_ZERO_BYTE;
8666 dgst_pos0 = 0;
8667 dgst_pos1 = 1;
8668 dgst_pos2 = 2;
8669 dgst_pos3 = 3;
8670 break;
8671
8672 case 5300: hash_type = HASH_TYPE_MD5;
8673 salt_type = SALT_TYPE_EMBEDDED;
8674 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8675 opts_type = OPTS_TYPE_PT_GENERATE_LE
8676 | OPTS_TYPE_ST_ADD80;
8677 kern_type = KERN_TYPE_IKEPSK_MD5;
8678 dgst_size = DGST_SIZE_4_4;
8679 parse_func = ikepsk_md5_parse_hash;
8680 sort_by_digest = sort_by_digest_4_4;
8681 opti_type = OPTI_TYPE_ZERO_BYTE;
8682 dgst_pos0 = 0;
8683 dgst_pos1 = 3;
8684 dgst_pos2 = 2;
8685 dgst_pos3 = 1;
8686 break;
8687
8688 case 5400: hash_type = HASH_TYPE_SHA1;
8689 salt_type = SALT_TYPE_EMBEDDED;
8690 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8691 opts_type = OPTS_TYPE_PT_GENERATE_BE
8692 | OPTS_TYPE_ST_ADD80;
8693 kern_type = KERN_TYPE_IKEPSK_SHA1;
8694 dgst_size = DGST_SIZE_4_5;
8695 parse_func = ikepsk_sha1_parse_hash;
8696 sort_by_digest = sort_by_digest_4_5;
8697 opti_type = OPTI_TYPE_ZERO_BYTE;
8698 dgst_pos0 = 3;
8699 dgst_pos1 = 4;
8700 dgst_pos2 = 2;
8701 dgst_pos3 = 1;
8702 break;
8703
8704 case 5500: hash_type = HASH_TYPE_NETNTLM;
8705 salt_type = SALT_TYPE_EMBEDDED;
8706 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8707 opts_type = OPTS_TYPE_PT_GENERATE_LE
8708 | OPTS_TYPE_PT_ADD80
8709 | OPTS_TYPE_PT_ADDBITS14
8710 | OPTS_TYPE_PT_UNICODE
8711 | OPTS_TYPE_ST_HEX;
8712 kern_type = KERN_TYPE_NETNTLMv1;
8713 dgst_size = DGST_SIZE_4_4;
8714 parse_func = netntlmv1_parse_hash;
8715 sort_by_digest = sort_by_digest_4_4;
8716 opti_type = OPTI_TYPE_ZERO_BYTE
8717 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8718 dgst_pos0 = 0;
8719 dgst_pos1 = 1;
8720 dgst_pos2 = 2;
8721 dgst_pos3 = 3;
8722 break;
8723
8724 case 5600: hash_type = HASH_TYPE_MD5;
8725 salt_type = SALT_TYPE_EMBEDDED;
8726 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8727 opts_type = OPTS_TYPE_PT_GENERATE_LE
8728 | OPTS_TYPE_PT_ADD80
8729 | OPTS_TYPE_PT_ADDBITS14
8730 | OPTS_TYPE_PT_UNICODE;
8731 kern_type = KERN_TYPE_NETNTLMv2;
8732 dgst_size = DGST_SIZE_4_4;
8733 parse_func = netntlmv2_parse_hash;
8734 sort_by_digest = sort_by_digest_4_4;
8735 opti_type = OPTI_TYPE_ZERO_BYTE;
8736 dgst_pos0 = 0;
8737 dgst_pos1 = 3;
8738 dgst_pos2 = 2;
8739 dgst_pos3 = 1;
8740 break;
8741
8742 case 5700: hash_type = HASH_TYPE_SHA256;
8743 salt_type = SALT_TYPE_NONE;
8744 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8745 opts_type = OPTS_TYPE_PT_GENERATE_BE
8746 | OPTS_TYPE_PT_ADD80
8747 | OPTS_TYPE_PT_ADDBITS15;
8748 kern_type = KERN_TYPE_SHA256;
8749 dgst_size = DGST_SIZE_4_8;
8750 parse_func = cisco4_parse_hash;
8751 sort_by_digest = sort_by_digest_4_8;
8752 opti_type = OPTI_TYPE_ZERO_BYTE
8753 | OPTI_TYPE_PRECOMPUTE_INIT
8754 | OPTI_TYPE_PRECOMPUTE_MERKLE
8755 | OPTI_TYPE_EARLY_SKIP
8756 | OPTI_TYPE_NOT_ITERATED
8757 | OPTI_TYPE_NOT_SALTED
8758 | OPTI_TYPE_RAW_HASH;
8759 dgst_pos0 = 3;
8760 dgst_pos1 = 7;
8761 dgst_pos2 = 2;
8762 dgst_pos3 = 6;
8763 break;
8764
8765 case 5800: hash_type = HASH_TYPE_SHA1;
8766 salt_type = SALT_TYPE_INTERN;
8767 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8768 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8769 | OPTS_TYPE_ST_ADD80;
8770 kern_type = KERN_TYPE_ANDROIDPIN;
8771 dgst_size = DGST_SIZE_4_5;
8772 parse_func = androidpin_parse_hash;
8773 sort_by_digest = sort_by_digest_4_5;
8774 opti_type = OPTI_TYPE_ZERO_BYTE;
8775 dgst_pos0 = 0;
8776 dgst_pos1 = 1;
8777 dgst_pos2 = 2;
8778 dgst_pos3 = 3;
8779 break;
8780
8781 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8782 salt_type = SALT_TYPE_NONE;
8783 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8784 opts_type = OPTS_TYPE_PT_GENERATE_LE
8785 | OPTS_TYPE_PT_ADD80;
8786 kern_type = KERN_TYPE_RIPEMD160;
8787 dgst_size = DGST_SIZE_4_5;
8788 parse_func = ripemd160_parse_hash;
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 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8798 salt_type = SALT_TYPE_NONE;
8799 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8800 opts_type = OPTS_TYPE_PT_GENERATE_BE
8801 | OPTS_TYPE_PT_ADD80;
8802 kern_type = KERN_TYPE_WHIRLPOOL;
8803 dgst_size = DGST_SIZE_4_16;
8804 parse_func = whirlpool_parse_hash;
8805 sort_by_digest = sort_by_digest_4_16;
8806 opti_type = OPTI_TYPE_ZERO_BYTE;
8807 dgst_pos0 = 0;
8808 dgst_pos1 = 1;
8809 dgst_pos2 = 2;
8810 dgst_pos3 = 3;
8811 break;
8812
8813 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8814 salt_type = SALT_TYPE_EMBEDDED;
8815 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8816 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8817 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8818 dgst_size = DGST_SIZE_4_5;
8819 parse_func = truecrypt_parse_hash_2k;
8820 sort_by_digest = sort_by_digest_4_5;
8821 opti_type = OPTI_TYPE_ZERO_BYTE;
8822 dgst_pos0 = 0;
8823 dgst_pos1 = 1;
8824 dgst_pos2 = 2;
8825 dgst_pos3 = 3;
8826 break;
8827
8828 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8829 salt_type = SALT_TYPE_EMBEDDED;
8830 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8831 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8832 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8833 dgst_size = DGST_SIZE_4_5;
8834 parse_func = truecrypt_parse_hash_2k;
8835 sort_by_digest = sort_by_digest_4_5;
8836 opti_type = OPTI_TYPE_ZERO_BYTE;
8837 dgst_pos0 = 0;
8838 dgst_pos1 = 1;
8839 dgst_pos2 = 2;
8840 dgst_pos3 = 3;
8841 break;
8842
8843 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8844 salt_type = SALT_TYPE_EMBEDDED;
8845 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8846 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8847 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8848 dgst_size = DGST_SIZE_4_5;
8849 parse_func = truecrypt_parse_hash_2k;
8850 sort_by_digest = sort_by_digest_4_5;
8851 opti_type = OPTI_TYPE_ZERO_BYTE;
8852 dgst_pos0 = 0;
8853 dgst_pos1 = 1;
8854 dgst_pos2 = 2;
8855 dgst_pos3 = 3;
8856 break;
8857
8858 case 6221: hash_type = HASH_TYPE_SHA512;
8859 salt_type = SALT_TYPE_EMBEDDED;
8860 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8861 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8862 kern_type = KERN_TYPE_TCSHA512_XTS512;
8863 dgst_size = DGST_SIZE_8_8;
8864 parse_func = truecrypt_parse_hash_1k;
8865 sort_by_digest = sort_by_digest_8_8;
8866 opti_type = OPTI_TYPE_ZERO_BYTE
8867 | OPTI_TYPE_USES_BITS_64;
8868 dgst_pos0 = 0;
8869 dgst_pos1 = 1;
8870 dgst_pos2 = 2;
8871 dgst_pos3 = 3;
8872 break;
8873
8874 case 6222: hash_type = HASH_TYPE_SHA512;
8875 salt_type = SALT_TYPE_EMBEDDED;
8876 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8877 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8878 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8879 dgst_size = DGST_SIZE_8_8;
8880 parse_func = truecrypt_parse_hash_1k;
8881 sort_by_digest = sort_by_digest_8_8;
8882 opti_type = OPTI_TYPE_ZERO_BYTE
8883 | OPTI_TYPE_USES_BITS_64;
8884 dgst_pos0 = 0;
8885 dgst_pos1 = 1;
8886 dgst_pos2 = 2;
8887 dgst_pos3 = 3;
8888 break;
8889
8890 case 6223: hash_type = HASH_TYPE_SHA512;
8891 salt_type = SALT_TYPE_EMBEDDED;
8892 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8893 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8894 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8895 dgst_size = DGST_SIZE_8_8;
8896 parse_func = truecrypt_parse_hash_1k;
8897 sort_by_digest = sort_by_digest_8_8;
8898 opti_type = OPTI_TYPE_ZERO_BYTE
8899 | OPTI_TYPE_USES_BITS_64;
8900 dgst_pos0 = 0;
8901 dgst_pos1 = 1;
8902 dgst_pos2 = 2;
8903 dgst_pos3 = 3;
8904 break;
8905
8906 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8907 salt_type = SALT_TYPE_EMBEDDED;
8908 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8909 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8910 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8911 dgst_size = DGST_SIZE_4_8;
8912 parse_func = truecrypt_parse_hash_1k;
8913 sort_by_digest = sort_by_digest_4_8;
8914 opti_type = OPTI_TYPE_ZERO_BYTE;
8915 dgst_pos0 = 0;
8916 dgst_pos1 = 1;
8917 dgst_pos2 = 2;
8918 dgst_pos3 = 3;
8919 break;
8920
8921 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8922 salt_type = SALT_TYPE_EMBEDDED;
8923 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8924 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8925 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8926 dgst_size = DGST_SIZE_4_8;
8927 parse_func = truecrypt_parse_hash_1k;
8928 sort_by_digest = sort_by_digest_4_8;
8929 opti_type = OPTI_TYPE_ZERO_BYTE;
8930 dgst_pos0 = 0;
8931 dgst_pos1 = 1;
8932 dgst_pos2 = 2;
8933 dgst_pos3 = 3;
8934 break;
8935
8936 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8937 salt_type = SALT_TYPE_EMBEDDED;
8938 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8939 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8940 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8941 dgst_size = DGST_SIZE_4_8;
8942 parse_func = truecrypt_parse_hash_1k;
8943 sort_by_digest = sort_by_digest_4_8;
8944 opti_type = OPTI_TYPE_ZERO_BYTE;
8945 dgst_pos0 = 0;
8946 dgst_pos1 = 1;
8947 dgst_pos2 = 2;
8948 dgst_pos3 = 3;
8949 break;
8950
8951 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8952 salt_type = SALT_TYPE_EMBEDDED;
8953 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8954 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8955 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8956 dgst_size = DGST_SIZE_4_5;
8957 parse_func = truecrypt_parse_hash_1k;
8958 sort_by_digest = sort_by_digest_4_5;
8959 opti_type = OPTI_TYPE_ZERO_BYTE;
8960 dgst_pos0 = 0;
8961 dgst_pos1 = 1;
8962 dgst_pos2 = 2;
8963 dgst_pos3 = 3;
8964 break;
8965
8966 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8967 salt_type = SALT_TYPE_EMBEDDED;
8968 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8969 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8970 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8971 dgst_size = DGST_SIZE_4_5;
8972 parse_func = truecrypt_parse_hash_1k;
8973 sort_by_digest = sort_by_digest_4_5;
8974 opti_type = OPTI_TYPE_ZERO_BYTE;
8975 dgst_pos0 = 0;
8976 dgst_pos1 = 1;
8977 dgst_pos2 = 2;
8978 dgst_pos3 = 3;
8979 break;
8980
8981 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8982 salt_type = SALT_TYPE_EMBEDDED;
8983 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8984 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8985 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8986 dgst_size = DGST_SIZE_4_5;
8987 parse_func = truecrypt_parse_hash_1k;
8988 sort_by_digest = sort_by_digest_4_5;
8989 opti_type = OPTI_TYPE_ZERO_BYTE;
8990 dgst_pos0 = 0;
8991 dgst_pos1 = 1;
8992 dgst_pos2 = 2;
8993 dgst_pos3 = 3;
8994 break;
8995
8996 case 6300: hash_type = HASH_TYPE_MD5;
8997 salt_type = SALT_TYPE_EMBEDDED;
8998 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8999 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9000 kern_type = KERN_TYPE_MD5AIX;
9001 dgst_size = DGST_SIZE_4_4;
9002 parse_func = md5aix_parse_hash;
9003 sort_by_digest = sort_by_digest_4_4;
9004 opti_type = OPTI_TYPE_ZERO_BYTE;
9005 dgst_pos0 = 0;
9006 dgst_pos1 = 1;
9007 dgst_pos2 = 2;
9008 dgst_pos3 = 3;
9009 break;
9010
9011 case 6400: hash_type = HASH_TYPE_SHA256;
9012 salt_type = SALT_TYPE_EMBEDDED;
9013 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9014 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9015 kern_type = KERN_TYPE_SHA256AIX;
9016 dgst_size = DGST_SIZE_4_8;
9017 parse_func = sha256aix_parse_hash;
9018 sort_by_digest = sort_by_digest_4_8;
9019 opti_type = OPTI_TYPE_ZERO_BYTE;
9020 dgst_pos0 = 0;
9021 dgst_pos1 = 1;
9022 dgst_pos2 = 2;
9023 dgst_pos3 = 3;
9024 break;
9025
9026 case 6500: hash_type = HASH_TYPE_SHA512;
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_SHA512AIX;
9031 dgst_size = DGST_SIZE_8_8;
9032 parse_func = sha512aix_parse_hash;
9033 sort_by_digest = sort_by_digest_8_8;
9034 opti_type = OPTI_TYPE_ZERO_BYTE
9035 | OPTI_TYPE_USES_BITS_64;
9036 dgst_pos0 = 0;
9037 dgst_pos1 = 1;
9038 dgst_pos2 = 2;
9039 dgst_pos3 = 3;
9040 break;
9041
9042 case 6600: hash_type = HASH_TYPE_AES;
9043 salt_type = SALT_TYPE_EMBEDDED;
9044 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9045 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9046 kern_type = KERN_TYPE_AGILEKEY;
9047 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9048 parse_func = agilekey_parse_hash;
9049 sort_by_digest = sort_by_digest_4_5;
9050 opti_type = OPTI_TYPE_ZERO_BYTE;
9051 dgst_pos0 = 0;
9052 dgst_pos1 = 1;
9053 dgst_pos2 = 2;
9054 dgst_pos3 = 3;
9055 break;
9056
9057 case 6700: hash_type = HASH_TYPE_SHA1;
9058 salt_type = SALT_TYPE_EMBEDDED;
9059 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9060 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9061 kern_type = KERN_TYPE_SHA1AIX;
9062 dgst_size = DGST_SIZE_4_5;
9063 parse_func = sha1aix_parse_hash;
9064 sort_by_digest = sort_by_digest_4_5;
9065 opti_type = OPTI_TYPE_ZERO_BYTE;
9066 dgst_pos0 = 0;
9067 dgst_pos1 = 1;
9068 dgst_pos2 = 2;
9069 dgst_pos3 = 3;
9070 break;
9071
9072 case 6800: hash_type = HASH_TYPE_AES;
9073 salt_type = SALT_TYPE_EMBEDDED;
9074 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9075 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9076 kern_type = KERN_TYPE_LASTPASS;
9077 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9078 parse_func = lastpass_parse_hash;
9079 sort_by_digest = sort_by_digest_4_8;
9080 opti_type = OPTI_TYPE_ZERO_BYTE;
9081 dgst_pos0 = 0;
9082 dgst_pos1 = 1;
9083 dgst_pos2 = 2;
9084 dgst_pos3 = 3;
9085 break;
9086
9087 case 6900: hash_type = HASH_TYPE_GOST;
9088 salt_type = SALT_TYPE_NONE;
9089 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9090 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9091 kern_type = KERN_TYPE_GOST;
9092 dgst_size = DGST_SIZE_4_8;
9093 parse_func = gost_parse_hash;
9094 sort_by_digest = sort_by_digest_4_8;
9095 opti_type = OPTI_TYPE_ZERO_BYTE;
9096 dgst_pos0 = 0;
9097 dgst_pos1 = 1;
9098 dgst_pos2 = 2;
9099 dgst_pos3 = 3;
9100 break;
9101
9102 case 7100: hash_type = HASH_TYPE_SHA512;
9103 salt_type = SALT_TYPE_EMBEDDED;
9104 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9105 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9106 kern_type = KERN_TYPE_PBKDF2_SHA512;
9107 dgst_size = DGST_SIZE_8_16;
9108 parse_func = sha512osx_parse_hash;
9109 sort_by_digest = sort_by_digest_8_16;
9110 opti_type = OPTI_TYPE_ZERO_BYTE
9111 | OPTI_TYPE_USES_BITS_64;
9112 dgst_pos0 = 0;
9113 dgst_pos1 = 1;
9114 dgst_pos2 = 2;
9115 dgst_pos3 = 3;
9116 break;
9117
9118 case 7200: hash_type = HASH_TYPE_SHA512;
9119 salt_type = SALT_TYPE_EMBEDDED;
9120 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9121 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9122 kern_type = KERN_TYPE_PBKDF2_SHA512;
9123 dgst_size = DGST_SIZE_8_16;
9124 parse_func = sha512grub_parse_hash;
9125 sort_by_digest = sort_by_digest_8_16;
9126 opti_type = OPTI_TYPE_ZERO_BYTE
9127 | OPTI_TYPE_USES_BITS_64;
9128 dgst_pos0 = 0;
9129 dgst_pos1 = 1;
9130 dgst_pos2 = 2;
9131 dgst_pos3 = 3;
9132 break;
9133
9134 case 7300: hash_type = HASH_TYPE_SHA1;
9135 salt_type = SALT_TYPE_EMBEDDED;
9136 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9137 opts_type = OPTS_TYPE_PT_GENERATE_BE
9138 | OPTS_TYPE_ST_ADD80
9139 | OPTS_TYPE_ST_ADDBITS15;
9140 kern_type = KERN_TYPE_RAKP;
9141 dgst_size = DGST_SIZE_4_5;
9142 parse_func = rakp_parse_hash;
9143 sort_by_digest = sort_by_digest_4_5;
9144 opti_type = OPTI_TYPE_ZERO_BYTE
9145 | OPTI_TYPE_NOT_ITERATED;
9146 dgst_pos0 = 3;
9147 dgst_pos1 = 4;
9148 dgst_pos2 = 2;
9149 dgst_pos3 = 1;
9150 break;
9151
9152 case 7400: hash_type = HASH_TYPE_SHA256;
9153 salt_type = SALT_TYPE_EMBEDDED;
9154 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9155 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9156 kern_type = KERN_TYPE_SHA256CRYPT;
9157 dgst_size = DGST_SIZE_4_8;
9158 parse_func = sha256crypt_parse_hash;
9159 sort_by_digest = sort_by_digest_4_8;
9160 opti_type = OPTI_TYPE_ZERO_BYTE;
9161 dgst_pos0 = 0;
9162 dgst_pos1 = 1;
9163 dgst_pos2 = 2;
9164 dgst_pos3 = 3;
9165 break;
9166
9167 case 7500: hash_type = HASH_TYPE_KRB5PA;
9168 salt_type = SALT_TYPE_EMBEDDED;
9169 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9170 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9171 kern_type = KERN_TYPE_KRB5PA;
9172 dgst_size = DGST_SIZE_4_4;
9173 parse_func = krb5pa_parse_hash;
9174 sort_by_digest = sort_by_digest_4_4;
9175 opti_type = OPTI_TYPE_ZERO_BYTE
9176 | OPTI_TYPE_NOT_ITERATED;
9177 dgst_pos0 = 0;
9178 dgst_pos1 = 1;
9179 dgst_pos2 = 2;
9180 dgst_pos3 = 3;
9181 break;
9182
9183 case 7600: hash_type = HASH_TYPE_SHA1;
9184 salt_type = SALT_TYPE_INTERN;
9185 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9186 opts_type = OPTS_TYPE_PT_GENERATE_BE
9187 | OPTS_TYPE_PT_ADD80
9188 | OPTS_TYPE_PT_ADDBITS15;
9189 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9190 dgst_size = DGST_SIZE_4_5;
9191 parse_func = redmine_parse_hash;
9192 sort_by_digest = sort_by_digest_4_5;
9193 opti_type = OPTI_TYPE_ZERO_BYTE
9194 | OPTI_TYPE_PRECOMPUTE_INIT
9195 | OPTI_TYPE_EARLY_SKIP
9196 | OPTI_TYPE_NOT_ITERATED
9197 | OPTI_TYPE_PREPENDED_SALT;
9198 dgst_pos0 = 3;
9199 dgst_pos1 = 4;
9200 dgst_pos2 = 2;
9201 dgst_pos3 = 1;
9202 break;
9203
9204 case 7700: hash_type = HASH_TYPE_SAPB;
9205 salt_type = SALT_TYPE_EMBEDDED;
9206 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9207 opts_type = OPTS_TYPE_PT_GENERATE_LE
9208 | OPTS_TYPE_PT_UPPER
9209 | OPTS_TYPE_ST_UPPER;
9210 kern_type = KERN_TYPE_SAPB;
9211 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9212 parse_func = sapb_parse_hash;
9213 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9214 opti_type = OPTI_TYPE_ZERO_BYTE
9215 | OPTI_TYPE_PRECOMPUTE_INIT
9216 | OPTI_TYPE_NOT_ITERATED;
9217 dgst_pos0 = 0;
9218 dgst_pos1 = 1;
9219 dgst_pos2 = 2;
9220 dgst_pos3 = 3;
9221 break;
9222
9223 case 7800: hash_type = HASH_TYPE_SAPG;
9224 salt_type = SALT_TYPE_EMBEDDED;
9225 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9226 opts_type = OPTS_TYPE_PT_GENERATE_BE
9227 | OPTS_TYPE_ST_ADD80
9228 | OPTS_TYPE_ST_UPPER;
9229 kern_type = KERN_TYPE_SAPG;
9230 dgst_size = DGST_SIZE_4_5;
9231 parse_func = sapg_parse_hash;
9232 sort_by_digest = sort_by_digest_4_5;
9233 opti_type = OPTI_TYPE_ZERO_BYTE
9234 | OPTI_TYPE_PRECOMPUTE_INIT
9235 | OPTI_TYPE_NOT_ITERATED;
9236 dgst_pos0 = 3;
9237 dgst_pos1 = 4;
9238 dgst_pos2 = 2;
9239 dgst_pos3 = 1;
9240 break;
9241
9242 case 7900: hash_type = HASH_TYPE_SHA512;
9243 salt_type = SALT_TYPE_EMBEDDED;
9244 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9245 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9246 kern_type = KERN_TYPE_DRUPAL7;
9247 dgst_size = DGST_SIZE_8_8;
9248 parse_func = drupal7_parse_hash;
9249 sort_by_digest = sort_by_digest_8_8;
9250 opti_type = OPTI_TYPE_ZERO_BYTE
9251 | OPTI_TYPE_USES_BITS_64;
9252 dgst_pos0 = 0;
9253 dgst_pos1 = 1;
9254 dgst_pos2 = 2;
9255 dgst_pos3 = 3;
9256 break;
9257
9258 case 8000: hash_type = HASH_TYPE_SHA256;
9259 salt_type = SALT_TYPE_EMBEDDED;
9260 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9261 opts_type = OPTS_TYPE_PT_GENERATE_BE
9262 | OPTS_TYPE_PT_UNICODE
9263 | OPTS_TYPE_ST_ADD80
9264 | OPTS_TYPE_ST_HEX;
9265 kern_type = KERN_TYPE_SYBASEASE;
9266 dgst_size = DGST_SIZE_4_8;
9267 parse_func = sybasease_parse_hash;
9268 sort_by_digest = sort_by_digest_4_8;
9269 opti_type = OPTI_TYPE_ZERO_BYTE
9270 | OPTI_TYPE_PRECOMPUTE_INIT
9271 | OPTI_TYPE_EARLY_SKIP
9272 | OPTI_TYPE_NOT_ITERATED
9273 | OPTI_TYPE_RAW_HASH;
9274 dgst_pos0 = 3;
9275 dgst_pos1 = 7;
9276 dgst_pos2 = 2;
9277 dgst_pos3 = 6;
9278 break;
9279
9280 case 8100: hash_type = HASH_TYPE_SHA1;
9281 salt_type = SALT_TYPE_EMBEDDED;
9282 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9283 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9284 kern_type = KERN_TYPE_NETSCALER;
9285 dgst_size = DGST_SIZE_4_5;
9286 parse_func = netscaler_parse_hash;
9287 sort_by_digest = sort_by_digest_4_5;
9288 opti_type = OPTI_TYPE_ZERO_BYTE
9289 | OPTI_TYPE_PRECOMPUTE_INIT
9290 | OPTI_TYPE_PRECOMPUTE_MERKLE
9291 | OPTI_TYPE_EARLY_SKIP
9292 | OPTI_TYPE_NOT_ITERATED
9293 | OPTI_TYPE_PREPENDED_SALT
9294 | OPTI_TYPE_RAW_HASH;
9295 dgst_pos0 = 3;
9296 dgst_pos1 = 4;
9297 dgst_pos2 = 2;
9298 dgst_pos3 = 1;
9299 break;
9300
9301 case 8200: hash_type = HASH_TYPE_SHA256;
9302 salt_type = SALT_TYPE_EMBEDDED;
9303 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9304 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9305 kern_type = KERN_TYPE_CLOUDKEY;
9306 dgst_size = DGST_SIZE_4_8;
9307 parse_func = cloudkey_parse_hash;
9308 sort_by_digest = sort_by_digest_4_8;
9309 opti_type = OPTI_TYPE_ZERO_BYTE;
9310 dgst_pos0 = 0;
9311 dgst_pos1 = 1;
9312 dgst_pos2 = 2;
9313 dgst_pos3 = 3;
9314 break;
9315
9316 case 8300: hash_type = HASH_TYPE_SHA1;
9317 salt_type = SALT_TYPE_EMBEDDED;
9318 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9319 opts_type = OPTS_TYPE_PT_GENERATE_BE
9320 | OPTS_TYPE_ST_HEX
9321 | OPTS_TYPE_ST_ADD80;
9322 kern_type = KERN_TYPE_NSEC3;
9323 dgst_size = DGST_SIZE_4_5;
9324 parse_func = nsec3_parse_hash;
9325 sort_by_digest = sort_by_digest_4_5;
9326 opti_type = OPTI_TYPE_ZERO_BYTE;
9327 dgst_pos0 = 3;
9328 dgst_pos1 = 4;
9329 dgst_pos2 = 2;
9330 dgst_pos3 = 1;
9331 break;
9332
9333 case 8400: hash_type = HASH_TYPE_SHA1;
9334 salt_type = SALT_TYPE_INTERN;
9335 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9336 opts_type = OPTS_TYPE_PT_GENERATE_BE
9337 | OPTS_TYPE_PT_ADD80
9338 | OPTS_TYPE_PT_ADDBITS15;
9339 kern_type = KERN_TYPE_WBB3;
9340 dgst_size = DGST_SIZE_4_5;
9341 parse_func = wbb3_parse_hash;
9342 sort_by_digest = sort_by_digest_4_5;
9343 opti_type = OPTI_TYPE_ZERO_BYTE
9344 | OPTI_TYPE_PRECOMPUTE_INIT
9345 | OPTI_TYPE_NOT_ITERATED;
9346 dgst_pos0 = 3;
9347 dgst_pos1 = 4;
9348 dgst_pos2 = 2;
9349 dgst_pos3 = 1;
9350 break;
9351
9352 case 8500: hash_type = HASH_TYPE_DESRACF;
9353 salt_type = SALT_TYPE_EMBEDDED;
9354 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9355 opts_type = OPTS_TYPE_PT_GENERATE_LE
9356 | OPTS_TYPE_ST_UPPER;
9357 kern_type = KERN_TYPE_RACF;
9358 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9359 parse_func = racf_parse_hash;
9360 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9361 opti_type = OPTI_TYPE_ZERO_BYTE
9362 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9363 dgst_pos0 = 0;
9364 dgst_pos1 = 1;
9365 dgst_pos2 = 2;
9366 dgst_pos3 = 3;
9367 break;
9368
9369 case 8600: hash_type = HASH_TYPE_LOTUS5;
9370 salt_type = SALT_TYPE_NONE;
9371 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9372 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9373 kern_type = KERN_TYPE_LOTUS5;
9374 dgst_size = DGST_SIZE_4_4;
9375 parse_func = lotus5_parse_hash;
9376 sort_by_digest = sort_by_digest_4_4;
9377 opti_type = OPTI_TYPE_EARLY_SKIP
9378 | OPTI_TYPE_NOT_ITERATED
9379 | OPTI_TYPE_NOT_SALTED
9380 | OPTI_TYPE_RAW_HASH;
9381 dgst_pos0 = 0;
9382 dgst_pos1 = 1;
9383 dgst_pos2 = 2;
9384 dgst_pos3 = 3;
9385 break;
9386
9387 case 8700: hash_type = HASH_TYPE_LOTUS6;
9388 salt_type = SALT_TYPE_EMBEDDED;
9389 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9390 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9391 kern_type = KERN_TYPE_LOTUS6;
9392 dgst_size = DGST_SIZE_4_4;
9393 parse_func = lotus6_parse_hash;
9394 sort_by_digest = sort_by_digest_4_4;
9395 opti_type = OPTI_TYPE_EARLY_SKIP
9396 | OPTI_TYPE_NOT_ITERATED
9397 | OPTI_TYPE_RAW_HASH;
9398 dgst_pos0 = 0;
9399 dgst_pos1 = 1;
9400 dgst_pos2 = 2;
9401 dgst_pos3 = 3;
9402 break;
9403
9404 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9405 salt_type = SALT_TYPE_EMBEDDED;
9406 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9407 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9408 kern_type = KERN_TYPE_ANDROIDFDE;
9409 dgst_size = DGST_SIZE_4_4;
9410 parse_func = androidfde_parse_hash;
9411 sort_by_digest = sort_by_digest_4_4;
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 8900: hash_type = HASH_TYPE_SCRYPT;
9420 salt_type = SALT_TYPE_EMBEDDED;
9421 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9422 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9423 kern_type = KERN_TYPE_SCRYPT;
9424 dgst_size = DGST_SIZE_4_8;
9425 parse_func = scrypt_parse_hash;
9426 sort_by_digest = sort_by_digest_4_8;
9427 opti_type = OPTI_TYPE_ZERO_BYTE;
9428 dgst_pos0 = 0;
9429 dgst_pos1 = 1;
9430 dgst_pos2 = 2;
9431 dgst_pos3 = 3;
9432 break;
9433
9434 case 9000: hash_type = HASH_TYPE_SHA1;
9435 salt_type = SALT_TYPE_EMBEDDED;
9436 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9437 opts_type = OPTS_TYPE_PT_GENERATE_LE
9438 | OPTS_TYPE_ST_GENERATE_LE;
9439 kern_type = KERN_TYPE_PSAFE2;
9440 dgst_size = DGST_SIZE_4_5;
9441 parse_func = psafe2_parse_hash;
9442 sort_by_digest = sort_by_digest_4_5;
9443 opti_type = OPTI_TYPE_ZERO_BYTE;
9444 dgst_pos0 = 0;
9445 dgst_pos1 = 1;
9446 dgst_pos2 = 2;
9447 dgst_pos3 = 3;
9448 break;
9449
9450 case 9100: hash_type = HASH_TYPE_LOTUS8;
9451 salt_type = SALT_TYPE_EMBEDDED;
9452 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9453 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9454 kern_type = KERN_TYPE_LOTUS8;
9455 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9456 parse_func = lotus8_parse_hash;
9457 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9458 opti_type = OPTI_TYPE_ZERO_BYTE;
9459 dgst_pos0 = 0;
9460 dgst_pos1 = 1;
9461 dgst_pos2 = 2;
9462 dgst_pos3 = 3;
9463 break;
9464
9465 case 9200: hash_type = HASH_TYPE_SHA256;
9466 salt_type = SALT_TYPE_EMBEDDED;
9467 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9468 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9469 kern_type = KERN_TYPE_PBKDF2_SHA256;
9470 dgst_size = DGST_SIZE_4_32;
9471 parse_func = cisco8_parse_hash;
9472 sort_by_digest = sort_by_digest_4_32;
9473 opti_type = OPTI_TYPE_ZERO_BYTE;
9474 dgst_pos0 = 0;
9475 dgst_pos1 = 1;
9476 dgst_pos2 = 2;
9477 dgst_pos3 = 3;
9478 break;
9479
9480 case 9300: hash_type = HASH_TYPE_SCRYPT;
9481 salt_type = SALT_TYPE_EMBEDDED;
9482 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9483 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9484 kern_type = KERN_TYPE_SCRYPT;
9485 dgst_size = DGST_SIZE_4_8;
9486 parse_func = cisco9_parse_hash;
9487 sort_by_digest = sort_by_digest_4_8;
9488 opti_type = OPTI_TYPE_ZERO_BYTE;
9489 dgst_pos0 = 0;
9490 dgst_pos1 = 1;
9491 dgst_pos2 = 2;
9492 dgst_pos3 = 3;
9493 break;
9494
9495 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9496 salt_type = SALT_TYPE_EMBEDDED;
9497 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9498 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9499 kern_type = KERN_TYPE_OFFICE2007;
9500 dgst_size = DGST_SIZE_4_4;
9501 parse_func = office2007_parse_hash;
9502 sort_by_digest = sort_by_digest_4_4;
9503 opti_type = OPTI_TYPE_ZERO_BYTE;
9504 dgst_pos0 = 0;
9505 dgst_pos1 = 1;
9506 dgst_pos2 = 2;
9507 dgst_pos3 = 3;
9508 break;
9509
9510 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9511 salt_type = SALT_TYPE_EMBEDDED;
9512 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9513 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9514 kern_type = KERN_TYPE_OFFICE2010;
9515 dgst_size = DGST_SIZE_4_4;
9516 parse_func = office2010_parse_hash;
9517 sort_by_digest = sort_by_digest_4_4;
9518 opti_type = OPTI_TYPE_ZERO_BYTE;
9519 dgst_pos0 = 0;
9520 dgst_pos1 = 1;
9521 dgst_pos2 = 2;
9522 dgst_pos3 = 3;
9523 break;
9524
9525 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9526 salt_type = SALT_TYPE_EMBEDDED;
9527 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9528 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9529 kern_type = KERN_TYPE_OFFICE2013;
9530 dgst_size = DGST_SIZE_4_4;
9531 parse_func = office2013_parse_hash;
9532 sort_by_digest = sort_by_digest_4_4;
9533 opti_type = OPTI_TYPE_ZERO_BYTE;
9534 dgst_pos0 = 0;
9535 dgst_pos1 = 1;
9536 dgst_pos2 = 2;
9537 dgst_pos3 = 3;
9538 break;
9539
9540 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9541 salt_type = SALT_TYPE_EMBEDDED;
9542 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9543 opts_type = OPTS_TYPE_PT_GENERATE_LE
9544 | OPTS_TYPE_PT_ADD80
9545 | OPTS_TYPE_PT_UNICODE;
9546 kern_type = KERN_TYPE_OLDOFFICE01;
9547 dgst_size = DGST_SIZE_4_4;
9548 parse_func = oldoffice01_parse_hash;
9549 sort_by_digest = sort_by_digest_4_4;
9550 opti_type = OPTI_TYPE_ZERO_BYTE
9551 | OPTI_TYPE_PRECOMPUTE_INIT
9552 | OPTI_TYPE_NOT_ITERATED;
9553 dgst_pos0 = 0;
9554 dgst_pos1 = 1;
9555 dgst_pos2 = 2;
9556 dgst_pos3 = 3;
9557 break;
9558
9559 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9560 salt_type = SALT_TYPE_EMBEDDED;
9561 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9562 opts_type = OPTS_TYPE_PT_GENERATE_LE
9563 | OPTS_TYPE_PT_ADD80;
9564 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9565 dgst_size = DGST_SIZE_4_4;
9566 parse_func = oldoffice01cm1_parse_hash;
9567 sort_by_digest = sort_by_digest_4_4;
9568 opti_type = OPTI_TYPE_ZERO_BYTE
9569 | OPTI_TYPE_PRECOMPUTE_INIT
9570 | OPTI_TYPE_NOT_ITERATED;
9571 dgst_pos0 = 0;
9572 dgst_pos1 = 1;
9573 dgst_pos2 = 2;
9574 dgst_pos3 = 3;
9575 break;
9576
9577 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9578 salt_type = SALT_TYPE_EMBEDDED;
9579 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9580 opts_type = OPTS_TYPE_PT_GENERATE_LE
9581 | OPTS_TYPE_PT_ADD80
9582 | OPTS_TYPE_PT_UNICODE
9583 | OPTS_TYPE_PT_NEVERCRACK;
9584 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9585 dgst_size = DGST_SIZE_4_4;
9586 parse_func = oldoffice01cm2_parse_hash;
9587 sort_by_digest = sort_by_digest_4_4;
9588 opti_type = OPTI_TYPE_ZERO_BYTE
9589 | OPTI_TYPE_PRECOMPUTE_INIT
9590 | OPTI_TYPE_NOT_ITERATED;
9591 dgst_pos0 = 0;
9592 dgst_pos1 = 1;
9593 dgst_pos2 = 2;
9594 dgst_pos3 = 3;
9595 break;
9596
9597 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9598 salt_type = SALT_TYPE_EMBEDDED;
9599 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9600 opts_type = OPTS_TYPE_PT_GENERATE_BE
9601 | OPTS_TYPE_PT_ADD80
9602 | OPTS_TYPE_PT_UNICODE;
9603 kern_type = KERN_TYPE_OLDOFFICE34;
9604 dgst_size = DGST_SIZE_4_4;
9605 parse_func = oldoffice34_parse_hash;
9606 sort_by_digest = sort_by_digest_4_4;
9607 opti_type = OPTI_TYPE_ZERO_BYTE
9608 | OPTI_TYPE_PRECOMPUTE_INIT
9609 | OPTI_TYPE_NOT_ITERATED;
9610 dgst_pos0 = 0;
9611 dgst_pos1 = 1;
9612 dgst_pos2 = 2;
9613 dgst_pos3 = 3;
9614 break;
9615
9616 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9617 salt_type = SALT_TYPE_EMBEDDED;
9618 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9619 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9620 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9621 dgst_size = DGST_SIZE_4_4;
9622 parse_func = oldoffice34cm1_parse_hash;
9623 sort_by_digest = sort_by_digest_4_4;
9624 opti_type = OPTI_TYPE_ZERO_BYTE
9625 | OPTI_TYPE_PRECOMPUTE_INIT
9626 | OPTI_TYPE_NOT_ITERATED;
9627 dgst_pos0 = 0;
9628 dgst_pos1 = 1;
9629 dgst_pos2 = 2;
9630 dgst_pos3 = 3;
9631 break;
9632
9633 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9634 salt_type = SALT_TYPE_EMBEDDED;
9635 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9636 opts_type = OPTS_TYPE_PT_GENERATE_BE
9637 | OPTS_TYPE_PT_ADD80
9638 | OPTS_TYPE_PT_UNICODE
9639 | OPTS_TYPE_PT_NEVERCRACK;
9640 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9641 dgst_size = DGST_SIZE_4_4;
9642 parse_func = oldoffice34cm2_parse_hash;
9643 sort_by_digest = sort_by_digest_4_4;
9644 opti_type = OPTI_TYPE_ZERO_BYTE
9645 | OPTI_TYPE_PRECOMPUTE_INIT
9646 | OPTI_TYPE_NOT_ITERATED;
9647 dgst_pos0 = 0;
9648 dgst_pos1 = 1;
9649 dgst_pos2 = 2;
9650 dgst_pos3 = 3;
9651 break;
9652
9653 case 9900: hash_type = HASH_TYPE_MD5;
9654 salt_type = SALT_TYPE_NONE;
9655 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9656 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9657 kern_type = KERN_TYPE_RADMIN2;
9658 dgst_size = DGST_SIZE_4_4;
9659 parse_func = radmin2_parse_hash;
9660 sort_by_digest = sort_by_digest_4_4;
9661 opti_type = OPTI_TYPE_ZERO_BYTE
9662 | OPTI_TYPE_PRECOMPUTE_INIT
9663 | OPTI_TYPE_EARLY_SKIP
9664 | OPTI_TYPE_NOT_ITERATED
9665 | OPTI_TYPE_NOT_SALTED;
9666 dgst_pos0 = 0;
9667 dgst_pos1 = 3;
9668 dgst_pos2 = 2;
9669 dgst_pos3 = 1;
9670 break;
9671
9672 case 10000: hash_type = HASH_TYPE_SHA256;
9673 salt_type = SALT_TYPE_EMBEDDED;
9674 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9675 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9676 kern_type = KERN_TYPE_PBKDF2_SHA256;
9677 dgst_size = DGST_SIZE_4_32;
9678 parse_func = djangopbkdf2_parse_hash;
9679 sort_by_digest = sort_by_digest_4_32;
9680 opti_type = OPTI_TYPE_ZERO_BYTE;
9681 dgst_pos0 = 0;
9682 dgst_pos1 = 1;
9683 dgst_pos2 = 2;
9684 dgst_pos3 = 3;
9685 break;
9686
9687 case 10100: hash_type = HASH_TYPE_SIPHASH;
9688 salt_type = SALT_TYPE_EMBEDDED;
9689 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9690 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9691 kern_type = KERN_TYPE_SIPHASH;
9692 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9693 parse_func = siphash_parse_hash;
9694 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9695 opti_type = OPTI_TYPE_ZERO_BYTE
9696 | OPTI_TYPE_NOT_ITERATED
9697 | OPTI_TYPE_RAW_HASH;
9698 dgst_pos0 = 0;
9699 dgst_pos1 = 1;
9700 dgst_pos2 = 2;
9701 dgst_pos3 = 3;
9702 break;
9703
9704 case 10200: hash_type = HASH_TYPE_MD5;
9705 salt_type = SALT_TYPE_EMBEDDED;
9706 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9707 opts_type = OPTS_TYPE_PT_GENERATE_LE
9708 | OPTS_TYPE_ST_ADD80
9709 | OPTS_TYPE_ST_ADDBITS14;
9710 kern_type = KERN_TYPE_HMACMD5_PW;
9711 dgst_size = DGST_SIZE_4_4;
9712 parse_func = crammd5_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 = 3;
9718 dgst_pos2 = 2;
9719 dgst_pos3 = 1;
9720 break;
9721
9722 case 10300: hash_type = HASH_TYPE_SHA1;
9723 salt_type = SALT_TYPE_EMBEDDED;
9724 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9725 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9726 kern_type = KERN_TYPE_SAPH_SHA1;
9727 dgst_size = DGST_SIZE_4_5;
9728 parse_func = saph_sha1_parse_hash;
9729 sort_by_digest = sort_by_digest_4_5;
9730 opti_type = OPTI_TYPE_ZERO_BYTE;
9731 dgst_pos0 = 0;
9732 dgst_pos1 = 1;
9733 dgst_pos2 = 2;
9734 dgst_pos3 = 3;
9735 break;
9736
9737 case 10400: hash_type = HASH_TYPE_PDFU16;
9738 salt_type = SALT_TYPE_EMBEDDED;
9739 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9740 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9741 kern_type = KERN_TYPE_PDF11;
9742 dgst_size = DGST_SIZE_4_4;
9743 parse_func = pdf11_parse_hash;
9744 sort_by_digest = sort_by_digest_4_4;
9745 opti_type = OPTI_TYPE_ZERO_BYTE
9746 | OPTI_TYPE_NOT_ITERATED;
9747 dgst_pos0 = 0;
9748 dgst_pos1 = 1;
9749 dgst_pos2 = 2;
9750 dgst_pos3 = 3;
9751 break;
9752
9753 case 10410: hash_type = HASH_TYPE_PDFU16;
9754 salt_type = SALT_TYPE_EMBEDDED;
9755 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9756 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9757 kern_type = KERN_TYPE_PDF11CM1;
9758 dgst_size = DGST_SIZE_4_4;
9759 parse_func = pdf11cm1_parse_hash;
9760 sort_by_digest = sort_by_digest_4_4;
9761 opti_type = OPTI_TYPE_ZERO_BYTE
9762 | OPTI_TYPE_NOT_ITERATED;
9763 dgst_pos0 = 0;
9764 dgst_pos1 = 1;
9765 dgst_pos2 = 2;
9766 dgst_pos3 = 3;
9767 break;
9768
9769 case 10420: hash_type = HASH_TYPE_PDFU16;
9770 salt_type = SALT_TYPE_EMBEDDED;
9771 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9772 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9773 kern_type = KERN_TYPE_PDF11CM2;
9774 dgst_size = DGST_SIZE_4_4;
9775 parse_func = pdf11cm2_parse_hash;
9776 sort_by_digest = sort_by_digest_4_4;
9777 opti_type = OPTI_TYPE_ZERO_BYTE
9778 | OPTI_TYPE_NOT_ITERATED;
9779 dgst_pos0 = 0;
9780 dgst_pos1 = 1;
9781 dgst_pos2 = 2;
9782 dgst_pos3 = 3;
9783 break;
9784
9785 case 10500: hash_type = HASH_TYPE_PDFU16;
9786 salt_type = SALT_TYPE_EMBEDDED;
9787 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9788 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9789 kern_type = KERN_TYPE_PDF14;
9790 dgst_size = DGST_SIZE_4_4;
9791 parse_func = pdf14_parse_hash;
9792 sort_by_digest = sort_by_digest_4_4;
9793 opti_type = OPTI_TYPE_ZERO_BYTE
9794 | OPTI_TYPE_NOT_ITERATED;
9795 dgst_pos0 = 0;
9796 dgst_pos1 = 1;
9797 dgst_pos2 = 2;
9798 dgst_pos3 = 3;
9799 break;
9800
9801 case 10600: hash_type = HASH_TYPE_SHA256;
9802 salt_type = SALT_TYPE_EMBEDDED;
9803 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9804 opts_type = OPTS_TYPE_PT_GENERATE_BE
9805 | OPTS_TYPE_ST_ADD80
9806 | OPTS_TYPE_ST_ADDBITS15
9807 | OPTS_TYPE_HASH_COPY;
9808 kern_type = KERN_TYPE_SHA256_PWSLT;
9809 dgst_size = DGST_SIZE_4_8;
9810 parse_func = pdf17l3_parse_hash;
9811 sort_by_digest = sort_by_digest_4_8;
9812 opti_type = OPTI_TYPE_ZERO_BYTE
9813 | OPTI_TYPE_PRECOMPUTE_INIT
9814 | OPTI_TYPE_PRECOMPUTE_MERKLE
9815 | OPTI_TYPE_EARLY_SKIP
9816 | OPTI_TYPE_NOT_ITERATED
9817 | OPTI_TYPE_APPENDED_SALT
9818 | OPTI_TYPE_RAW_HASH;
9819 dgst_pos0 = 3;
9820 dgst_pos1 = 7;
9821 dgst_pos2 = 2;
9822 dgst_pos3 = 6;
9823 break;
9824
9825 case 10700: hash_type = HASH_TYPE_PDFU32;
9826 salt_type = SALT_TYPE_EMBEDDED;
9827 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9828 opts_type = OPTS_TYPE_PT_GENERATE_LE
9829 | OPTS_TYPE_HASH_COPY;
9830 kern_type = KERN_TYPE_PDF17L8;
9831 dgst_size = DGST_SIZE_4_8;
9832 parse_func = pdf17l8_parse_hash;
9833 sort_by_digest = sort_by_digest_4_8;
9834 opti_type = OPTI_TYPE_ZERO_BYTE
9835 | OPTI_TYPE_NOT_ITERATED;
9836 dgst_pos0 = 0;
9837 dgst_pos1 = 1;
9838 dgst_pos2 = 2;
9839 dgst_pos3 = 3;
9840 break;
9841
9842 case 10800: hash_type = HASH_TYPE_SHA384;
9843 salt_type = SALT_TYPE_NONE;
9844 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9845 opts_type = OPTS_TYPE_PT_GENERATE_BE
9846 | OPTS_TYPE_PT_ADD80
9847 | OPTS_TYPE_PT_ADDBITS15;
9848 kern_type = KERN_TYPE_SHA384;
9849 dgst_size = DGST_SIZE_8_8;
9850 parse_func = sha384_parse_hash;
9851 sort_by_digest = sort_by_digest_8_8;
9852 opti_type = OPTI_TYPE_ZERO_BYTE
9853 | OPTI_TYPE_PRECOMPUTE_INIT
9854 | OPTI_TYPE_PRECOMPUTE_MERKLE
9855 | OPTI_TYPE_EARLY_SKIP
9856 | OPTI_TYPE_NOT_ITERATED
9857 | OPTI_TYPE_NOT_SALTED
9858 | OPTI_TYPE_USES_BITS_64
9859 | OPTI_TYPE_RAW_HASH;
9860 dgst_pos0 = 6;
9861 dgst_pos1 = 7;
9862 dgst_pos2 = 4;
9863 dgst_pos3 = 5;
9864 break;
9865
9866 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9867 salt_type = SALT_TYPE_EMBEDDED;
9868 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9869 opts_type = OPTS_TYPE_PT_GENERATE_LE
9870 | OPTS_TYPE_ST_BASE64
9871 | OPTS_TYPE_HASH_COPY;
9872 kern_type = KERN_TYPE_PBKDF2_SHA256;
9873 dgst_size = DGST_SIZE_4_32;
9874 parse_func = pbkdf2_sha256_parse_hash;
9875 sort_by_digest = sort_by_digest_4_32;
9876 opti_type = OPTI_TYPE_ZERO_BYTE;
9877 dgst_pos0 = 0;
9878 dgst_pos1 = 1;
9879 dgst_pos2 = 2;
9880 dgst_pos3 = 3;
9881 break;
9882
9883 case 11000: hash_type = HASH_TYPE_MD5;
9884 salt_type = SALT_TYPE_INTERN;
9885 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9886 opts_type = OPTS_TYPE_PT_GENERATE_LE
9887 | OPTS_TYPE_PT_ADD80;
9888 kern_type = KERN_TYPE_PRESTASHOP;
9889 dgst_size = DGST_SIZE_4_4;
9890 parse_func = prestashop_parse_hash;
9891 sort_by_digest = sort_by_digest_4_4;
9892 opti_type = OPTI_TYPE_ZERO_BYTE
9893 | OPTI_TYPE_PRECOMPUTE_INIT
9894 | OPTI_TYPE_NOT_ITERATED
9895 | OPTI_TYPE_PREPENDED_SALT;
9896 dgst_pos0 = 0;
9897 dgst_pos1 = 3;
9898 dgst_pos2 = 2;
9899 dgst_pos3 = 1;
9900 break;
9901
9902 case 11100: hash_type = HASH_TYPE_MD5;
9903 salt_type = SALT_TYPE_EMBEDDED;
9904 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9905 opts_type = OPTS_TYPE_PT_GENERATE_LE
9906 | OPTS_TYPE_ST_ADD80;
9907 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9908 dgst_size = DGST_SIZE_4_4;
9909 parse_func = postgresql_auth_parse_hash;
9910 sort_by_digest = sort_by_digest_4_4;
9911 opti_type = OPTI_TYPE_ZERO_BYTE
9912 | OPTI_TYPE_PRECOMPUTE_INIT
9913 | OPTI_TYPE_PRECOMPUTE_MERKLE
9914 | OPTI_TYPE_EARLY_SKIP;
9915 dgst_pos0 = 0;
9916 dgst_pos1 = 3;
9917 dgst_pos2 = 2;
9918 dgst_pos3 = 1;
9919 break;
9920
9921 case 11200: hash_type = HASH_TYPE_SHA1;
9922 salt_type = SALT_TYPE_EMBEDDED;
9923 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9924 opts_type = OPTS_TYPE_PT_GENERATE_BE
9925 | OPTS_TYPE_PT_ADD80
9926 | OPTS_TYPE_ST_HEX;
9927 kern_type = KERN_TYPE_MYSQL_AUTH;
9928 dgst_size = DGST_SIZE_4_5;
9929 parse_func = mysql_auth_parse_hash;
9930 sort_by_digest = sort_by_digest_4_5;
9931 opti_type = OPTI_TYPE_ZERO_BYTE
9932 | OPTI_TYPE_EARLY_SKIP;
9933 dgst_pos0 = 3;
9934 dgst_pos1 = 4;
9935 dgst_pos2 = 2;
9936 dgst_pos3 = 1;
9937 break;
9938
9939 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9940 salt_type = SALT_TYPE_EMBEDDED;
9941 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9942 opts_type = OPTS_TYPE_PT_GENERATE_LE
9943 | OPTS_TYPE_ST_HEX
9944 | OPTS_TYPE_ST_ADD80;
9945 kern_type = KERN_TYPE_BITCOIN_WALLET;
9946 dgst_size = DGST_SIZE_4_4;
9947 parse_func = bitcoin_wallet_parse_hash;
9948 sort_by_digest = sort_by_digest_4_4;
9949 opti_type = OPTI_TYPE_ZERO_BYTE;
9950 dgst_pos0 = 0;
9951 dgst_pos1 = 1;
9952 dgst_pos2 = 2;
9953 dgst_pos3 = 3;
9954 break;
9955
9956 case 11400: hash_type = HASH_TYPE_MD5;
9957 salt_type = SALT_TYPE_EMBEDDED;
9958 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9959 opts_type = OPTS_TYPE_PT_GENERATE_LE
9960 | OPTS_TYPE_PT_ADD80
9961 | OPTS_TYPE_HASH_COPY;
9962 kern_type = KERN_TYPE_SIP_AUTH;
9963 dgst_size = DGST_SIZE_4_4;
9964 parse_func = sip_auth_parse_hash;
9965 sort_by_digest = sort_by_digest_4_4;
9966 opti_type = OPTI_TYPE_ZERO_BYTE;
9967 dgst_pos0 = 0;
9968 dgst_pos1 = 3;
9969 dgst_pos2 = 2;
9970 dgst_pos3 = 1;
9971 break;
9972
9973 case 11500: hash_type = HASH_TYPE_CRC32;
9974 salt_type = SALT_TYPE_INTERN;
9975 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9976 opts_type = OPTS_TYPE_PT_GENERATE_LE
9977 | OPTS_TYPE_ST_GENERATE_LE
9978 | OPTS_TYPE_ST_HEX;
9979 kern_type = KERN_TYPE_CRC32;
9980 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9981 parse_func = crc32_parse_hash;
9982 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9983 opti_type = OPTI_TYPE_ZERO_BYTE;
9984 dgst_pos0 = 0;
9985 dgst_pos1 = 1;
9986 dgst_pos2 = 2;
9987 dgst_pos3 = 3;
9988 break;
9989
9990 case 11600: hash_type = HASH_TYPE_AES;
9991 salt_type = SALT_TYPE_EMBEDDED;
9992 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9993 opts_type = OPTS_TYPE_PT_GENERATE_LE
9994 | OPTS_TYPE_PT_NEVERCRACK;
9995 kern_type = KERN_TYPE_SEVEN_ZIP;
9996 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9997 parse_func = seven_zip_parse_hash;
9998 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9999 opti_type = OPTI_TYPE_ZERO_BYTE;
10000 dgst_pos0 = 0;
10001 dgst_pos1 = 1;
10002 dgst_pos2 = 2;
10003 dgst_pos3 = 3;
10004 break;
10005
10006 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10007 salt_type = SALT_TYPE_NONE;
10008 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10009 opts_type = OPTS_TYPE_PT_GENERATE_LE
10010 | OPTS_TYPE_PT_ADD01;
10011 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10012 dgst_size = DGST_SIZE_4_8;
10013 parse_func = gost2012sbog_256_parse_hash;
10014 sort_by_digest = sort_by_digest_4_8;
10015 opti_type = OPTI_TYPE_ZERO_BYTE;
10016 dgst_pos0 = 0;
10017 dgst_pos1 = 1;
10018 dgst_pos2 = 2;
10019 dgst_pos3 = 3;
10020 break;
10021
10022 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10023 salt_type = SALT_TYPE_NONE;
10024 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10025 opts_type = OPTS_TYPE_PT_GENERATE_LE
10026 | OPTS_TYPE_PT_ADD01;
10027 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10028 dgst_size = DGST_SIZE_4_16;
10029 parse_func = gost2012sbog_512_parse_hash;
10030 sort_by_digest = sort_by_digest_4_16;
10031 opti_type = OPTI_TYPE_ZERO_BYTE;
10032 dgst_pos0 = 0;
10033 dgst_pos1 = 1;
10034 dgst_pos2 = 2;
10035 dgst_pos3 = 3;
10036 break;
10037
10038 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10039 salt_type = SALT_TYPE_EMBEDDED;
10040 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10041 opts_type = OPTS_TYPE_PT_GENERATE_LE
10042 | OPTS_TYPE_ST_BASE64
10043 | OPTS_TYPE_HASH_COPY;
10044 kern_type = KERN_TYPE_PBKDF2_MD5;
10045 dgst_size = DGST_SIZE_4_32;
10046 parse_func = pbkdf2_md5_parse_hash;
10047 sort_by_digest = sort_by_digest_4_32;
10048 opti_type = OPTI_TYPE_ZERO_BYTE;
10049 dgst_pos0 = 0;
10050 dgst_pos1 = 1;
10051 dgst_pos2 = 2;
10052 dgst_pos3 = 3;
10053 break;
10054
10055 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10056 salt_type = SALT_TYPE_EMBEDDED;
10057 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10058 opts_type = OPTS_TYPE_PT_GENERATE_LE
10059 | OPTS_TYPE_ST_BASE64
10060 | OPTS_TYPE_HASH_COPY;
10061 kern_type = KERN_TYPE_PBKDF2_SHA1;
10062 dgst_size = DGST_SIZE_4_32;
10063 parse_func = pbkdf2_sha1_parse_hash;
10064 sort_by_digest = sort_by_digest_4_32;
10065 opti_type = OPTI_TYPE_ZERO_BYTE;
10066 dgst_pos0 = 0;
10067 dgst_pos1 = 1;
10068 dgst_pos2 = 2;
10069 dgst_pos3 = 3;
10070 break;
10071
10072 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10073 salt_type = SALT_TYPE_EMBEDDED;
10074 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10075 opts_type = OPTS_TYPE_PT_GENERATE_LE
10076 | OPTS_TYPE_ST_BASE64
10077 | OPTS_TYPE_HASH_COPY;
10078 kern_type = KERN_TYPE_PBKDF2_SHA512;
10079 dgst_size = DGST_SIZE_8_16;
10080 parse_func = pbkdf2_sha512_parse_hash;
10081 sort_by_digest = sort_by_digest_8_16;
10082 opti_type = OPTI_TYPE_ZERO_BYTE
10083 | OPTI_TYPE_USES_BITS_64;
10084 dgst_pos0 = 0;
10085 dgst_pos1 = 1;
10086 dgst_pos2 = 2;
10087 dgst_pos3 = 3;
10088 break;
10089
10090 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10091 salt_type = SALT_TYPE_EMBEDDED;
10092 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10093 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10094 kern_type = KERN_TYPE_ECRYPTFS;
10095 dgst_size = DGST_SIZE_8_8;
10096 parse_func = ecryptfs_parse_hash;
10097 sort_by_digest = sort_by_digest_8_8;
10098 opti_type = OPTI_TYPE_ZERO_BYTE
10099 | OPTI_TYPE_USES_BITS_64;
10100 dgst_pos0 = 0;
10101 dgst_pos1 = 1;
10102 dgst_pos2 = 2;
10103 dgst_pos3 = 3;
10104 break;
10105
10106 case 12300: hash_type = HASH_TYPE_ORACLET;
10107 salt_type = SALT_TYPE_EMBEDDED;
10108 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10109 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10110 kern_type = KERN_TYPE_ORACLET;
10111 dgst_size = DGST_SIZE_8_16;
10112 parse_func = oraclet_parse_hash;
10113 sort_by_digest = sort_by_digest_8_16;
10114 opti_type = OPTI_TYPE_ZERO_BYTE
10115 | OPTI_TYPE_USES_BITS_64;
10116 dgst_pos0 = 0;
10117 dgst_pos1 = 1;
10118 dgst_pos2 = 2;
10119 dgst_pos3 = 3;
10120 break;
10121
10122 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10123 salt_type = SALT_TYPE_EMBEDDED;
10124 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10125 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10126 kern_type = KERN_TYPE_BSDICRYPT;
10127 dgst_size = DGST_SIZE_4_4;
10128 parse_func = bsdicrypt_parse_hash;
10129 sort_by_digest = sort_by_digest_4_4;
10130 opti_type = OPTI_TYPE_ZERO_BYTE
10131 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10132 dgst_pos0 = 0;
10133 dgst_pos1 = 1;
10134 dgst_pos2 = 2;
10135 dgst_pos3 = 3;
10136 break;
10137
10138 case 12500: hash_type = HASH_TYPE_RAR3HP;
10139 salt_type = SALT_TYPE_EMBEDDED;
10140 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10141 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10142 kern_type = KERN_TYPE_RAR3;
10143 dgst_size = DGST_SIZE_4_4;
10144 parse_func = rar3hp_parse_hash;
10145 sort_by_digest = sort_by_digest_4_4;
10146 opti_type = OPTI_TYPE_ZERO_BYTE;
10147 dgst_pos0 = 0;
10148 dgst_pos1 = 1;
10149 dgst_pos2 = 2;
10150 dgst_pos3 = 3;
10151 break;
10152
10153 case 12600: hash_type = HASH_TYPE_SHA256;
10154 salt_type = SALT_TYPE_INTERN;
10155 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10156 opts_type = OPTS_TYPE_PT_GENERATE_BE
10157 | OPTS_TYPE_PT_ADD80;
10158 kern_type = KERN_TYPE_CF10;
10159 dgst_size = DGST_SIZE_4_8;
10160 parse_func = cf10_parse_hash;
10161 sort_by_digest = sort_by_digest_4_8;
10162 opti_type = OPTI_TYPE_ZERO_BYTE
10163 | OPTI_TYPE_PRECOMPUTE_INIT
10164 | OPTI_TYPE_EARLY_SKIP
10165 | OPTI_TYPE_NOT_ITERATED;
10166 dgst_pos0 = 3;
10167 dgst_pos1 = 7;
10168 dgst_pos2 = 2;
10169 dgst_pos3 = 6;
10170 break;
10171
10172 case 12700: hash_type = HASH_TYPE_AES;
10173 salt_type = SALT_TYPE_EMBEDDED;
10174 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10175 opts_type = OPTS_TYPE_PT_GENERATE_LE
10176 | OPTS_TYPE_HASH_COPY;
10177 kern_type = KERN_TYPE_MYWALLET;
10178 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10179 parse_func = mywallet_parse_hash;
10180 sort_by_digest = sort_by_digest_4_5;
10181 opti_type = OPTI_TYPE_ZERO_BYTE;
10182 dgst_pos0 = 0;
10183 dgst_pos1 = 1;
10184 dgst_pos2 = 2;
10185 dgst_pos3 = 3;
10186 break;
10187
10188 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10189 salt_type = SALT_TYPE_EMBEDDED;
10190 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10191 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10192 kern_type = KERN_TYPE_MS_DRSR;
10193 dgst_size = DGST_SIZE_4_8;
10194 parse_func = ms_drsr_parse_hash;
10195 sort_by_digest = sort_by_digest_4_8;
10196 opti_type = OPTI_TYPE_ZERO_BYTE;
10197 dgst_pos0 = 0;
10198 dgst_pos1 = 1;
10199 dgst_pos2 = 2;
10200 dgst_pos3 = 3;
10201 break;
10202
10203 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10204 salt_type = SALT_TYPE_EMBEDDED;
10205 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10206 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10207 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10208 dgst_size = DGST_SIZE_4_8;
10209 parse_func = androidfde_samsung_parse_hash;
10210 sort_by_digest = sort_by_digest_4_8;
10211 opti_type = OPTI_TYPE_ZERO_BYTE;
10212 dgst_pos0 = 0;
10213 dgst_pos1 = 1;
10214 dgst_pos2 = 2;
10215 dgst_pos3 = 3;
10216 break;
10217
10218 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10219 salt_type = SALT_TYPE_EMBEDDED;
10220 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10221 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10222 kern_type = KERN_TYPE_RAR5;
10223 dgst_size = DGST_SIZE_4_4;
10224 parse_func = rar5_parse_hash;
10225 sort_by_digest = sort_by_digest_4_4;
10226 opti_type = OPTI_TYPE_ZERO_BYTE;
10227 dgst_pos0 = 0;
10228 dgst_pos1 = 1;
10229 dgst_pos2 = 2;
10230 dgst_pos3 = 3;
10231 break;
10232
10233 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10234 salt_type = SALT_TYPE_EMBEDDED;
10235 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10236 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10237 kern_type = KERN_TYPE_KRB5TGS;
10238 dgst_size = DGST_SIZE_4_4;
10239 parse_func = krb5tgs_parse_hash;
10240 sort_by_digest = sort_by_digest_4_4;
10241 opti_type = OPTI_TYPE_ZERO_BYTE
10242 | OPTI_TYPE_NOT_ITERATED;
10243 dgst_pos0 = 0;
10244 dgst_pos1 = 1;
10245 dgst_pos2 = 2;
10246 dgst_pos3 = 3;
10247 break;
10248
10249 case 13200: hash_type = HASH_TYPE_AES;
10250 salt_type = SALT_TYPE_EMBEDDED;
10251 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10252 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10253 kern_type = KERN_TYPE_AXCRYPT;
10254 dgst_size = DGST_SIZE_4_4;
10255 parse_func = axcrypt_parse_hash;
10256 sort_by_digest = sort_by_digest_4_4;
10257 opti_type = OPTI_TYPE_ZERO_BYTE;
10258 dgst_pos0 = 0;
10259 dgst_pos1 = 1;
10260 dgst_pos2 = 2;
10261 dgst_pos3 = 3;
10262 break;
10263
10264 case 13300: hash_type = HASH_TYPE_SHA1;
10265 salt_type = SALT_TYPE_NONE;
10266 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10267 opts_type = OPTS_TYPE_PT_GENERATE_BE
10268 | OPTS_TYPE_PT_ADD80
10269 | OPTS_TYPE_PT_ADDBITS15;
10270 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10271 dgst_size = DGST_SIZE_4_5;
10272 parse_func = sha1axcrypt_parse_hash;
10273 sort_by_digest = sort_by_digest_4_5;
10274 opti_type = OPTI_TYPE_ZERO_BYTE
10275 | OPTI_TYPE_PRECOMPUTE_INIT
10276 | OPTI_TYPE_EARLY_SKIP
10277 | OPTI_TYPE_NOT_ITERATED
10278 | OPTI_TYPE_NOT_SALTED;
10279 dgst_pos0 = 0;
10280 dgst_pos1 = 4;
10281 dgst_pos2 = 3;
10282 dgst_pos3 = 2;
10283 break;
10284
10285 case 13400: hash_type = HASH_TYPE_AES;
10286 salt_type = SALT_TYPE_EMBEDDED;
10287 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10288 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10289 kern_type = KERN_TYPE_KEEPASS;
10290 dgst_size = DGST_SIZE_4_4;
10291 parse_func = keepass_parse_hash;
10292 sort_by_digest = sort_by_digest_4_4;
10293 opti_type = OPTI_TYPE_ZERO_BYTE;
10294 dgst_pos0 = 0;
10295 dgst_pos1 = 1;
10296 dgst_pos2 = 2;
10297 dgst_pos3 = 3;
10298 break;
10299
10300 default: usage_mini_print (PROGNAME); return (-1);
10301 }
10302
10303 /**
10304 * parser
10305 */
10306
10307 data.parse_func = parse_func;
10308
10309 /**
10310 * misc stuff
10311 */
10312
10313 if (hex_salt)
10314 {
10315 if (salt_type == SALT_TYPE_INTERN)
10316 {
10317 opts_type |= OPTS_TYPE_ST_HEX;
10318 }
10319 else
10320 {
10321 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10322
10323 return (-1);
10324 }
10325 }
10326
10327 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10328 | (salt_type == SALT_TYPE_EXTERN)
10329 | (salt_type == SALT_TYPE_EMBEDDED)
10330 | (salt_type == SALT_TYPE_VIRTUAL));
10331
10332 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10333
10334 data.hash_type = hash_type;
10335 data.attack_mode = attack_mode;
10336 data.attack_kern = attack_kern;
10337 data.attack_exec = attack_exec;
10338 data.kern_type = kern_type;
10339 data.opts_type = opts_type;
10340 data.dgst_size = dgst_size;
10341 data.salt_type = salt_type;
10342 data.isSalted = isSalted;
10343 data.sort_by_digest = sort_by_digest;
10344 data.dgst_pos0 = dgst_pos0;
10345 data.dgst_pos1 = dgst_pos1;
10346 data.dgst_pos2 = dgst_pos2;
10347 data.dgst_pos3 = dgst_pos3;
10348
10349 esalt_size = 0;
10350
10351 switch (hash_mode)
10352 {
10353 case 2500: esalt_size = sizeof (wpa_t); break;
10354 case 5300: esalt_size = sizeof (ikepsk_t); break;
10355 case 5400: esalt_size = sizeof (ikepsk_t); break;
10356 case 5500: esalt_size = sizeof (netntlm_t); break;
10357 case 5600: esalt_size = sizeof (netntlm_t); break;
10358 case 6211: esalt_size = sizeof (tc_t); break;
10359 case 6212: esalt_size = sizeof (tc_t); break;
10360 case 6213: esalt_size = sizeof (tc_t); break;
10361 case 6221: esalt_size = sizeof (tc_t); break;
10362 case 6222: esalt_size = sizeof (tc_t); break;
10363 case 6223: esalt_size = sizeof (tc_t); break;
10364 case 6231: esalt_size = sizeof (tc_t); break;
10365 case 6232: esalt_size = sizeof (tc_t); break;
10366 case 6233: esalt_size = sizeof (tc_t); break;
10367 case 6241: esalt_size = sizeof (tc_t); break;
10368 case 6242: esalt_size = sizeof (tc_t); break;
10369 case 6243: esalt_size = sizeof (tc_t); break;
10370 case 6600: esalt_size = sizeof (agilekey_t); break;
10371 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10372 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10373 case 7300: esalt_size = sizeof (rakp_t); break;
10374 case 7500: esalt_size = sizeof (krb5pa_t); break;
10375 case 8200: esalt_size = sizeof (cloudkey_t); break;
10376 case 8800: esalt_size = sizeof (androidfde_t); break;
10377 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10378 case 9400: esalt_size = sizeof (office2007_t); break;
10379 case 9500: esalt_size = sizeof (office2010_t); break;
10380 case 9600: esalt_size = sizeof (office2013_t); break;
10381 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10382 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10383 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10384 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10385 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10386 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10387 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10388 case 10200: esalt_size = sizeof (cram_md5_t); break;
10389 case 10400: esalt_size = sizeof (pdf_t); break;
10390 case 10410: esalt_size = sizeof (pdf_t); break;
10391 case 10420: esalt_size = sizeof (pdf_t); break;
10392 case 10500: esalt_size = sizeof (pdf_t); break;
10393 case 10600: esalt_size = sizeof (pdf_t); break;
10394 case 10700: esalt_size = sizeof (pdf_t); break;
10395 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10396 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10397 case 11400: esalt_size = sizeof (sip_t); break;
10398 case 11600: esalt_size = sizeof (seven_zip_t); break;
10399 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10400 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10401 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10402 case 13000: esalt_size = sizeof (rar5_t); break;
10403 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10404 case 13400: esalt_size = sizeof (keepass_t); break;
10405 }
10406
10407 data.esalt_size = esalt_size;
10408
10409 /**
10410 * choose dictionary parser
10411 */
10412
10413 if (hash_type == HASH_TYPE_LM)
10414 {
10415 get_next_word_func = get_next_word_lm;
10416 }
10417 else if (opts_type & OPTS_TYPE_PT_UPPER)
10418 {
10419 get_next_word_func = get_next_word_uc;
10420 }
10421 else
10422 {
10423 get_next_word_func = get_next_word_std;
10424 }
10425
10426 /**
10427 * dictstat
10428 */
10429
10430 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10431
10432 #ifdef _POSIX
10433 size_t dictstat_nmemb = 0;
10434 #endif
10435
10436 #ifdef _WIN
10437 uint dictstat_nmemb = 0;
10438 #endif
10439
10440 char dictstat[256] = { 0 };
10441
10442 FILE *dictstat_fp = NULL;
10443
10444 if (keyspace == 0)
10445 {
10446 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10447
10448 dictstat_fp = fopen (dictstat, "rb");
10449
10450 if (dictstat_fp)
10451 {
10452 #ifdef _POSIX
10453 struct stat tmpstat;
10454
10455 fstat (fileno (dictstat_fp), &tmpstat);
10456 #endif
10457
10458 #ifdef _WIN
10459 struct stat64 tmpstat;
10460
10461 _fstat64 (fileno (dictstat_fp), &tmpstat);
10462 #endif
10463
10464 if (tmpstat.st_mtime < COMPTIME)
10465 {
10466 /* with v0.15 the format changed so we have to ensure user is using a good version
10467 since there is no version-header in the dictstat file */
10468
10469 fclose (dictstat_fp);
10470
10471 unlink (dictstat);
10472 }
10473 else
10474 {
10475 while (!feof (dictstat_fp))
10476 {
10477 dictstat_t d;
10478
10479 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10480
10481 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10482
10483 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10484 {
10485 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10486
10487 return -1;
10488 }
10489 }
10490
10491 fclose (dictstat_fp);
10492 }
10493 }
10494 }
10495
10496 /**
10497 * potfile
10498 */
10499
10500 char potfile[256] = { 0 };
10501
10502 if (potfile_path == NULL)
10503 {
10504 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10505 }
10506 else
10507 {
10508 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10509 }
10510
10511 data.pot_fp = NULL;
10512
10513 FILE *out_fp = NULL;
10514 FILE *pot_fp = NULL;
10515
10516 if (show == 1 || left == 1)
10517 {
10518 pot_fp = fopen (potfile, "rb");
10519
10520 if (pot_fp == NULL)
10521 {
10522 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10523
10524 return (-1);
10525 }
10526
10527 if (outfile != NULL)
10528 {
10529 if ((out_fp = fopen (outfile, "ab")) == NULL)
10530 {
10531 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10532
10533 fclose (pot_fp);
10534
10535 return (-1);
10536 }
10537 }
10538 else
10539 {
10540 out_fp = stdout;
10541 }
10542 }
10543 else
10544 {
10545 if (potfile_disable == 0)
10546 {
10547 pot_fp = fopen (potfile, "ab");
10548
10549 if (pot_fp == NULL)
10550 {
10551 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10552
10553 return (-1);
10554 }
10555
10556 data.pot_fp = pot_fp;
10557 }
10558 }
10559
10560 pot_t *pot = NULL;
10561
10562 uint pot_cnt = 0;
10563 uint pot_avail = 0;
10564
10565 if (show == 1 || left == 1)
10566 {
10567 SUPPRESS_OUTPUT = 1;
10568
10569 pot_avail = count_lines (pot_fp);
10570
10571 rewind (pot_fp);
10572
10573 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10574
10575 uint pot_hashes_avail = 0;
10576
10577 uint line_num = 0;
10578
10579 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10580
10581 while (!feof (pot_fp))
10582 {
10583 line_num++;
10584
10585 int line_len = fgetl (pot_fp, line_buf);
10586
10587 if (line_len == 0) continue;
10588
10589 char *plain_buf = line_buf + line_len;
10590
10591 pot_t *pot_ptr = &pot[pot_cnt];
10592
10593 hash_t *hashes_buf = &pot_ptr->hash;
10594
10595 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10596 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10597
10598 if (pot_cnt == pot_hashes_avail)
10599 {
10600 uint pos = 0;
10601
10602 for (pos = 0; pos < INCR_POT; pos++)
10603 {
10604 if ((pot_cnt + pos) >= pot_avail) break;
10605
10606 pot_t *tmp_pot = &pot[pot_cnt + pos];
10607
10608 hash_t *tmp_hash = &tmp_pot->hash;
10609
10610 tmp_hash->digest = mymalloc (dgst_size);
10611
10612 if (isSalted)
10613 {
10614 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10615 }
10616
10617 if (esalt_size)
10618 {
10619 tmp_hash->esalt = mymalloc (esalt_size);
10620 }
10621
10622 pot_hashes_avail++;
10623 }
10624 }
10625
10626 int plain_len = 0;
10627
10628 int parser_status;
10629
10630 int iter = MAX_CUT_TRIES;
10631
10632 do
10633 {
10634 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10635 {
10636 if (line_buf[i] == ':')
10637 {
10638 line_len--;
10639
10640 break;
10641 }
10642 }
10643
10644 if (data.hash_mode != 2500)
10645 {
10646 parser_status = parse_func (line_buf, line_len, hashes_buf);
10647 }
10648 else
10649 {
10650 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10651
10652 if (line_len > max_salt_size)
10653 {
10654 parser_status = PARSER_GLOBAL_LENGTH;
10655 }
10656 else
10657 {
10658 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10659
10660 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10661
10662 hashes_buf->salt->salt_len = line_len;
10663
10664 parser_status = PARSER_OK;
10665 }
10666 }
10667
10668 // if NOT parsed without error, we add the ":" to the plain
10669
10670 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10671 {
10672 plain_len++;
10673 plain_buf--;
10674 }
10675
10676 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10677
10678 if (parser_status < PARSER_GLOBAL_ZERO)
10679 {
10680 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10681
10682 continue;
10683 }
10684
10685 if (plain_len >= 255) continue;
10686
10687 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10688
10689 pot_ptr->plain_len = plain_len;
10690
10691 pot_cnt++;
10692 }
10693
10694 myfree (line_buf);
10695
10696 fclose (pot_fp);
10697
10698 SUPPRESS_OUTPUT = 0;
10699
10700 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10701 }
10702
10703 /**
10704 * word len
10705 */
10706
10707 uint pw_min = PW_MIN;
10708 uint pw_max = PW_MAX;
10709
10710 switch (hash_mode)
10711 {
10712 case 125: if (pw_max > 32) pw_max = 32;
10713 break;
10714 case 400: if (pw_max > 40) pw_max = 40;
10715 break;
10716 case 500: if (pw_max > 16) pw_max = 16;
10717 break;
10718 case 1500: if (pw_max > 8) pw_max = 8;
10719 break;
10720 case 1600: if (pw_max > 16) pw_max = 16;
10721 break;
10722 case 1800: if (pw_max > 16) pw_max = 16;
10723 break;
10724 case 2100: if (pw_max > 16) pw_max = 16;
10725 break;
10726 case 2500: if (pw_min < 8) pw_min = 8;
10727 break;
10728 case 3000: if (pw_max > 7) pw_max = 7;
10729 break;
10730 case 5200: if (pw_max > 24) pw_max = 24;
10731 break;
10732 case 5800: if (pw_max > 16) pw_max = 16;
10733 break;
10734 case 6300: if (pw_max > 16) pw_max = 16;
10735 break;
10736 case 7400: if (pw_max > 16) pw_max = 16;
10737 break;
10738 case 7900: if (pw_max > 48) pw_max = 48;
10739 break;
10740 case 8500: if (pw_max > 8) pw_max = 8;
10741 break;
10742 case 8600: if (pw_max > 16) pw_max = 16;
10743 break;
10744 case 9710: pw_min = 5;
10745 pw_max = 5;
10746 break;
10747 case 9810: pw_min = 5;
10748 pw_max = 5;
10749 break;
10750 case 10410: pw_min = 5;
10751 pw_max = 5;
10752 break;
10753 case 10300: if (pw_max < 3) pw_min = 3;
10754 if (pw_max > 40) pw_max = 40;
10755 break;
10756 case 10500: if (pw_max < 3) pw_min = 3;
10757 if (pw_max > 40) pw_max = 40;
10758 break;
10759 case 10700: if (pw_max > 16) pw_max = 16;
10760 break;
10761 case 11300: if (pw_max > 40) pw_max = 40;
10762 break;
10763 case 12500: if (pw_max > 20) pw_max = 20;
10764 break;
10765 case 12800: if (pw_max > 24) pw_max = 24;
10766 break;
10767 }
10768
10769 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10770 {
10771 switch (attack_kern)
10772 {
10773 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10774 break;
10775 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10776 break;
10777 }
10778 }
10779
10780 /**
10781 * charsets : keep them together for more easy maintainnce
10782 */
10783
10784 cs_t mp_sys[6] = { { { 0 }, 0 } };
10785 cs_t mp_usr[4] = { { { 0 }, 0 } };
10786
10787 mp_setup_sys (mp_sys);
10788
10789 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10790 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10791 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10792 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10793
10794 /**
10795 * load hashes, part I: find input mode, count hashes
10796 */
10797
10798 uint hashlist_mode = 0;
10799 uint hashlist_format = HLFMT_HASHCAT;
10800
10801 uint hashes_avail = 0;
10802
10803 if (benchmark == 0)
10804 {
10805 struct stat f;
10806
10807 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10808
10809 if ((hash_mode == 2500) ||
10810 (hash_mode == 5200) ||
10811 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10812 (hash_mode == 9000))
10813 {
10814 hashlist_mode = HL_MODE_ARG;
10815
10816 char *hashfile = myargv[optind];
10817
10818 data.hashfile = hashfile;
10819
10820 logfile_top_var_string ("target", hashfile);
10821 }
10822
10823 if (hashlist_mode == HL_MODE_ARG)
10824 {
10825 if (hash_mode == 2500)
10826 {
10827 struct stat st;
10828
10829 if (stat (data.hashfile, &st) == -1)
10830 {
10831 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10832
10833 return (-1);
10834 }
10835
10836 hashes_avail = st.st_size / sizeof (hccap_t);
10837 }
10838 else
10839 {
10840 hashes_avail = 1;
10841 }
10842 }
10843 else if (hashlist_mode == HL_MODE_FILE)
10844 {
10845 char *hashfile = myargv[optind];
10846
10847 data.hashfile = hashfile;
10848
10849 logfile_top_var_string ("target", hashfile);
10850
10851 FILE *fp = NULL;
10852
10853 if ((fp = fopen (hashfile, "rb")) == NULL)
10854 {
10855 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10856
10857 return (-1);
10858 }
10859
10860 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10861
10862 hashes_avail = count_lines (fp);
10863
10864 rewind (fp);
10865
10866 if (hashes_avail == 0)
10867 {
10868 log_error ("ERROR: hashfile is empty or corrupt");
10869
10870 fclose (fp);
10871
10872 return (-1);
10873 }
10874
10875 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10876
10877 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10878 {
10879 log_error ("ERROR: remove not supported in native hashfile-format mode");
10880
10881 fclose (fp);
10882
10883 return (-1);
10884 }
10885
10886 fclose (fp);
10887 }
10888 }
10889 else
10890 {
10891 hashlist_mode = HL_MODE_ARG;
10892
10893 hashes_avail = 1;
10894 }
10895
10896 if (hash_mode == 3000) hashes_avail *= 2;
10897
10898 data.hashlist_mode = hashlist_mode;
10899 data.hashlist_format = hashlist_format;
10900
10901 logfile_top_uint (hashlist_mode);
10902 logfile_top_uint (hashlist_format);
10903
10904 /**
10905 * load hashes, part II: allocate required memory, set pointers
10906 */
10907
10908 hash_t *hashes_buf = NULL;
10909 void *digests_buf = NULL;
10910 salt_t *salts_buf = NULL;
10911 void *esalts_buf = NULL;
10912
10913 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10914
10915 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10916
10917 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10918 {
10919 u32 hash_pos;
10920
10921 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10922 {
10923 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10924
10925 hashes_buf[hash_pos].hash_info = hash_info;
10926
10927 if (username && (remove || show || left))
10928 {
10929 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10930 }
10931
10932 if (benchmark)
10933 {
10934 hash_info->orighash = (char *) mymalloc (256);
10935 }
10936 }
10937 }
10938
10939 if (isSalted)
10940 {
10941 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10942
10943 if (esalt_size)
10944 {
10945 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10946 }
10947 }
10948 else
10949 {
10950 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10951 }
10952
10953 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10954 {
10955 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10956
10957 if (isSalted)
10958 {
10959 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10960
10961 if (esalt_size)
10962 {
10963 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10964 }
10965 }
10966 else
10967 {
10968 hashes_buf[hash_pos].salt = &salts_buf[0];
10969 }
10970 }
10971
10972 /**
10973 * load hashes, part III: parse hashes or generate them if benchmark
10974 */
10975
10976 uint hashes_cnt = 0;
10977
10978 if (benchmark == 0)
10979 {
10980 if (keyspace == 1)
10981 {
10982 // useless to read hash file for keyspace, cheat a little bit w/ optind
10983 }
10984 else if (hashes_avail == 0)
10985 {
10986 }
10987 else if (hashlist_mode == HL_MODE_ARG)
10988 {
10989 char *input_buf = myargv[optind];
10990
10991 uint input_len = strlen (input_buf);
10992
10993 logfile_top_var_string ("target", input_buf);
10994
10995 char *hash_buf = NULL;
10996 int hash_len = 0;
10997
10998 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10999
11000 bool hash_fmt_error = 0;
11001
11002 if (hash_len < 1) hash_fmt_error = 1;
11003 if (hash_buf == NULL) hash_fmt_error = 1;
11004
11005 if (hash_fmt_error)
11006 {
11007 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11008 }
11009 else
11010 {
11011 if (opts_type & OPTS_TYPE_HASH_COPY)
11012 {
11013 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11014
11015 hash_info_tmp->orighash = mystrdup (hash_buf);
11016 }
11017
11018 if (isSalted)
11019 {
11020 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11021 }
11022
11023 int parser_status = PARSER_OK;
11024
11025 if (hash_mode == 2500)
11026 {
11027 if (hash_len == 0)
11028 {
11029 log_error ("ERROR: hccap file not specified");
11030
11031 return (-1);
11032 }
11033
11034 hashlist_mode = HL_MODE_FILE;
11035
11036 data.hashlist_mode = hashlist_mode;
11037
11038 FILE *fp = fopen (hash_buf, "rb");
11039
11040 if (fp == NULL)
11041 {
11042 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11043
11044 return (-1);
11045 }
11046
11047 if (hashes_avail < 1)
11048 {
11049 log_error ("ERROR: hccap file is empty or corrupt");
11050
11051 fclose (fp);
11052
11053 return (-1);
11054 }
11055
11056 uint hccap_size = sizeof (hccap_t);
11057
11058 char *in = (char *) mymalloc (hccap_size);
11059
11060 while (!feof (fp))
11061 {
11062 int n = fread (in, hccap_size, 1, fp);
11063
11064 if (n != 1)
11065 {
11066 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11067
11068 break;
11069 }
11070
11071 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11072
11073 if (parser_status != PARSER_OK)
11074 {
11075 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11076
11077 continue;
11078 }
11079
11080 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11081
11082 if ((show == 1) || (left == 1))
11083 {
11084 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11085
11086 char *salt_ptr = (char *) tmp_salt->salt_buf;
11087
11088 int cur_pos = tmp_salt->salt_len;
11089 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11090
11091 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11092
11093 // do the appending task
11094
11095 snprintf (salt_ptr + cur_pos,
11096 rem_len,
11097 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11098 wpa->orig_mac1[0],
11099 wpa->orig_mac1[1],
11100 wpa->orig_mac1[2],
11101 wpa->orig_mac1[3],
11102 wpa->orig_mac1[4],
11103 wpa->orig_mac1[5],
11104 wpa->orig_mac2[0],
11105 wpa->orig_mac2[1],
11106 wpa->orig_mac2[2],
11107 wpa->orig_mac2[3],
11108 wpa->orig_mac2[4],
11109 wpa->orig_mac2[5]);
11110
11111 // memset () the remaining part of the salt
11112
11113 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11114 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11115
11116 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11117
11118 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11119 }
11120
11121 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);
11122 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);
11123
11124 hashes_cnt++;
11125 }
11126
11127 fclose (fp);
11128
11129 myfree (in);
11130 }
11131 else if (hash_mode == 3000)
11132 {
11133 if (hash_len == 32)
11134 {
11135 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11136
11137 hash_t *lm_hash_left = NULL;
11138
11139 if (parser_status == PARSER_OK)
11140 {
11141 lm_hash_left = &hashes_buf[hashes_cnt];
11142
11143 hashes_cnt++;
11144 }
11145 else
11146 {
11147 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11148 }
11149
11150 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11151
11152 hash_t *lm_hash_right = NULL;
11153
11154 if (parser_status == PARSER_OK)
11155 {
11156 lm_hash_right = &hashes_buf[hashes_cnt];
11157
11158 hashes_cnt++;
11159 }
11160 else
11161 {
11162 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11163 }
11164
11165 // show / left
11166
11167 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11168 {
11169 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);
11170 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);
11171 }
11172 }
11173 else
11174 {
11175 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11176
11177 if (parser_status == PARSER_OK)
11178 {
11179 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11180 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11181 }
11182
11183 if (parser_status == PARSER_OK)
11184 {
11185 hashes_cnt++;
11186 }
11187 else
11188 {
11189 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11190 }
11191 }
11192 }
11193 else
11194 {
11195 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11196
11197 if (parser_status == PARSER_OK)
11198 {
11199 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11200 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11201 }
11202
11203 if (parser_status == PARSER_OK)
11204 {
11205 hashes_cnt++;
11206 }
11207 else
11208 {
11209 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11210 }
11211 }
11212 }
11213 }
11214 else if (hashlist_mode == HL_MODE_FILE)
11215 {
11216 char *hashfile = data.hashfile;
11217
11218 FILE *fp;
11219
11220 if ((fp = fopen (hashfile, "rb")) == NULL)
11221 {
11222 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11223
11224 return (-1);
11225 }
11226
11227 uint line_num = 0;
11228
11229 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11230
11231 while (!feof (fp))
11232 {
11233 line_num++;
11234
11235 int line_len = fgetl (fp, line_buf);
11236
11237 if (line_len == 0) continue;
11238
11239 char *hash_buf = NULL;
11240 int hash_len = 0;
11241
11242 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11243
11244 bool hash_fmt_error = 0;
11245
11246 if (hash_len < 1) hash_fmt_error = 1;
11247 if (hash_buf == NULL) hash_fmt_error = 1;
11248
11249 if (hash_fmt_error)
11250 {
11251 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11252
11253 continue;
11254 }
11255
11256 if (username)
11257 {
11258 char *user_buf = NULL;
11259 int user_len = 0;
11260
11261 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11262
11263 if (remove || show)
11264 {
11265 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11266
11267 *user = (user_t *) mymalloc (sizeof (user_t));
11268
11269 user_t *user_ptr = *user;
11270
11271 if (user_buf != NULL)
11272 {
11273 user_ptr->user_name = mystrdup (user_buf);
11274 }
11275 else
11276 {
11277 user_ptr->user_name = mystrdup ("");
11278 }
11279
11280 user_ptr->user_len = user_len;
11281 }
11282 }
11283
11284 if (opts_type & OPTS_TYPE_HASH_COPY)
11285 {
11286 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11287
11288 hash_info_tmp->orighash = mystrdup (hash_buf);
11289 }
11290
11291 if (isSalted)
11292 {
11293 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11294 }
11295
11296 if (hash_mode == 3000)
11297 {
11298 if (hash_len == 32)
11299 {
11300 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11301
11302 if (parser_status < PARSER_GLOBAL_ZERO)
11303 {
11304 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11305
11306 continue;
11307 }
11308
11309 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11310
11311 hashes_cnt++;
11312
11313 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11314
11315 if (parser_status < PARSER_GLOBAL_ZERO)
11316 {
11317 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11318
11319 continue;
11320 }
11321
11322 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11323
11324 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);
11325
11326 hashes_cnt++;
11327
11328 // show / left
11329
11330 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);
11331 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);
11332 }
11333 else
11334 {
11335 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11336
11337 if (parser_status < PARSER_GLOBAL_ZERO)
11338 {
11339 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11340
11341 continue;
11342 }
11343
11344 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);
11345
11346 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11347 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11348
11349 hashes_cnt++;
11350 }
11351 }
11352 else
11353 {
11354 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11355
11356 if (parser_status < PARSER_GLOBAL_ZERO)
11357 {
11358 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11359
11360 continue;
11361 }
11362
11363 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);
11364
11365 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11366 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11367
11368 hashes_cnt++;
11369 }
11370 }
11371
11372 myfree (line_buf);
11373
11374 fclose (fp);
11375
11376 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11377
11378 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11379 }
11380 }
11381 else
11382 {
11383 if (isSalted)
11384 {
11385 hashes_buf[0].salt->salt_len = 8;
11386
11387 // special salt handling
11388
11389 switch (hash_mode)
11390 {
11391 case 1500: hashes_buf[0].salt->salt_len = 2;
11392 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11393 break;
11394 case 1731: hashes_buf[0].salt->salt_len = 4;
11395 break;
11396 case 2410: hashes_buf[0].salt->salt_len = 4;
11397 break;
11398 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11399 break;
11400 case 3100: hashes_buf[0].salt->salt_len = 1;
11401 break;
11402 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11403 break;
11404 case 5800: hashes_buf[0].salt->salt_len = 16;
11405 break;
11406 case 6800: hashes_buf[0].salt->salt_len = 32;
11407 break;
11408 case 8400: hashes_buf[0].salt->salt_len = 40;
11409 break;
11410 case 8800: hashes_buf[0].salt->salt_len = 16;
11411 break;
11412 case 8900: hashes_buf[0].salt->salt_len = 16;
11413 hashes_buf[0].salt->scrypt_N = 1024;
11414 hashes_buf[0].salt->scrypt_r = 1;
11415 hashes_buf[0].salt->scrypt_p = 1;
11416 break;
11417 case 9100: hashes_buf[0].salt->salt_len = 16;
11418 break;
11419 case 9300: hashes_buf[0].salt->salt_len = 14;
11420 hashes_buf[0].salt->scrypt_N = 16384;
11421 hashes_buf[0].salt->scrypt_r = 1;
11422 hashes_buf[0].salt->scrypt_p = 1;
11423 break;
11424 case 9400: hashes_buf[0].salt->salt_len = 16;
11425 break;
11426 case 9500: hashes_buf[0].salt->salt_len = 16;
11427 break;
11428 case 9600: hashes_buf[0].salt->salt_len = 16;
11429 break;
11430 case 9700: hashes_buf[0].salt->salt_len = 16;
11431 break;
11432 case 9710: hashes_buf[0].salt->salt_len = 16;
11433 break;
11434 case 9720: hashes_buf[0].salt->salt_len = 16;
11435 break;
11436 case 9800: hashes_buf[0].salt->salt_len = 16;
11437 break;
11438 case 9810: hashes_buf[0].salt->salt_len = 16;
11439 break;
11440 case 9820: hashes_buf[0].salt->salt_len = 16;
11441 break;
11442 case 10300: hashes_buf[0].salt->salt_len = 12;
11443 break;
11444 case 11500: hashes_buf[0].salt->salt_len = 4;
11445 break;
11446 case 11600: hashes_buf[0].salt->salt_len = 4;
11447 break;
11448 case 12400: hashes_buf[0].salt->salt_len = 4;
11449 break;
11450 case 12500: hashes_buf[0].salt->salt_len = 8;
11451 break;
11452 case 12600: hashes_buf[0].salt->salt_len = 64;
11453 break;
11454 }
11455
11456 // special esalt handling
11457
11458 switch (hash_mode)
11459 {
11460 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11461 break;
11462 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11463 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11464 break;
11465 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11466 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11467 break;
11468 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11469 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11470 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11471 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11472 break;
11473 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11474 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11475 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11476 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11477 break;
11478 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11479 break;
11480 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11481 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11482 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11483 break;
11484 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11485 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11486 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11487 break;
11488 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11489 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11490 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11491 break;
11492 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11493 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11494 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11495 break;
11496 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11497 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11498 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11499 break;
11500 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11501 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11502 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11503 break;
11504 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11505 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11506 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11507 break;
11508 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11509 break;
11510 }
11511 }
11512
11513 // set hashfile
11514
11515 switch (hash_mode)
11516 {
11517 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11518 break;
11519 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11520 break;
11521 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11522 break;
11523 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11524 break;
11525 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11526 break;
11527 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11528 break;
11529 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11530 break;
11531 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11532 break;
11533 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11534 break;
11535 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11536 break;
11537 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11538 break;
11539 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11540 break;
11541 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11542 break;
11543 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11544 break;
11545 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11546 break;
11547 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11548 break;
11549 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11550 break;
11551 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11552 break;
11553 }
11554
11555 // set default iterations
11556
11557 switch (hash_mode)
11558 {
11559 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11560 break;
11561 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11562 break;
11563 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11564 break;
11565 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11566 break;
11567 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11568 break;
11569 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11570 break;
11571 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11572 break;
11573 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11574 break;
11575 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11576 break;
11577 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11578 break;
11579 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11580 break;
11581 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11582 break;
11583 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11584 break;
11585 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11586 break;
11587 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11588 break;
11589 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11590 break;
11591 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11592 break;
11593 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11594 break;
11595 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11596 break;
11597 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11598 break;
11599 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11600 break;
11601 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11602 break;
11603 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11604 break;
11605 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11606 break;
11607 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11608 break;
11609 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11610 break;
11611 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11612 break;
11613 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11614 break;
11615 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11616 break;
11617 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11618 break;
11619 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11620 break;
11621 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11622 break;
11623 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11624 break;
11625 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11626 break;
11627 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11628 break;
11629 case 8900: hashes_buf[0].salt->salt_iter = 1;
11630 break;
11631 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11632 break;
11633 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11634 break;
11635 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11636 break;
11637 case 9300: hashes_buf[0].salt->salt_iter = 1;
11638 break;
11639 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11640 break;
11641 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11642 break;
11643 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11644 break;
11645 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11646 break;
11647 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11648 break;
11649 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11650 break;
11651 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11652 break;
11653 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11654 break;
11655 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11656 break;
11657 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11658 break;
11659 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11660 break;
11661 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11662 break;
11663 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11664 break;
11665 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11666 break;
11667 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11668 break;
11669 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11670 break;
11671 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11672 break;
11673 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11674 break;
11675 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11676 break;
11677 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11678 break;
11679 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11680 break;
11681 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
11682 break;
11683 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
11684 break;
11685 }
11686
11687 hashes_cnt = 1;
11688 }
11689
11690 if (show == 1 || left == 1)
11691 {
11692 for (uint i = 0; i < pot_cnt; i++)
11693 {
11694 pot_t *pot_ptr = &pot[i];
11695
11696 hash_t *hashes_buf = &pot_ptr->hash;
11697
11698 local_free (hashes_buf->digest);
11699
11700 if (isSalted)
11701 {
11702 local_free (hashes_buf->salt);
11703 }
11704 }
11705
11706 local_free (pot);
11707
11708 if (data.quiet == 0) log_info_nn ("");
11709
11710 return (0);
11711 }
11712
11713 if (keyspace == 0)
11714 {
11715 if (hashes_cnt == 0)
11716 {
11717 log_error ("ERROR: No hashes loaded");
11718
11719 return (-1);
11720 }
11721 }
11722
11723 /**
11724 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11725 */
11726
11727 if (data.outfile != NULL)
11728 {
11729 if (data.hashfile != NULL)
11730 {
11731 #ifdef _POSIX
11732 struct stat tmpstat_outfile;
11733 struct stat tmpstat_hashfile;
11734 #endif
11735
11736 #ifdef _WIN
11737 struct stat64 tmpstat_outfile;
11738 struct stat64 tmpstat_hashfile;
11739 #endif
11740
11741 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11742
11743 if (tmp_outfile_fp)
11744 {
11745 #ifdef _POSIX
11746 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11747 #endif
11748
11749 #ifdef _WIN
11750 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11751 #endif
11752
11753 fclose (tmp_outfile_fp);
11754 }
11755
11756 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11757
11758 if (tmp_hashfile_fp)
11759 {
11760 #ifdef _POSIX
11761 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11762 #endif
11763
11764 #ifdef _WIN
11765 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11766 #endif
11767
11768 fclose (tmp_hashfile_fp);
11769 }
11770
11771 if (tmp_outfile_fp && tmp_outfile_fp)
11772 {
11773 tmpstat_outfile.st_mode = 0;
11774 tmpstat_outfile.st_nlink = 0;
11775 tmpstat_outfile.st_uid = 0;
11776 tmpstat_outfile.st_gid = 0;
11777 tmpstat_outfile.st_rdev = 0;
11778 tmpstat_outfile.st_atime = 0;
11779
11780 tmpstat_hashfile.st_mode = 0;
11781 tmpstat_hashfile.st_nlink = 0;
11782 tmpstat_hashfile.st_uid = 0;
11783 tmpstat_hashfile.st_gid = 0;
11784 tmpstat_hashfile.st_rdev = 0;
11785 tmpstat_hashfile.st_atime = 0;
11786
11787 #ifdef _POSIX
11788 tmpstat_outfile.st_blksize = 0;
11789 tmpstat_outfile.st_blocks = 0;
11790
11791 tmpstat_hashfile.st_blksize = 0;
11792 tmpstat_hashfile.st_blocks = 0;
11793 #endif
11794
11795 #ifdef _POSIX
11796 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11797 {
11798 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11799
11800 return (-1);
11801 }
11802 #endif
11803
11804 #ifdef _WIN
11805 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11806 {
11807 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11808
11809 return (-1);
11810 }
11811 #endif
11812 }
11813 }
11814 }
11815
11816 /**
11817 * Remove duplicates
11818 */
11819
11820 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11821
11822 if (isSalted)
11823 {
11824 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11825 }
11826 else
11827 {
11828 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11829 }
11830
11831 uint hashes_cnt_orig = hashes_cnt;
11832
11833 hashes_cnt = 1;
11834
11835 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11836 {
11837 if (isSalted)
11838 {
11839 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11840 {
11841 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11842 }
11843 }
11844 else
11845 {
11846 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11847 }
11848
11849 if (hashes_pos > hashes_cnt)
11850 {
11851 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11852 }
11853
11854 hashes_cnt++;
11855 }
11856
11857 /**
11858 * Potfile removes
11859 */
11860
11861 uint potfile_remove_cracks = 0;
11862
11863 if (potfile_disable == 0)
11864 {
11865 hash_t hash_buf;
11866
11867 hash_buf.digest = mymalloc (dgst_size);
11868 hash_buf.salt = NULL;
11869 hash_buf.esalt = NULL;
11870 hash_buf.hash_info = NULL;
11871 hash_buf.cracked = 0;
11872
11873 if (isSalted)
11874 {
11875 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11876 }
11877
11878 if (esalt_size)
11879 {
11880 hash_buf.esalt = mymalloc (esalt_size);
11881 }
11882
11883 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11884
11885 // no solution for these special hash types (for instane because they use hashfile in output etc)
11886 if ((hash_mode != 5200) &&
11887 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11888 (hash_mode != 9000))
11889 {
11890 FILE *fp = fopen (potfile, "rb");
11891
11892 if (fp != NULL)
11893 {
11894 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11895
11896 // to be safe work with a copy (because of line_len loop, i etc)
11897 // moved up here because it's easier to handle continue case
11898 // it's just 64kb
11899
11900 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
11901
11902 while (!feof (fp))
11903 {
11904 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
11905
11906 if (ptr == NULL) break;
11907
11908 int line_len = strlen (line_buf);
11909
11910 if (line_len == 0) continue;
11911
11912 int iter = MAX_CUT_TRIES;
11913
11914 for (int i = line_len - 1; i && iter; i--, line_len--)
11915 {
11916 if (line_buf[i] != ':') continue;
11917
11918 if (isSalted)
11919 {
11920 memset (hash_buf.salt, 0, sizeof (salt_t));
11921 }
11922
11923 hash_t *found = NULL;
11924
11925 if (hash_mode == 6800)
11926 {
11927 if (i < 64) // 64 = 16 * uint in salt_buf[]
11928 {
11929 // manipulate salt_buf
11930 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11931
11932 hash_buf.salt->salt_len = i;
11933
11934 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11935 }
11936 }
11937 else if (hash_mode == 2500)
11938 {
11939 if (i < 64) // 64 = 16 * uint in salt_buf[]
11940 {
11941 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11942 // manipulate salt_buf
11943
11944 memcpy (line_buf_cpy, line_buf, i);
11945
11946 char *mac2_pos = strrchr (line_buf_cpy, ':');
11947
11948 if (mac2_pos == NULL) continue;
11949
11950 mac2_pos[0] = 0;
11951 mac2_pos++;
11952
11953 if (strlen (mac2_pos) != 12) continue;
11954
11955 char *mac1_pos = strrchr (line_buf_cpy, ':');
11956
11957 if (mac1_pos == NULL) continue;
11958
11959 mac1_pos[0] = 0;
11960 mac1_pos++;
11961
11962 if (strlen (mac1_pos) != 12) continue;
11963
11964 uint essid_length = mac1_pos - line_buf_cpy - 1;
11965
11966 // here we need the ESSID
11967 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11968
11969 hash_buf.salt->salt_len = essid_length;
11970
11971 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11972
11973 if (found)
11974 {
11975 wpa_t *wpa = (wpa_t *) found->esalt;
11976
11977 // compare hex string(s) vs binary MAC address(es)
11978
11979 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11980 {
11981 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11982 {
11983 found = NULL;
11984
11985 break;
11986 }
11987 }
11988
11989 // early skip ;)
11990 if (!found) continue;
11991
11992 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11993 {
11994 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11995 {
11996 found = NULL;
11997
11998 break;
11999 }
12000 }
12001 }
12002 }
12003 }
12004 else
12005 {
12006 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12007
12008 if (parser_status == PARSER_OK)
12009 {
12010 if (isSalted)
12011 {
12012 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12013 }
12014 else
12015 {
12016 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12017 }
12018 }
12019 }
12020
12021 if (found == NULL) continue;
12022
12023 if (!found->cracked) potfile_remove_cracks++;
12024
12025 found->cracked = 1;
12026
12027 if (found) break;
12028
12029 iter--;
12030 }
12031 }
12032
12033 myfree (line_buf_cpy);
12034
12035 myfree (line_buf);
12036
12037 fclose (fp);
12038 }
12039 }
12040
12041 if (esalt_size)
12042 {
12043 local_free (hash_buf.esalt);
12044 }
12045
12046 if (isSalted)
12047 {
12048 local_free (hash_buf.salt);
12049 }
12050
12051 local_free (hash_buf.digest);
12052 }
12053
12054 /**
12055 * Now generate all the buffers required for later
12056 */
12057
12058 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12059
12060 salt_t *salts_buf_new = NULL;
12061 void *esalts_buf_new = NULL;
12062
12063 if (isSalted)
12064 {
12065 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12066
12067 if (esalt_size)
12068 {
12069 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12070 }
12071 }
12072 else
12073 {
12074 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12075 }
12076
12077 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12078
12079 uint digests_cnt = hashes_cnt;
12080 uint digests_done = 0;
12081
12082 uint size_digests = digests_cnt * dgst_size;
12083 uint size_shown = digests_cnt * sizeof (uint);
12084
12085 uint *digests_shown = (uint *) mymalloc (size_shown);
12086 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12087
12088 uint salts_cnt = 0;
12089 uint salts_done = 0;
12090
12091 hashinfo_t **hash_info = NULL;
12092
12093 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12094 {
12095 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12096
12097 if (username && (remove || show))
12098 {
12099 uint user_pos;
12100
12101 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12102 {
12103 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12104
12105 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12106 }
12107 }
12108 }
12109
12110 uint *salts_shown = (uint *) mymalloc (size_shown);
12111
12112 salt_t *salt_buf;
12113
12114 {
12115 // copied from inner loop
12116
12117 salt_buf = &salts_buf_new[salts_cnt];
12118
12119 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12120
12121 if (esalt_size)
12122 {
12123 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12124 }
12125
12126 salt_buf->digests_cnt = 0;
12127 salt_buf->digests_done = 0;
12128 salt_buf->digests_offset = 0;
12129
12130 salts_cnt++;
12131 }
12132
12133 if (hashes_buf[0].cracked == 1)
12134 {
12135 digests_shown[0] = 1;
12136
12137 digests_done++;
12138
12139 salt_buf->digests_done++;
12140 }
12141
12142 salt_buf->digests_cnt++;
12143
12144 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12145
12146 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12147 {
12148 hash_info[0] = hashes_buf[0].hash_info;
12149 }
12150
12151 // copy from inner loop
12152
12153 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12154 {
12155 if (isSalted)
12156 {
12157 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12158 {
12159 salt_buf = &salts_buf_new[salts_cnt];
12160
12161 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12162
12163 if (esalt_size)
12164 {
12165 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12166 }
12167
12168 salt_buf->digests_cnt = 0;
12169 salt_buf->digests_done = 0;
12170 salt_buf->digests_offset = hashes_pos;
12171
12172 salts_cnt++;
12173 }
12174 }
12175
12176 if (hashes_buf[hashes_pos].cracked == 1)
12177 {
12178 digests_shown[hashes_pos] = 1;
12179
12180 digests_done++;
12181
12182 salt_buf->digests_done++;
12183 }
12184
12185 salt_buf->digests_cnt++;
12186
12187 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12188
12189 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12190 {
12191 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12192 }
12193 }
12194
12195 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12196 {
12197 salt_t *salt_buf = &salts_buf_new[salt_pos];
12198
12199 if (salt_buf->digests_done == salt_buf->digests_cnt)
12200 {
12201 salts_shown[salt_pos] = 1;
12202
12203 salts_done++;
12204 }
12205
12206 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12207 }
12208
12209 local_free (digests_buf);
12210 local_free (salts_buf);
12211 local_free (esalts_buf);
12212
12213 digests_buf = digests_buf_new;
12214 salts_buf = salts_buf_new;
12215 esalts_buf = esalts_buf_new;
12216
12217 local_free (hashes_buf);
12218
12219 /**
12220 * special modification not set from parser
12221 */
12222
12223 switch (hash_mode)
12224 {
12225 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12226 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12227 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12228 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12229 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12230 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12231 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12232 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12233 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12234 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12235 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12236 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12237 }
12238
12239 if (truecrypt_keyfiles)
12240 {
12241 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12242
12243 char *keyfiles = strdup (truecrypt_keyfiles);
12244
12245 char *keyfile = strtok (keyfiles, ",");
12246
12247 do
12248 {
12249 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12250
12251 } while ((keyfile = strtok (NULL, ",")) != NULL);
12252
12253 free (keyfiles);
12254 }
12255
12256 data.digests_cnt = digests_cnt;
12257 data.digests_done = digests_done;
12258 data.digests_buf = digests_buf;
12259 data.digests_shown = digests_shown;
12260 data.digests_shown_tmp = digests_shown_tmp;
12261
12262 data.salts_cnt = salts_cnt;
12263 data.salts_done = salts_done;
12264 data.salts_buf = salts_buf;
12265 data.salts_shown = salts_shown;
12266
12267 data.esalts_buf = esalts_buf;
12268 data.hash_info = hash_info;
12269
12270 /**
12271 * Automatic Optimizers
12272 */
12273
12274 if (salts_cnt == 1)
12275 opti_type |= OPTI_TYPE_SINGLE_SALT;
12276
12277 if (digests_cnt == 1)
12278 opti_type |= OPTI_TYPE_SINGLE_HASH;
12279
12280 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12281 opti_type |= OPTI_TYPE_NOT_ITERATED;
12282
12283 if (attack_mode == ATTACK_MODE_BF)
12284 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12285
12286 data.opti_type = opti_type;
12287
12288 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12289 {
12290 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12291 {
12292 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12293 {
12294 if (opts_type & OPTS_TYPE_ST_ADD80)
12295 {
12296 opts_type &= ~OPTS_TYPE_ST_ADD80;
12297 opts_type |= OPTS_TYPE_PT_ADD80;
12298 }
12299
12300 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12301 {
12302 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12303 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12304 }
12305
12306 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12307 {
12308 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12309 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12310 }
12311 }
12312 }
12313 }
12314
12315 /**
12316 * Some algorithm, like descrypt, can benefit from JIT compilation
12317 */
12318
12319 int force_jit_compilation = -1;
12320
12321 if (hash_mode == 8900)
12322 {
12323 force_jit_compilation = 8900;
12324 }
12325 else if (hash_mode == 9300)
12326 {
12327 force_jit_compilation = 8900;
12328 }
12329 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12330 {
12331 force_jit_compilation = 1500;
12332 }
12333
12334 /**
12335 * generate bitmap tables
12336 */
12337
12338 const uint bitmap_shift1 = 5;
12339 const uint bitmap_shift2 = 13;
12340
12341 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12342
12343 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12344 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12345 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12346 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12347 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12348 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12349 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12350 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12351
12352 uint bitmap_bits;
12353 uint bitmap_nums;
12354 uint bitmap_mask;
12355 uint bitmap_size;
12356
12357 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12358 {
12359 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12360
12361 bitmap_nums = 1 << bitmap_bits;
12362
12363 bitmap_mask = bitmap_nums - 1;
12364
12365 bitmap_size = bitmap_nums * sizeof (uint);
12366
12367 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12368
12369 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;
12370 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;
12371
12372 break;
12373 }
12374
12375 bitmap_nums = 1 << bitmap_bits;
12376
12377 bitmap_mask = bitmap_nums - 1;
12378
12379 bitmap_size = bitmap_nums * sizeof (uint);
12380
12381 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);
12382 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);
12383
12384 /**
12385 * prepare quick rule
12386 */
12387
12388 data.rule_buf_l = rule_buf_l;
12389 data.rule_buf_r = rule_buf_r;
12390
12391 int rule_len_l = (int) strlen (rule_buf_l);
12392 int rule_len_r = (int) strlen (rule_buf_r);
12393
12394 data.rule_len_l = rule_len_l;
12395 data.rule_len_r = rule_len_r;
12396
12397 /**
12398 * load rules
12399 */
12400
12401 uint *all_kernel_rules_cnt = NULL;
12402
12403 kernel_rule_t **all_kernel_rules_buf = NULL;
12404
12405 if (rp_files_cnt)
12406 {
12407 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12408
12409 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12410 }
12411
12412 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12413
12414 int rule_len = 0;
12415
12416 for (uint i = 0; i < rp_files_cnt; i++)
12417 {
12418 uint kernel_rules_avail = 0;
12419
12420 uint kernel_rules_cnt = 0;
12421
12422 kernel_rule_t *kernel_rules_buf = NULL;
12423
12424 char *rp_file = rp_files[i];
12425
12426 char in[BLOCK_SIZE] = { 0 };
12427 char out[BLOCK_SIZE] = { 0 };
12428
12429 FILE *fp = NULL;
12430
12431 uint rule_line = 0;
12432
12433 if ((fp = fopen (rp_file, "rb")) == NULL)
12434 {
12435 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12436
12437 return (-1);
12438 }
12439
12440 while (!feof (fp))
12441 {
12442 memset (rule_buf, 0, HCBUFSIZ);
12443
12444 rule_len = fgetl (fp, rule_buf);
12445
12446 rule_line++;
12447
12448 if (rule_len == 0) continue;
12449
12450 if (rule_buf[0] == '#') continue;
12451
12452 if (kernel_rules_avail == kernel_rules_cnt)
12453 {
12454 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12455
12456 kernel_rules_avail += INCR_RULES;
12457 }
12458
12459 memset (in, 0, BLOCK_SIZE);
12460 memset (out, 0, BLOCK_SIZE);
12461
12462 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12463
12464 if (result == -1)
12465 {
12466 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12467
12468 continue;
12469 }
12470
12471 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12472 {
12473 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12474
12475 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12476
12477 continue;
12478 }
12479
12480 /* its so slow
12481 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12482 {
12483 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12484
12485 continue;
12486 }
12487 */
12488
12489 kernel_rules_cnt++;
12490 }
12491
12492 fclose (fp);
12493
12494 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12495
12496 all_kernel_rules_buf[i] = kernel_rules_buf;
12497 }
12498
12499 /**
12500 * merge rules or automatic rule generator
12501 */
12502
12503 uint kernel_rules_cnt = 0;
12504
12505 kernel_rule_t *kernel_rules_buf = NULL;
12506
12507 if (attack_mode == ATTACK_MODE_STRAIGHT)
12508 {
12509 if (rp_files_cnt)
12510 {
12511 kernel_rules_cnt = 1;
12512
12513 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12514
12515 repeats[0] = kernel_rules_cnt;
12516
12517 for (uint i = 0; i < rp_files_cnt; i++)
12518 {
12519 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12520
12521 repeats[i + 1] = kernel_rules_cnt;
12522 }
12523
12524 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12525
12526 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12527
12528 for (uint i = 0; i < kernel_rules_cnt; i++)
12529 {
12530 uint out_pos = 0;
12531
12532 kernel_rule_t *out = &kernel_rules_buf[i];
12533
12534 for (uint j = 0; j < rp_files_cnt; j++)
12535 {
12536 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12537 uint in_pos;
12538
12539 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12540
12541 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12542 {
12543 if (out_pos == RULES_MAX - 1)
12544 {
12545 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12546
12547 break;
12548 }
12549
12550 out->cmds[out_pos] = in->cmds[in_pos];
12551 }
12552 }
12553 }
12554
12555 local_free (repeats);
12556 }
12557 else if (rp_gen)
12558 {
12559 uint kernel_rules_avail = 0;
12560
12561 while (kernel_rules_cnt < rp_gen)
12562 {
12563 if (kernel_rules_avail == kernel_rules_cnt)
12564 {
12565 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12566
12567 kernel_rules_avail += INCR_RULES;
12568 }
12569
12570 memset (rule_buf, 0, HCBUFSIZ);
12571
12572 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12573
12574 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12575
12576 kernel_rules_cnt++;
12577 }
12578 }
12579 }
12580
12581 myfree (rule_buf);
12582
12583 /**
12584 * generate NOP rules
12585 */
12586
12587 if (kernel_rules_cnt == 0)
12588 {
12589 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12590
12591 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12592
12593 kernel_rules_cnt++;
12594 }
12595
12596 data.kernel_rules_cnt = kernel_rules_cnt;
12597 data.kernel_rules_buf = kernel_rules_buf;
12598
12599 /**
12600 * OpenCL platforms: detect
12601 */
12602
12603 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12604 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12605
12606 cl_uint platforms_cnt = 0;
12607 cl_uint platform_devices_cnt = 0;
12608
12609 if (keyspace == 0)
12610 {
12611 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12612
12613 if (platforms_cnt == 0)
12614 {
12615 log_error ("ERROR: No OpenCL compatible platform found");
12616
12617 return (-1);
12618 }
12619
12620 if (opencl_platforms_filter != (uint) -1)
12621 {
12622 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
12623
12624 if (opencl_platforms_filter > platform_cnt_mask)
12625 {
12626 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
12627
12628 return (-1);
12629 }
12630 }
12631 }
12632
12633 /**
12634 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12635 */
12636
12637 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12638 {
12639 cl_platform_id platform = platforms[platform_id];
12640
12641 char platform_vendor[INFOSZ] = { 0 };
12642
12643 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12644
12645 #ifdef HAVE_HWMON
12646 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12647 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12648 {
12649 // make sure that we do not directly control the fan for NVidia
12650
12651 gpu_temp_retain = 0;
12652
12653 data.gpu_temp_retain = gpu_temp_retain;
12654 }
12655 #endif // HAVE_NVML || HAVE_NVAPI
12656 #endif
12657 }
12658
12659 /**
12660 * OpenCL devices: simply push all devices from all platforms into the same device array
12661 */
12662
12663 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12664
12665 data.devices_param = devices_param;
12666
12667 uint devices_cnt = 0;
12668
12669 uint devices_active = 0;
12670
12671 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12672 {
12673 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12674
12675 cl_platform_id platform = platforms[platform_id];
12676
12677 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12678
12679 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12680 {
12681 size_t param_value_size = 0;
12682
12683 const uint device_id = devices_cnt;
12684
12685 hc_device_param_t *device_param = &data.devices_param[device_id];
12686
12687 device_param->device = platform_devices[platform_devices_id];
12688
12689 device_param->device_id = device_id;
12690
12691 device_param->platform_devices_id = platform_devices_id;
12692
12693 // device_type
12694
12695 cl_device_type device_type;
12696
12697 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12698
12699 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12700
12701 device_param->device_type = device_type;
12702
12703 // vendor_id
12704
12705 cl_uint vendor_id = 0;
12706
12707 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12708
12709 device_param->vendor_id = vendor_id;
12710
12711 // device_name
12712
12713 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12714
12715 char *device_name = (char *) mymalloc (param_value_size);
12716
12717 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12718
12719 device_param->device_name = device_name;
12720
12721 // tuning db
12722
12723 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12724
12725 // device_version
12726
12727 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12728
12729 char *device_version = (char *) mymalloc (param_value_size);
12730
12731 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12732
12733 device_param->device_version = device_version;
12734
12735 // device_opencl_version
12736
12737 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12738
12739 char *device_opencl_version = (char *) mymalloc (param_value_size);
12740
12741 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12742
12743 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12744
12745 myfree (device_opencl_version);
12746
12747 if (strstr (device_version, "pocl"))
12748 {
12749 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12750 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12751
12752 cl_uint vendor_id = VENDOR_ID_GENERIC;
12753
12754 device_param->vendor_id = vendor_id;
12755 }
12756
12757 // vector_width
12758
12759 cl_uint vector_width;
12760
12761 if (opencl_vector_width_chgd == 0)
12762 {
12763 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12764 {
12765 if (opti_type & OPTI_TYPE_USES_BITS_64)
12766 {
12767 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12768 }
12769 else
12770 {
12771 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12772 }
12773 }
12774 else
12775 {
12776 vector_width = (cl_uint) tuningdb_entry->vector_width;
12777 }
12778 }
12779 else
12780 {
12781 vector_width = opencl_vector_width;
12782 }
12783
12784 if (vector_width > 16) vector_width = 16;
12785
12786 device_param->vector_width = vector_width;
12787
12788 // max_compute_units
12789
12790 cl_uint device_processors;
12791
12792 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12793
12794 device_param->device_processors = device_processors;
12795
12796 // max_mem_alloc_size
12797
12798 cl_ulong device_maxmem_alloc;
12799
12800 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12801
12802 device_param->device_maxmem_alloc = device_maxmem_alloc;
12803
12804 // max_mem_alloc_size
12805
12806 cl_ulong device_global_mem;
12807
12808 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12809
12810 device_param->device_global_mem = device_global_mem;
12811
12812 // max_clock_frequency
12813
12814 cl_uint device_maxclock_frequency;
12815
12816 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12817
12818 device_param->device_maxclock_frequency = device_maxclock_frequency;
12819
12820 // skipped
12821
12822 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12823 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12824
12825 device_param->skipped = (skipped1 || skipped2);
12826
12827 // driver_version
12828 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12829
12830 char *driver_version = (char *) mymalloc (param_value_size);
12831
12832 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12833
12834 device_param->driver_version = driver_version;
12835
12836 // device_name_chksum
12837
12838 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12839
12840 #if __x86_64__
12841 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);
12842 #else
12843 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);
12844 #endif
12845
12846 uint device_name_digest[4] = { 0 };
12847
12848 md5_64 ((uint *) device_name_chksum, device_name_digest);
12849
12850 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12851
12852 device_param->device_name_chksum = device_name_chksum;
12853
12854 // device_processor_cores
12855
12856 if (device_type & CL_DEVICE_TYPE_CPU)
12857 {
12858 cl_uint device_processor_cores = 1;
12859
12860 device_param->device_processor_cores = device_processor_cores;
12861 }
12862
12863 if (device_type & CL_DEVICE_TYPE_GPU)
12864 {
12865 if (vendor_id == VENDOR_ID_AMD)
12866 {
12867 if (strstr (device_version, "MESA"))
12868 {
12869 // MESA stuff
12870 }
12871 else
12872 {
12873 cl_uint device_processor_cores = 0;
12874
12875 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12876
12877 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12878
12879 device_param->device_processor_cores = device_processor_cores;
12880 }
12881 }
12882 else if (vendor_id == VENDOR_ID_NV)
12883 {
12884 cl_uint kernel_exec_timeout = 0;
12885
12886 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12887
12888 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12889
12890 device_param->kernel_exec_timeout = kernel_exec_timeout;
12891
12892 cl_uint device_processor_cores = 0;
12893
12894 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12895
12896 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12897
12898 device_param->device_processor_cores = device_processor_cores;
12899
12900 cl_uint sm_minor = 0;
12901 cl_uint sm_major = 0;
12902
12903 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12904 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12905
12906 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12907 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12908
12909 device_param->sm_minor = sm_minor;
12910 device_param->sm_major = sm_major;
12911 }
12912 else
12913 {
12914 cl_uint device_processor_cores = 1;
12915
12916 device_param->device_processor_cores = device_processor_cores;
12917 }
12918 }
12919
12920 // display results
12921
12922 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12923 {
12924 if (device_param->skipped == 0)
12925 {
12926 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12927 device_id + 1,
12928 device_name,
12929 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12930 (unsigned int) (device_global_mem / 1024 / 1024),
12931 (unsigned int) (device_maxclock_frequency),
12932 (unsigned int) device_processors);
12933 }
12934 else
12935 {
12936 log_info ("Device #%u: %s, skipped",
12937 device_id + 1,
12938 device_name);
12939 }
12940 }
12941
12942 // common driver check
12943
12944 if (device_param->skipped == 0)
12945 {
12946 if (strstr (device_version, "pocl"))
12947 {
12948 if (force == 0)
12949 {
12950 log_info ("");
12951 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12952 log_info ("You are STRONGLY encouraged not to use it");
12953 log_info ("You can use --force to override this but do not post error reports if you do so");
12954 log_info ("");
12955
12956 return (-1);
12957 }
12958 }
12959
12960 if (device_type & CL_DEVICE_TYPE_GPU)
12961 {
12962 if (vendor_id == VENDOR_ID_NV)
12963 {
12964 if (device_param->kernel_exec_timeout != 0)
12965 {
12966 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);
12967 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12968 }
12969 }
12970 else if (vendor_id == VENDOR_ID_AMD)
12971 {
12972 if (strstr (device_version, "MESA"))
12973 {
12974 // MESA stuff
12975 }
12976 else
12977 {
12978 int catalyst_check = (force == 1) ? 0 : 1;
12979
12980 int catalyst_warn = 0;
12981
12982 int catalyst_broken = 0;
12983
12984 if (catalyst_check == 1)
12985 {
12986 catalyst_warn = 1;
12987
12988 // v14.9 and higher
12989 if (atoi (device_param->driver_version) >= 1573)
12990 {
12991 catalyst_warn = 0;
12992 }
12993
12994 catalyst_check = 0;
12995 }
12996
12997 if (catalyst_broken == 1)
12998 {
12999 log_info ("");
13000 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13001 log_info ("It will pass over cracked hashes and does not report them as cracked");
13002 log_info ("You are STRONGLY encouraged not to use it");
13003 log_info ("You can use --force to override this but do not post error reports if you do so");
13004 log_info ("");
13005
13006 return (-1);
13007 }
13008
13009 if (catalyst_warn == 1)
13010 {
13011 log_info ("");
13012 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13013 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13014 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
13015 #ifdef _WIN
13016 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13017 #endif
13018 log_info ("You can use --force to override this but do not post error reports if you do so");
13019 log_info ("");
13020
13021 return (-1);
13022 }
13023 }
13024 }
13025 }
13026
13027 /**
13028 * kernel accel and loops tuning db adjustment
13029 */
13030
13031 device_param->kernel_accel_min = 1;
13032 device_param->kernel_accel_max = 1024;
13033
13034 device_param->kernel_loops_min = 1;
13035 device_param->kernel_loops_max = 1024;
13036
13037 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13038
13039 if (tuningdb_entry)
13040 {
13041 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13042 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13043
13044 if (_kernel_accel)
13045 {
13046 device_param->kernel_accel_min = _kernel_accel;
13047 device_param->kernel_accel_max = _kernel_accel;
13048 }
13049
13050 if (_kernel_loops)
13051 {
13052 if (workload_profile == 1)
13053 {
13054 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13055 }
13056 else if (workload_profile == 2)
13057 {
13058 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13059 }
13060
13061 device_param->kernel_loops_min = _kernel_loops;
13062 device_param->kernel_loops_max = _kernel_loops;
13063 }
13064 }
13065
13066 // commandline parameters overwrite tuningdb entries
13067
13068 if (kernel_accel)
13069 {
13070 device_param->kernel_accel_min = kernel_accel;
13071 device_param->kernel_accel_max = kernel_accel;
13072 }
13073
13074 if (kernel_loops)
13075 {
13076 device_param->kernel_loops_min = kernel_loops;
13077 device_param->kernel_loops_max = kernel_loops;
13078 }
13079
13080 /**
13081 * activate device
13082 */
13083
13084 devices_active++;
13085 }
13086
13087 // next please
13088
13089 devices_cnt++;
13090 }
13091 }
13092
13093 if (keyspace == 0 && devices_active == 0)
13094 {
13095 log_error ("ERROR: No devices found/left");
13096
13097 return (-1);
13098 }
13099
13100 // 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)
13101
13102 if (devices_filter != (uint) -1)
13103 {
13104 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13105
13106 if (devices_filter > devices_cnt_mask)
13107 {
13108 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13109
13110 return (-1);
13111 }
13112 }
13113
13114 data.devices_cnt = devices_cnt;
13115
13116 data.devices_active = devices_active;
13117
13118 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13119 {
13120 log_info ("");
13121 }
13122
13123 /**
13124 * HM devices: init
13125 */
13126
13127 #ifdef HAVE_HWMON
13128 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13129 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13130 #endif
13131
13132 #ifdef HAVE_ADL
13133 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13134 #endif
13135
13136 if (gpu_temp_disable == 0)
13137 {
13138 #if defined(WIN) && defined(HAVE_NVAPI)
13139 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13140
13141 if (nvapi_init (nvapi) == 0)
13142 data.hm_nv = nvapi;
13143
13144 if (data.hm_nv)
13145 {
13146 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13147 {
13148 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13149
13150 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13151
13152 int tmp_out = 0;
13153
13154 for (int i = 0; i < tmp_in; i++)
13155 {
13156 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13157 }
13158
13159 for (int i = 0; i < tmp_out; i++)
13160 {
13161 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13162
13163 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13164
13165 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;
13166 }
13167 }
13168 }
13169 #endif // WIN && HAVE_NVAPI
13170
13171 #if defined(LINUX) && defined(HAVE_NVML)
13172 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13173
13174 if (nvml_init (nvml) == 0)
13175 data.hm_nv = nvml;
13176
13177 if (data.hm_nv)
13178 {
13179 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13180 {
13181 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13182
13183 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13184
13185 int tmp_out = 0;
13186
13187 for (int i = 0; i < tmp_in; i++)
13188 {
13189 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13190 }
13191
13192 for (int i = 0; i < tmp_out; i++)
13193 {
13194 unsigned int speed;
13195
13196 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;
13197 }
13198 }
13199 }
13200 #endif // LINUX && HAVE_NVML
13201
13202 data.hm_amd = NULL;
13203
13204 #ifdef HAVE_ADL
13205 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13206
13207 if (adl_init (adl) == 0)
13208 data.hm_amd = adl;
13209
13210 if (data.hm_amd)
13211 {
13212 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13213 {
13214 // total number of adapters
13215
13216 int hm_adapters_num;
13217
13218 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13219
13220 // adapter info
13221
13222 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13223
13224 if (lpAdapterInfo == NULL) return (-1);
13225
13226 // get a list (of ids of) valid/usable adapters
13227
13228 int num_adl_adapters = 0;
13229
13230 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13231
13232 if (num_adl_adapters > 0)
13233 {
13234 hc_thread_mutex_lock (mux_adl);
13235
13236 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13237
13238 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13239
13240 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13241 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13242
13243 hc_thread_mutex_unlock (mux_adl);
13244 }
13245
13246 myfree (valid_adl_device_list);
13247 myfree (lpAdapterInfo);
13248 }
13249 }
13250 #endif // HAVE_ADL
13251
13252 if (data.hm_amd == NULL && data.hm_nv == NULL)
13253 {
13254 gpu_temp_disable = 1;
13255 }
13256 }
13257
13258 /**
13259 * OpenCL devices: allocate buffer for device specific information
13260 */
13261
13262 #ifdef HAVE_HWMON
13263 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13264
13265 #ifdef HAVE_ADL
13266 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13267
13268 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13269 #endif // ADL
13270 #endif
13271
13272 /**
13273 * enable custom signal handler(s)
13274 */
13275
13276 if (benchmark == 0)
13277 {
13278 hc_signal (sigHandler_default);
13279 }
13280 else
13281 {
13282 hc_signal (sigHandler_benchmark);
13283 }
13284
13285 /**
13286 * User-defined GPU temp handling
13287 */
13288
13289 #ifdef HAVE_HWMON
13290 if (gpu_temp_disable == 1)
13291 {
13292 gpu_temp_abort = 0;
13293 gpu_temp_retain = 0;
13294 }
13295
13296 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13297 {
13298 if (gpu_temp_abort < gpu_temp_retain)
13299 {
13300 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13301
13302 return (-1);
13303 }
13304 }
13305
13306 data.gpu_temp_disable = gpu_temp_disable;
13307 data.gpu_temp_abort = gpu_temp_abort;
13308 data.gpu_temp_retain = gpu_temp_retain;
13309 #endif
13310
13311 /**
13312 * inform the user
13313 */
13314
13315 if (data.quiet == 0)
13316 {
13317 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13318
13319 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);
13320
13321 if (attack_mode == ATTACK_MODE_STRAIGHT)
13322 {
13323 log_info ("Rules: %u", kernel_rules_cnt);
13324 }
13325
13326 if (opti_type)
13327 {
13328 log_info ("Applicable Optimizers:");
13329
13330 for (uint i = 0; i < 32; i++)
13331 {
13332 const uint opti_bit = 1u << i;
13333
13334 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13335 }
13336 }
13337
13338 /**
13339 * Watchdog and Temperature balance
13340 */
13341
13342 #ifdef HAVE_HWMON
13343 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13344 {
13345 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13346 }
13347
13348 if (gpu_temp_abort == 0)
13349 {
13350 log_info ("Watchdog: Temperature abort trigger disabled");
13351 }
13352 else
13353 {
13354 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13355 }
13356
13357 if (gpu_temp_retain == 0)
13358 {
13359 log_info ("Watchdog: Temperature retain trigger disabled");
13360 }
13361 else
13362 {
13363 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13364 }
13365 #endif
13366 }
13367
13368 if (data.quiet == 0) log_info ("");
13369
13370 /**
13371 * HM devices: copy
13372 */
13373
13374 if (gpu_temp_disable == 0)
13375 {
13376 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13377 {
13378 hc_device_param_t *device_param = &data.devices_param[device_id];
13379
13380 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13381
13382 if (device_param->skipped) continue;
13383
13384 const uint platform_devices_id = device_param->platform_devices_id;
13385
13386 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13387 if (device_param->vendor_id == VENDOR_ID_NV)
13388 {
13389 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13390 }
13391 #endif
13392
13393 #ifdef HAVE_ADL
13394 if (device_param->vendor_id == VENDOR_ID_AMD)
13395 {
13396 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13397 }
13398 #endif
13399 }
13400 }
13401
13402 /*
13403 * Temporary fix:
13404 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13405 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13406 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13407 * Driver / ADL bug?
13408 */
13409
13410 #ifdef HAVE_ADL
13411 if (powertune_enable == 1)
13412 {
13413 hc_thread_mutex_lock (mux_adl);
13414
13415 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13416 {
13417 hc_device_param_t *device_param = &data.devices_param[device_id];
13418
13419 if (device_param->skipped) continue;
13420
13421 if (data.hm_device[device_id].od_version == 6)
13422 {
13423 // set powertune value only
13424
13425 int powertune_supported = 0;
13426
13427 int ADL_rc = 0;
13428
13429 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13430 {
13431 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13432
13433 return (-1);
13434 }
13435
13436 if (powertune_supported != 0)
13437 {
13438 // powertune set
13439 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13440
13441 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13442 {
13443 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13444
13445 return (-1);
13446 }
13447
13448 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13449 {
13450 log_error ("ERROR: Failed to set new ADL PowerControl values");
13451
13452 return (-1);
13453 }
13454 }
13455 }
13456 }
13457
13458 hc_thread_mutex_unlock (mux_adl);
13459 }
13460 #endif // HAVE_ADK
13461 #endif // HAVE_HWMON
13462
13463 #ifdef DEBUG
13464 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13465 #endif
13466
13467 uint kernel_power_all = 0;
13468
13469 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13470 {
13471 /**
13472 * host buffer
13473 */
13474
13475 hc_device_param_t *device_param = &data.devices_param[device_id];
13476
13477 if (device_param->skipped) continue;
13478
13479 /**
13480 * device properties
13481 */
13482
13483 const char *device_name_chksum = device_param->device_name_chksum;
13484 const u32 device_processors = device_param->device_processors;
13485 const u32 device_processor_cores = device_param->device_processor_cores;
13486
13487 /**
13488 * create context for each device
13489 */
13490
13491 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13492
13493 /**
13494 * create command-queue
13495 */
13496
13497 // not supported with NV
13498 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13499
13500 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13501
13502 /**
13503 * create input buffers on device : calculate size of fixed memory buffers
13504 */
13505
13506 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13507 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13508
13509 device_param->size_root_css = size_root_css;
13510 device_param->size_markov_css = size_markov_css;
13511
13512 uint size_results = KERNEL_THREADS * sizeof (uint);
13513
13514 device_param->size_results = size_results;
13515
13516 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13517 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13518
13519 uint size_plains = digests_cnt * sizeof (plain_t);
13520 uint size_salts = salts_cnt * sizeof (salt_t);
13521 uint size_esalts = salts_cnt * esalt_size;
13522
13523 device_param->size_plains = size_plains;
13524 device_param->size_digests = size_digests;
13525 device_param->size_shown = size_shown;
13526 device_param->size_salts = size_salts;
13527
13528 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13529 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13530 uint size_tm = 32 * sizeof (bs_word_t);
13531
13532 // scryptV stuff
13533
13534 u64 size_scryptV = 1;
13535
13536 if ((hash_mode == 8900) || (hash_mode == 9300))
13537 {
13538 uint tmto_start = 0;
13539 uint tmto_stop = 10;
13540
13541 if (scrypt_tmto)
13542 {
13543 tmto_start = scrypt_tmto;
13544 }
13545 else
13546 {
13547 // in case the user did not specify the tmto manually
13548 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13549 // but set the lower end only in case the user has a device with too less memory
13550
13551 if (hash_mode == 8900)
13552 {
13553 if (device_param->vendor_id == VENDOR_ID_AMD)
13554 {
13555 tmto_start = 1;
13556 }
13557 else if (device_param->vendor_id == VENDOR_ID_NV)
13558 {
13559 tmto_start = 3;
13560 }
13561 }
13562 else if (hash_mode == 9300)
13563 {
13564 if (device_param->vendor_id == VENDOR_ID_AMD)
13565 {
13566 tmto_start = 3;
13567 }
13568 else if (device_param->vendor_id == VENDOR_ID_NV)
13569 {
13570 tmto_start = 5;
13571 }
13572 }
13573 }
13574
13575 if (quiet == 0) log_info ("");
13576
13577 uint shader_per_mp = 1;
13578
13579 if (device_param->vendor_id == VENDOR_ID_AMD)
13580 {
13581 shader_per_mp = 8;
13582 }
13583 else if (device_param->vendor_id == VENDOR_ID_NV)
13584 {
13585 shader_per_mp = 32;
13586 }
13587
13588 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13589 {
13590 // TODO: in theory the following calculation needs to be done per salt, not global
13591 // we assume all hashes have the same scrypt settings
13592
13593 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13594
13595 size_scryptV /= 1 << tmto;
13596
13597 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13598
13599 if (size_scryptV > device_param->device_maxmem_alloc)
13600 {
13601 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13602
13603 continue;
13604 }
13605
13606 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13607 {
13608 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13609 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13610 }
13611
13612 break;
13613 }
13614
13615 if (data.salts_buf[0].scrypt_phy == 0)
13616 {
13617 log_error ("ERROR: can't allocate enough device memory");
13618
13619 return -1;
13620 }
13621
13622 if (quiet == 0) log_info ("");
13623 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13624 }
13625
13626 /**
13627 * create input buffers on device : calculate size of dynamic size memory buffers
13628 */
13629
13630 uint kernel_threads = KERNEL_THREADS;
13631
13632 // some algorithms need a fixed kernel-threads count (mostly because of shared memory usage)
13633
13634 if (hash_mode == 3200) kernel_threads = 8;
13635 if (hash_mode == 9000) kernel_threads = 8;
13636
13637 /**
13638 * some algorithms need a fixed kernel-loops count
13639 */
13640
13641 if (hash_mode == 1500)
13642 {
13643 const u32 kernel_loops_fixed = 1024;
13644
13645 device_param->kernel_loops_min = kernel_loops_fixed;
13646 device_param->kernel_loops_max = kernel_loops_fixed;
13647 }
13648
13649 if (hash_mode == 3000)
13650 {
13651 const u32 kernel_loops_fixed = 1024;
13652
13653 device_param->kernel_loops_min = kernel_loops_fixed;
13654 device_param->kernel_loops_max = kernel_loops_fixed;
13655 }
13656
13657 if (hash_mode == 8900)
13658 {
13659 const u32 kernel_loops_fixed = 1;
13660
13661 device_param->kernel_loops_min = kernel_loops_fixed;
13662 device_param->kernel_loops_max = kernel_loops_fixed;
13663 }
13664
13665 if (hash_mode == 9300)
13666 {
13667 const u32 kernel_loops_fixed = 1;
13668
13669 device_param->kernel_loops_min = kernel_loops_fixed;
13670 device_param->kernel_loops_max = kernel_loops_fixed;
13671 }
13672
13673 if (hash_mode == 12500)
13674 {
13675 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13676
13677 device_param->kernel_loops_min = kernel_loops_fixed;
13678 device_param->kernel_loops_max = kernel_loops_fixed;
13679 }
13680
13681 /**
13682 * some algorithms have a maximum kernel-loops count
13683 */
13684
13685 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13686 {
13687 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13688 {
13689 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13690 }
13691 }
13692
13693 /**
13694 * some algorithms need a special kernel-accel
13695 */
13696
13697 if (hash_mode == 8900)
13698 {
13699 device_param->kernel_accel_min = 1;
13700 device_param->kernel_accel_max = 64;
13701 }
13702
13703 if (hash_mode == 9300)
13704 {
13705 device_param->kernel_accel_min = 1;
13706 device_param->kernel_accel_max = 64;
13707 }
13708
13709 u32 kernel_accel_min = device_param->kernel_accel_min;
13710 u32 kernel_accel_max = device_param->kernel_accel_max;
13711
13712 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13713
13714 uint size_pws = 4;
13715 uint size_tmps = 4;
13716 uint size_hooks = 4;
13717
13718 while (kernel_accel_max >= kernel_accel_min)
13719 {
13720 uint kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13721
13722 // size_pws
13723
13724 size_pws = kernel_power_max * sizeof (pw_t);
13725
13726 // size_tmps
13727
13728 switch (hash_mode)
13729 {
13730 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13731 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13732 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13733 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13734 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13735 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13736 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13737 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13738 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13739 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13740 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13741 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13742 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13743 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13744 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13745 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13746 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13747 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13748 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13749 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13750 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13751 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13752 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13753 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13754 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13755 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13756 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13757 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13758 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13759 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13760 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13761 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13762 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13763 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13764 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13765 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13766 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13767 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13768 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13769 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13770 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13771 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13772 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13773 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13774 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13775 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13776 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13777 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13778 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13779 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13780 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13781 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13782 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13783 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13784 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13785 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13786 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13787 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13788 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13789 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13790 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13791 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
13792 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
13793 };
13794
13795 // size_hooks
13796
13797 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13798 {
13799 // none yet
13800 }
13801
13802 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13803 // if not, decrease amplifier and try again
13804
13805 int skip = 0;
13806
13807 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13808 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13809 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13810
13811 if (( bitmap_size
13812 + bitmap_size
13813 + bitmap_size
13814 + bitmap_size
13815 + bitmap_size
13816 + bitmap_size
13817 + bitmap_size
13818 + bitmap_size
13819 + size_bfs
13820 + size_combs
13821 + size_digests
13822 + size_esalts
13823 + size_hooks
13824 + size_markov_css
13825 + size_plains
13826 + size_pws
13827 + size_results
13828 + size_root_css
13829 + size_rules
13830 + size_rules_c
13831 + size_salts
13832 + size_scryptV
13833 + size_shown
13834 + size_tm
13835 + size_tmps) > device_param->device_global_mem) skip = 1;
13836
13837 if (skip == 1)
13838 {
13839 kernel_accel_max--;
13840
13841 continue;
13842 }
13843
13844 break;
13845 }
13846
13847 /*
13848 if (kernel_accel_max == 0)
13849 {
13850 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13851
13852 return -1;
13853 }
13854 */
13855
13856 device_param->kernel_accel_min = kernel_accel_min;
13857 device_param->kernel_accel_max = kernel_accel_max;
13858
13859 /*
13860 if (kernel_accel_max < kernel_accel)
13861 {
13862 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13863
13864 device_param->kernel_accel = kernel_accel_max;
13865 }
13866 */
13867
13868 device_param->size_bfs = size_bfs;
13869 device_param->size_combs = size_combs;
13870 device_param->size_rules = size_rules;
13871 device_param->size_rules_c = size_rules_c;
13872 device_param->size_pws = size_pws;
13873 device_param->size_tmps = size_tmps;
13874 device_param->size_hooks = size_hooks;
13875
13876 // do not confuse kernel_accel_max with kernel_accel here
13877
13878 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13879
13880 device_param->kernel_threads = kernel_threads;
13881 device_param->kernel_power_user = kernel_power;
13882
13883 kernel_power_all += kernel_power;
13884
13885 /**
13886 * default building options
13887 */
13888
13889 char build_opts[1024] = { 0 };
13890
13891 // we don't have sm_* on vendors not NV but it doesn't matter
13892
13893 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);
13894
13895 /**
13896 * main kernel
13897 */
13898
13899 {
13900 /**
13901 * kernel source filename
13902 */
13903
13904 char source_file[256] = { 0 };
13905
13906 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13907
13908 struct stat sst;
13909
13910 if (stat (source_file, &sst) == -1)
13911 {
13912 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13913
13914 return -1;
13915 }
13916
13917 /**
13918 * kernel cached filename
13919 */
13920
13921 char cached_file[256] = { 0 };
13922
13923 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13924
13925 int cached = 1;
13926
13927 struct stat cst;
13928
13929 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13930 {
13931 cached = 0;
13932 }
13933
13934 /**
13935 * kernel compile or load
13936 */
13937
13938 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13939
13940 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13941
13942 if (force_jit_compilation == -1)
13943 {
13944 if (cached == 0)
13945 {
13946 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13947
13948 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13949
13950 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13951
13952 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13953
13954 #ifdef DEBUG
13955 size_t build_log_size = 0;
13956
13957 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
13958
13959 if (build_log_size > 1)
13960 {
13961 char *build_log = (char *) malloc (build_log_size + 1);
13962
13963 memset (build_log, 0, build_log_size + 1);
13964
13965 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
13966
13967 puts (build_log);
13968
13969 free (build_log);
13970 }
13971 #endif
13972
13973 if (rc != 0)
13974 {
13975 device_param->skipped = true;
13976 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13977 continue;
13978 }
13979
13980 size_t binary_size;
13981
13982 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13983
13984 u8 *binary = (u8 *) mymalloc (binary_size);
13985
13986 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13987
13988 writeProgramBin (cached_file, binary, binary_size);
13989
13990 local_free (binary);
13991 }
13992 else
13993 {
13994 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13995
13996 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13997
13998 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13999
14000 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14001 }
14002 }
14003 else
14004 {
14005 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14006
14007 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14008
14009 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14010
14011 char build_opts_update[1024] = { 0 };
14012
14013 if (force_jit_compilation == 1500)
14014 {
14015 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14016 }
14017 else if (force_jit_compilation == 8900)
14018 {
14019 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);
14020 }
14021 else
14022 {
14023 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14024 }
14025
14026 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14027
14028 #ifdef DEBUG
14029 size_t build_log_size = 0;
14030
14031 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14032
14033 if (build_log_size > 1)
14034 {
14035 char *build_log = (char *) malloc (build_log_size + 1);
14036
14037 memset (build_log, 0, build_log_size + 1);
14038
14039 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14040
14041 puts (build_log);
14042
14043 free (build_log);
14044 }
14045 #endif
14046
14047 if (rc != 0)
14048 {
14049 device_param->skipped = true;
14050
14051 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14052 }
14053 }
14054
14055 local_free (kernel_lengths);
14056 local_free (kernel_sources[0]);
14057 local_free (kernel_sources);
14058 }
14059
14060 /**
14061 * word generator kernel
14062 */
14063
14064 if (attack_mode != ATTACK_MODE_STRAIGHT)
14065 {
14066 /**
14067 * kernel mp source filename
14068 */
14069
14070 char source_file[256] = { 0 };
14071
14072 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14073
14074 struct stat sst;
14075
14076 if (stat (source_file, &sst) == -1)
14077 {
14078 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14079
14080 return -1;
14081 }
14082
14083 /**
14084 * kernel mp cached filename
14085 */
14086
14087 char cached_file[256] = { 0 };
14088
14089 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14090
14091 int cached = 1;
14092
14093 struct stat cst;
14094
14095 if (stat (cached_file, &cst) == -1)
14096 {
14097 cached = 0;
14098 }
14099
14100 /**
14101 * kernel compile or load
14102 */
14103
14104 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14105
14106 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14107
14108 if (cached == 0)
14109 {
14110 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14111
14112 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14113
14114 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14115
14116 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14117
14118 if (rc != 0)
14119 {
14120 device_param->skipped = true;
14121 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14122 continue;
14123 }
14124
14125 size_t binary_size;
14126
14127 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14128
14129 u8 *binary = (u8 *) mymalloc (binary_size);
14130
14131 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14132
14133 writeProgramBin (cached_file, binary, binary_size);
14134
14135 local_free (binary);
14136 }
14137 else
14138 {
14139 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14140
14141 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14142
14143 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14144
14145 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14146 }
14147
14148 local_free (kernel_lengths);
14149 local_free (kernel_sources[0]);
14150 local_free (kernel_sources);
14151 }
14152
14153 /**
14154 * amplifier kernel
14155 */
14156
14157 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14158 {
14159
14160 }
14161 else
14162 {
14163 /**
14164 * kernel amp source filename
14165 */
14166
14167 char source_file[256] = { 0 };
14168
14169 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14170
14171 struct stat sst;
14172
14173 if (stat (source_file, &sst) == -1)
14174 {
14175 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14176
14177 return -1;
14178 }
14179
14180 /**
14181 * kernel amp cached filename
14182 */
14183
14184 char cached_file[256] = { 0 };
14185
14186 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14187
14188 int cached = 1;
14189
14190 struct stat cst;
14191
14192 if (stat (cached_file, &cst) == -1)
14193 {
14194 cached = 0;
14195 }
14196
14197 /**
14198 * kernel compile or load
14199 */
14200
14201 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14202
14203 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14204
14205 if (cached == 0)
14206 {
14207 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14208
14209 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14210
14211 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14212
14213 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14214
14215 if (rc != 0)
14216 {
14217 device_param->skipped = true;
14218 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14219 continue;
14220 }
14221
14222 size_t binary_size;
14223
14224 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14225
14226 u8 *binary = (u8 *) mymalloc (binary_size);
14227
14228 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14229
14230 writeProgramBin (cached_file, binary, binary_size);
14231
14232 local_free (binary);
14233 }
14234 else
14235 {
14236 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14237
14238 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14239
14240 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14241
14242 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14243 }
14244
14245 local_free (kernel_lengths);
14246 local_free (kernel_sources[0]);
14247 local_free (kernel_sources);
14248 }
14249
14250 // some algorithm collide too fast, make that impossible
14251
14252 if (benchmark == 1)
14253 {
14254 ((uint *) digests_buf)[0] = -1;
14255 ((uint *) digests_buf)[1] = -1;
14256 ((uint *) digests_buf)[2] = -1;
14257 ((uint *) digests_buf)[3] = -1;
14258 }
14259
14260 /**
14261 * global buffers
14262 */
14263
14264 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14265 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14266 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14267 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14268 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14269 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14270 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14271 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14272 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14273 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14274 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14275 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14276 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14277 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14278 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14279 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14280 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14281 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14282
14283 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);
14284 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);
14285 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);
14286 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);
14287 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);
14288 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);
14289 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);
14290 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);
14291 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14292 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14293 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14294
14295 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14296 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14297 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14298 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14299 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14300 run_kernel_bzero (device_param, device_param->d_result, size_results);
14301
14302 /**
14303 * special buffers
14304 */
14305
14306 if (attack_kern == ATTACK_KERN_STRAIGHT)
14307 {
14308 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14309 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14310
14311 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14312
14313 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14314 }
14315 else if (attack_kern == ATTACK_KERN_COMBI)
14316 {
14317 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14318 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14319 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14320 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14321
14322 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14323 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14324 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14325 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14326 }
14327 else if (attack_kern == ATTACK_KERN_BF)
14328 {
14329 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14330 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14331 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14332 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14333 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14334
14335 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14336 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14337 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14338 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14339 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14340 }
14341
14342 if (size_esalts)
14343 {
14344 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14345
14346 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14347 }
14348
14349 /**
14350 * main host data
14351 */
14352
14353 uint *result = (uint *) mymalloc (size_results);
14354
14355 device_param->result = result;
14356
14357 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14358
14359 device_param->pws_buf = pws_buf;
14360
14361 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14362
14363 device_param->combs_buf = combs_buf;
14364
14365 void *hooks_buf = mymalloc (size_hooks);
14366
14367 device_param->hooks_buf = hooks_buf;
14368
14369 /**
14370 * kernel args
14371 */
14372
14373 device_param->kernel_params_buf32[21] = bitmap_mask;
14374 device_param->kernel_params_buf32[22] = bitmap_shift1;
14375 device_param->kernel_params_buf32[23] = bitmap_shift2;
14376 device_param->kernel_params_buf32[24] = 0; // salt_pos
14377 device_param->kernel_params_buf32[25] = 0; // loop_pos
14378 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14379 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14380 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14381 device_param->kernel_params_buf32[29] = 0; // digests_offset
14382 device_param->kernel_params_buf32[30] = 0; // combs_mode
14383 device_param->kernel_params_buf32[31] = 0; // gid_max
14384
14385 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14386 ? &device_param->d_pws_buf
14387 : &device_param->d_pws_amp_buf;
14388 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14389 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14390 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14391 device_param->kernel_params[ 4] = &device_param->d_tmps;
14392 device_param->kernel_params[ 5] = &device_param->d_hooks;
14393 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14394 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14395 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14396 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14397 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14398 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14399 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14400 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14401 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14402 device_param->kernel_params[15] = &device_param->d_digests_buf;
14403 device_param->kernel_params[16] = &device_param->d_digests_shown;
14404 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14405 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14406 device_param->kernel_params[19] = &device_param->d_result;
14407 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14408 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14409 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14410 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14411 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14412 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14413 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14414 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14415 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14416 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14417 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14418 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14419
14420 device_param->kernel_params_mp_buf64[3] = 0;
14421 device_param->kernel_params_mp_buf32[4] = 0;
14422 device_param->kernel_params_mp_buf32[5] = 0;
14423 device_param->kernel_params_mp_buf32[6] = 0;
14424 device_param->kernel_params_mp_buf32[7] = 0;
14425 device_param->kernel_params_mp_buf32[8] = 0;
14426
14427 device_param->kernel_params_mp[0] = NULL;
14428 device_param->kernel_params_mp[1] = NULL;
14429 device_param->kernel_params_mp[2] = NULL;
14430 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14431 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14432 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14433 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14434 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14435 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14436
14437 device_param->kernel_params_mp_l_buf64[3] = 0;
14438 device_param->kernel_params_mp_l_buf32[4] = 0;
14439 device_param->kernel_params_mp_l_buf32[5] = 0;
14440 device_param->kernel_params_mp_l_buf32[6] = 0;
14441 device_param->kernel_params_mp_l_buf32[7] = 0;
14442 device_param->kernel_params_mp_l_buf32[8] = 0;
14443 device_param->kernel_params_mp_l_buf32[9] = 0;
14444
14445 device_param->kernel_params_mp_l[0] = NULL;
14446 device_param->kernel_params_mp_l[1] = NULL;
14447 device_param->kernel_params_mp_l[2] = NULL;
14448 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14449 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14450 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14451 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14452 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14453 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14454 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14455
14456 device_param->kernel_params_mp_r_buf64[3] = 0;
14457 device_param->kernel_params_mp_r_buf32[4] = 0;
14458 device_param->kernel_params_mp_r_buf32[5] = 0;
14459 device_param->kernel_params_mp_r_buf32[6] = 0;
14460 device_param->kernel_params_mp_r_buf32[7] = 0;
14461 device_param->kernel_params_mp_r_buf32[8] = 0;
14462
14463 device_param->kernel_params_mp_r[0] = NULL;
14464 device_param->kernel_params_mp_r[1] = NULL;
14465 device_param->kernel_params_mp_r[2] = NULL;
14466 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14467 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14468 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14469 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14470 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14471 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14472
14473 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14474 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14475
14476 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14477 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14478 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14479 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14480 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14481 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14482 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14483
14484 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14485 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14486
14487 /**
14488 * kernel name
14489 */
14490
14491 char kernel_name[64] = { 0 };
14492
14493 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14494 {
14495 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14496 {
14497 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14498
14499 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14500
14501 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14502
14503 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14504
14505 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14506
14507 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14508 }
14509 else
14510 {
14511 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14512
14513 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14514
14515 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14516
14517 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14518
14519 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14520
14521 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14522 }
14523
14524 if (data.attack_mode == ATTACK_MODE_BF)
14525 {
14526 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14527 {
14528 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14529
14530 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14531 }
14532 }
14533 }
14534 else
14535 {
14536 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14537
14538 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14539
14540 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14541
14542 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14543
14544 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14545
14546 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14547
14548 if (opts_type & OPTS_TYPE_HOOK12)
14549 {
14550 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14551
14552 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14553 }
14554
14555 if (opts_type & OPTS_TYPE_HOOK23)
14556 {
14557 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14558
14559 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14560 }
14561 }
14562
14563 for (uint i = 0; i <= 20; i++)
14564 {
14565 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14566 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14567 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14568
14569 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14570 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14571 }
14572
14573 for (uint i = 21; i <= 31; i++)
14574 {
14575 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14576 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14577 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14578
14579 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14580 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14581 }
14582
14583 if (attack_mode == ATTACK_MODE_BF)
14584 {
14585 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14586 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14587
14588 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14589 {
14590 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14591 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14592 }
14593 }
14594 else if (attack_mode == ATTACK_MODE_HYBRID1)
14595 {
14596 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14597 }
14598 else if (attack_mode == ATTACK_MODE_HYBRID2)
14599 {
14600 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14601 }
14602
14603 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14604 {
14605 // nothing to do
14606 }
14607 else
14608 {
14609 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14610 }
14611
14612 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14613 {
14614 // nothing to do
14615 }
14616 else
14617 {
14618 for (uint i = 0; i < 5; i++)
14619 {
14620 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14621 }
14622
14623 for (uint i = 5; i < 7; i++)
14624 {
14625 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14626 }
14627 }
14628
14629 /**
14630 * Store initial fanspeed if gpu_temp_retain is enabled
14631 */
14632
14633 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14634 int gpu_temp_retain_set = 0;
14635
14636 if (gpu_temp_disable == 0)
14637 {
14638 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14639 {
14640 hc_thread_mutex_lock (mux_adl);
14641
14642 if (data.hm_device[device_id].fan_supported == 1)
14643 {
14644 if (gpu_temp_retain_chgd == 0)
14645 {
14646 uint cur_temp = 0;
14647 uint default_temp = 0;
14648
14649 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);
14650
14651 if (ADL_rc == ADL_OK)
14652 {
14653 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14654
14655 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14656
14657 // special case with multi gpu setups: always use minimum retain
14658
14659 if (gpu_temp_retain_set == 0)
14660 {
14661 gpu_temp_retain = gpu_temp_retain_target;
14662 gpu_temp_retain_set = 1;
14663 }
14664 else
14665 {
14666 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14667 }
14668
14669 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14670 }
14671 }
14672
14673 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14674
14675 temp_retain_fanspeed_value[device_id] = fan_speed;
14676
14677 if (fan_speed == -1)
14678 {
14679 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14680
14681 temp_retain_fanspeed_value[device_id] = 0;
14682 }
14683 }
14684
14685 hc_thread_mutex_unlock (mux_adl);
14686 }
14687 }
14688
14689 /**
14690 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14691 */
14692
14693 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14694 {
14695 hc_thread_mutex_lock (mux_adl);
14696
14697 if (data.hm_device[device_id].od_version == 6)
14698 {
14699 int ADL_rc;
14700
14701 // check powertune capabilities first, if not available then skip device
14702
14703 int powertune_supported = 0;
14704
14705 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14706 {
14707 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14708
14709 return (-1);
14710 }
14711
14712 if (powertune_supported != 0)
14713 {
14714 // powercontrol settings
14715
14716 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14717
14718 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14719 {
14720 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14721 }
14722
14723 if (ADL_rc != ADL_OK)
14724 {
14725 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14726
14727 return (-1);
14728 }
14729
14730 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14731 {
14732 log_error ("ERROR: Failed to set new ADL PowerControl values");
14733
14734 return (-1);
14735 }
14736
14737 // clocks
14738
14739 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14740
14741 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14742
14743 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)
14744 {
14745 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14746
14747 return (-1);
14748 }
14749
14750 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14751
14752 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14753
14754 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14755 {
14756 log_error ("ERROR: Failed to get ADL device capabilities");
14757
14758 return (-1);
14759 }
14760
14761 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14762 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14763
14764 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14765 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14766
14767 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14768 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14769
14770 // warning if profile has too low max values
14771
14772 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14773 {
14774 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14775 }
14776
14777 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14778 {
14779 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14780 }
14781
14782 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14783
14784 performance_state->iNumberOfPerformanceLevels = 2;
14785
14786 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14787 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14788 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14789 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14790
14791 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)
14792 {
14793 log_info ("ERROR: Failed to set ADL performance state");
14794
14795 return (-1);
14796 }
14797
14798 local_free (performance_state);
14799 }
14800 }
14801
14802 hc_thread_mutex_unlock (mux_adl);
14803 }
14804 #endif // HAVE_HWMON && HAVE_ADL
14805 }
14806
14807 data.kernel_power_all = kernel_power_all;
14808
14809 if (data.quiet == 0) log_info ("");
14810
14811 /**
14812 * In benchmark-mode, inform user which algorithm is checked
14813 */
14814
14815 if (benchmark == 1)
14816 {
14817 quiet = 0;
14818
14819 data.quiet = quiet;
14820
14821 char *hash_type = strhashtype (data.hash_mode); // not a bug
14822
14823 log_info ("Hashtype: %s", hash_type);
14824 log_info ("");
14825 }
14826
14827 /**
14828 * keep track of the progress
14829 */
14830
14831 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14832 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14833 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14834
14835 /**
14836 * open filehandles
14837 */
14838
14839 #if _WIN
14840 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14841 {
14842 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14843
14844 return (-1);
14845 }
14846
14847 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14848 {
14849 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14850
14851 return (-1);
14852 }
14853
14854 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14855 {
14856 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14857
14858 return (-1);
14859 }
14860 #endif
14861
14862 /**
14863 * dictionary pad
14864 */
14865
14866 segment_size *= (1024 * 1024);
14867
14868 data.segment_size = segment_size;
14869
14870 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14871
14872 wl_data->buf = (char *) mymalloc (segment_size);
14873 wl_data->avail = segment_size;
14874 wl_data->incr = segment_size;
14875 wl_data->cnt = 0;
14876 wl_data->pos = 0;
14877
14878 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14879
14880 data.wordlist_mode = wordlist_mode;
14881
14882 cs_t *css_buf = NULL;
14883 uint css_cnt = 0;
14884 uint dictcnt = 0;
14885 uint maskcnt = 1;
14886 char **masks = NULL;
14887 char **dictfiles = NULL;
14888
14889 uint mask_from_file = 0;
14890
14891 if (attack_mode == ATTACK_MODE_STRAIGHT)
14892 {
14893 if (wordlist_mode == WL_MODE_FILE)
14894 {
14895 int wls_left = myargc - (optind + 1);
14896
14897 for (int i = 0; i < wls_left; i++)
14898 {
14899 char *l0_filename = myargv[optind + 1 + i];
14900
14901 struct stat l0_stat;
14902
14903 if (stat (l0_filename, &l0_stat) == -1)
14904 {
14905 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14906
14907 return (-1);
14908 }
14909
14910 uint is_dir = S_ISDIR (l0_stat.st_mode);
14911
14912 if (is_dir == 0)
14913 {
14914 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14915
14916 dictcnt++;
14917
14918 dictfiles[dictcnt - 1] = l0_filename;
14919 }
14920 else
14921 {
14922 // do not allow --keyspace w/ a directory
14923
14924 if (keyspace == 1)
14925 {
14926 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14927
14928 return (-1);
14929 }
14930
14931 char **dictionary_files = NULL;
14932
14933 dictionary_files = scan_directory (l0_filename);
14934
14935 if (dictionary_files != NULL)
14936 {
14937 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14938
14939 for (int d = 0; dictionary_files[d] != NULL; d++)
14940 {
14941 char *l1_filename = dictionary_files[d];
14942
14943 struct stat l1_stat;
14944
14945 if (stat (l1_filename, &l1_stat) == -1)
14946 {
14947 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14948
14949 return (-1);
14950 }
14951
14952 if (S_ISREG (l1_stat.st_mode))
14953 {
14954 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14955
14956 dictcnt++;
14957
14958 dictfiles[dictcnt - 1] = strdup (l1_filename);
14959 }
14960 }
14961 }
14962
14963 local_free (dictionary_files);
14964 }
14965 }
14966
14967 if (dictcnt < 1)
14968 {
14969 log_error ("ERROR: No usable dictionary file found.");
14970
14971 return (-1);
14972 }
14973 }
14974 else if (wordlist_mode == WL_MODE_STDIN)
14975 {
14976 dictcnt = 1;
14977 }
14978 }
14979 else if (attack_mode == ATTACK_MODE_COMBI)
14980 {
14981 // display
14982
14983 char *dictfile1 = myargv[optind + 1 + 0];
14984 char *dictfile2 = myargv[optind + 1 + 1];
14985
14986 // find the bigger dictionary and use as base
14987
14988 FILE *fp1 = NULL;
14989 FILE *fp2 = NULL;
14990
14991 struct stat tmp_stat;
14992
14993 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14994 {
14995 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14996
14997 return (-1);
14998 }
14999
15000 if (stat (dictfile1, &tmp_stat) == -1)
15001 {
15002 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15003
15004 fclose (fp1);
15005
15006 return (-1);
15007 }
15008
15009 if (S_ISDIR (tmp_stat.st_mode))
15010 {
15011 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15012
15013 fclose (fp1);
15014
15015 return (-1);
15016 }
15017
15018 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15019 {
15020 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15021
15022 fclose (fp1);
15023
15024 return (-1);
15025 }
15026
15027 if (stat (dictfile2, &tmp_stat) == -1)
15028 {
15029 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15030
15031 fclose (fp1);
15032 fclose (fp2);
15033
15034 return (-1);
15035 }
15036
15037 if (S_ISDIR (tmp_stat.st_mode))
15038 {
15039 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15040
15041 fclose (fp1);
15042 fclose (fp2);
15043
15044 return (-1);
15045 }
15046
15047 data.combs_cnt = 1;
15048
15049 data.quiet = 1;
15050
15051 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15052
15053 data.quiet = quiet;
15054
15055 if (words1_cnt == 0)
15056 {
15057 log_error ("ERROR: %s: empty file", dictfile1);
15058
15059 fclose (fp1);
15060 fclose (fp2);
15061
15062 return (-1);
15063 }
15064
15065 data.combs_cnt = 1;
15066
15067 data.quiet = 1;
15068
15069 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15070
15071 data.quiet = quiet;
15072
15073 if (words2_cnt == 0)
15074 {
15075 log_error ("ERROR: %s: empty file", dictfile2);
15076
15077 fclose (fp1);
15078 fclose (fp2);
15079
15080 return (-1);
15081 }
15082
15083 fclose (fp1);
15084 fclose (fp2);
15085
15086 data.dictfile = dictfile1;
15087 data.dictfile2 = dictfile2;
15088
15089 if (words1_cnt >= words2_cnt)
15090 {
15091 data.combs_cnt = words2_cnt;
15092 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15093
15094 dictfiles = &data.dictfile;
15095
15096 dictcnt = 1;
15097 }
15098 else
15099 {
15100 data.combs_cnt = words1_cnt;
15101 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15102
15103 dictfiles = &data.dictfile2;
15104
15105 dictcnt = 1;
15106
15107 // we also have to switch wordlist related rules!
15108
15109 char *tmpc = data.rule_buf_l;
15110
15111 data.rule_buf_l = data.rule_buf_r;
15112 data.rule_buf_r = tmpc;
15113
15114 int tmpi = data.rule_len_l;
15115
15116 data.rule_len_l = data.rule_len_r;
15117 data.rule_len_r = tmpi;
15118 }
15119 }
15120 else if (attack_mode == ATTACK_MODE_BF)
15121 {
15122 char *mask = NULL;
15123
15124 maskcnt = 0;
15125
15126 if (benchmark == 0)
15127 {
15128 mask = myargv[optind + 1];
15129
15130 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15131
15132 if ((optind + 2) <= myargc)
15133 {
15134 struct stat file_stat;
15135
15136 if (stat (mask, &file_stat) == -1)
15137 {
15138 maskcnt = 1;
15139
15140 masks[maskcnt - 1] = mystrdup (mask);
15141 }
15142 else
15143 {
15144 int wls_left = myargc - (optind + 1);
15145
15146 uint masks_avail = INCR_MASKS;
15147
15148 for (int i = 0; i < wls_left; i++)
15149 {
15150 if (i != 0)
15151 {
15152 mask = myargv[optind + 1 + i];
15153
15154 if (stat (mask, &file_stat) == -1)
15155 {
15156 log_error ("ERROR: %s: %s", mask, strerror (errno));
15157
15158 return (-1);
15159 }
15160 }
15161
15162 uint is_file = S_ISREG (file_stat.st_mode);
15163
15164 if (is_file == 1)
15165 {
15166 FILE *mask_fp;
15167
15168 if ((mask_fp = fopen (mask, "r")) == NULL)
15169 {
15170 log_error ("ERROR: %s: %s", mask, strerror (errno));
15171
15172 return (-1);
15173 }
15174
15175 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15176
15177 while (!feof (mask_fp))
15178 {
15179 memset (line_buf, 0, HCBUFSIZ);
15180
15181 int line_len = fgetl (mask_fp, line_buf);
15182
15183 if (line_len == 0) continue;
15184
15185 if (line_buf[0] == '#') continue;
15186
15187 if (masks_avail == maskcnt)
15188 {
15189 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15190
15191 masks_avail += INCR_MASKS;
15192 }
15193
15194 masks[maskcnt] = mystrdup (line_buf);
15195
15196 maskcnt++;
15197 }
15198
15199 myfree (line_buf);
15200
15201 fclose (mask_fp);
15202 }
15203 else
15204 {
15205 log_error ("ERROR: %s: unsupported file-type", mask);
15206
15207 return (-1);
15208 }
15209 }
15210
15211 mask_from_file = 1;
15212 }
15213 }
15214 else
15215 {
15216 custom_charset_1 = (char *) "?l?d?u";
15217 custom_charset_2 = (char *) "?l?d";
15218 custom_charset_3 = (char *) "?l?d*!$@_";
15219
15220 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15221 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15222 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15223
15224 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15225
15226 wordlist_mode = WL_MODE_MASK;
15227
15228 data.wordlist_mode = wordlist_mode;
15229
15230 increment = 1;
15231
15232 maskcnt = 1;
15233 }
15234 }
15235 else
15236 {
15237 /**
15238 * generate full masks and charsets
15239 */
15240
15241 masks = (char **) mymalloc (sizeof (char *));
15242
15243 switch (hash_mode)
15244 {
15245 case 1731: pw_min = 5;
15246 pw_max = 5;
15247 mask = mystrdup ("?b?b?b?b?b");
15248 break;
15249 case 12500: pw_min = 5;
15250 pw_max = 5;
15251 mask = mystrdup ("?b?b?b?b?b");
15252 break;
15253 default: pw_min = 7;
15254 pw_max = 7;
15255 mask = mystrdup ("?b?b?b?b?b?b?b");
15256 break;
15257 }
15258
15259 maskcnt = 1;
15260
15261 masks[maskcnt - 1] = mystrdup (mask);
15262
15263 wordlist_mode = WL_MODE_MASK;
15264
15265 data.wordlist_mode = wordlist_mode;
15266
15267 increment = 1;
15268 }
15269
15270 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15271
15272 if (increment)
15273 {
15274 if (increment_min > pw_min) pw_min = increment_min;
15275
15276 if (increment_max < pw_max) pw_max = increment_max;
15277 }
15278 }
15279 else if (attack_mode == ATTACK_MODE_HYBRID1)
15280 {
15281 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15282
15283 // display
15284
15285 char *mask = myargv[myargc - 1];
15286
15287 maskcnt = 0;
15288
15289 masks = (char **) mymalloc (1 * sizeof (char *));
15290
15291 // mod
15292
15293 struct stat file_stat;
15294
15295 if (stat (mask, &file_stat) == -1)
15296 {
15297 maskcnt = 1;
15298
15299 masks[maskcnt - 1] = mystrdup (mask);
15300 }
15301 else
15302 {
15303 uint is_file = S_ISREG (file_stat.st_mode);
15304
15305 if (is_file == 1)
15306 {
15307 FILE *mask_fp;
15308
15309 if ((mask_fp = fopen (mask, "r")) == NULL)
15310 {
15311 log_error ("ERROR: %s: %s", mask, strerror (errno));
15312
15313 return (-1);
15314 }
15315
15316 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15317
15318 uint masks_avail = 1;
15319
15320 while (!feof (mask_fp))
15321 {
15322 memset (line_buf, 0, HCBUFSIZ);
15323
15324 int line_len = fgetl (mask_fp, line_buf);
15325
15326 if (line_len == 0) continue;
15327
15328 if (line_buf[0] == '#') continue;
15329
15330 if (masks_avail == maskcnt)
15331 {
15332 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15333
15334 masks_avail += INCR_MASKS;
15335 }
15336
15337 masks[maskcnt] = mystrdup (line_buf);
15338
15339 maskcnt++;
15340 }
15341
15342 myfree (line_buf);
15343
15344 fclose (mask_fp);
15345
15346 mask_from_file = 1;
15347 }
15348 else
15349 {
15350 maskcnt = 1;
15351
15352 masks[maskcnt - 1] = mystrdup (mask);
15353 }
15354 }
15355
15356 // base
15357
15358 int wls_left = myargc - (optind + 2);
15359
15360 for (int i = 0; i < wls_left; i++)
15361 {
15362 char *filename = myargv[optind + 1 + i];
15363
15364 struct stat file_stat;
15365
15366 if (stat (filename, &file_stat) == -1)
15367 {
15368 log_error ("ERROR: %s: %s", filename, strerror (errno));
15369
15370 return (-1);
15371 }
15372
15373 uint is_dir = S_ISDIR (file_stat.st_mode);
15374
15375 if (is_dir == 0)
15376 {
15377 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15378
15379 dictcnt++;
15380
15381 dictfiles[dictcnt - 1] = filename;
15382 }
15383 else
15384 {
15385 // do not allow --keyspace w/ a directory
15386
15387 if (keyspace == 1)
15388 {
15389 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15390
15391 return (-1);
15392 }
15393
15394 char **dictionary_files = NULL;
15395
15396 dictionary_files = scan_directory (filename);
15397
15398 if (dictionary_files != NULL)
15399 {
15400 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15401
15402 for (int d = 0; dictionary_files[d] != NULL; d++)
15403 {
15404 char *l1_filename = dictionary_files[d];
15405
15406 struct stat l1_stat;
15407
15408 if (stat (l1_filename, &l1_stat) == -1)
15409 {
15410 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15411
15412 return (-1);
15413 }
15414
15415 if (S_ISREG (l1_stat.st_mode))
15416 {
15417 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15418
15419 dictcnt++;
15420
15421 dictfiles[dictcnt - 1] = strdup (l1_filename);
15422 }
15423 }
15424 }
15425
15426 local_free (dictionary_files);
15427 }
15428 }
15429
15430 if (dictcnt < 1)
15431 {
15432 log_error ("ERROR: No usable dictionary file found.");
15433
15434 return (-1);
15435 }
15436
15437 if (increment)
15438 {
15439 maskcnt = 0;
15440
15441 uint mask_min = increment_min; // we can't reject smaller masks here
15442 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15443
15444 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15445 {
15446 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15447
15448 if (cur_mask == NULL) break;
15449
15450 masks[maskcnt] = cur_mask;
15451
15452 maskcnt++;
15453
15454 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15455 }
15456 }
15457 }
15458 else if (attack_mode == ATTACK_MODE_HYBRID2)
15459 {
15460 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15461
15462 // display
15463
15464 char *mask = myargv[optind + 1 + 0];
15465
15466 maskcnt = 0;
15467
15468 masks = (char **) mymalloc (1 * sizeof (char *));
15469
15470 // mod
15471
15472 struct stat file_stat;
15473
15474 if (stat (mask, &file_stat) == -1)
15475 {
15476 maskcnt = 1;
15477
15478 masks[maskcnt - 1] = mystrdup (mask);
15479 }
15480 else
15481 {
15482 uint is_file = S_ISREG (file_stat.st_mode);
15483
15484 if (is_file == 1)
15485 {
15486 FILE *mask_fp;
15487
15488 if ((mask_fp = fopen (mask, "r")) == NULL)
15489 {
15490 log_error ("ERROR: %s: %s", mask, strerror (errno));
15491
15492 return (-1);
15493 }
15494
15495 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15496
15497 uint masks_avail = 1;
15498
15499 while (!feof (mask_fp))
15500 {
15501 memset (line_buf, 0, HCBUFSIZ);
15502
15503 int line_len = fgetl (mask_fp, line_buf);
15504
15505 if (line_len == 0) continue;
15506
15507 if (line_buf[0] == '#') continue;
15508
15509 if (masks_avail == maskcnt)
15510 {
15511 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15512
15513 masks_avail += INCR_MASKS;
15514 }
15515
15516 masks[maskcnt] = mystrdup (line_buf);
15517
15518 maskcnt++;
15519 }
15520
15521 myfree (line_buf);
15522
15523 fclose (mask_fp);
15524
15525 mask_from_file = 1;
15526 }
15527 else
15528 {
15529 maskcnt = 1;
15530
15531 masks[maskcnt - 1] = mystrdup (mask);
15532 }
15533 }
15534
15535 // base
15536
15537 int wls_left = myargc - (optind + 2);
15538
15539 for (int i = 0; i < wls_left; i++)
15540 {
15541 char *filename = myargv[optind + 2 + i];
15542
15543 struct stat file_stat;
15544
15545 if (stat (filename, &file_stat) == -1)
15546 {
15547 log_error ("ERROR: %s: %s", filename, strerror (errno));
15548
15549 return (-1);
15550 }
15551
15552 uint is_dir = S_ISDIR (file_stat.st_mode);
15553
15554 if (is_dir == 0)
15555 {
15556 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15557
15558 dictcnt++;
15559
15560 dictfiles[dictcnt - 1] = filename;
15561 }
15562 else
15563 {
15564 // do not allow --keyspace w/ a directory
15565
15566 if (keyspace == 1)
15567 {
15568 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15569
15570 return (-1);
15571 }
15572
15573 char **dictionary_files = NULL;
15574
15575 dictionary_files = scan_directory (filename);
15576
15577 if (dictionary_files != NULL)
15578 {
15579 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15580
15581 for (int d = 0; dictionary_files[d] != NULL; d++)
15582 {
15583 char *l1_filename = dictionary_files[d];
15584
15585 struct stat l1_stat;
15586
15587 if (stat (l1_filename, &l1_stat) == -1)
15588 {
15589 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15590
15591 return (-1);
15592 }
15593
15594 if (S_ISREG (l1_stat.st_mode))
15595 {
15596 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15597
15598 dictcnt++;
15599
15600 dictfiles[dictcnt - 1] = strdup (l1_filename);
15601 }
15602 }
15603 }
15604
15605 local_free (dictionary_files);
15606 }
15607 }
15608
15609 if (dictcnt < 1)
15610 {
15611 log_error ("ERROR: No usable dictionary file found.");
15612
15613 return (-1);
15614 }
15615
15616 if (increment)
15617 {
15618 maskcnt = 0;
15619
15620 uint mask_min = increment_min; // we can't reject smaller masks here
15621 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15622
15623 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15624 {
15625 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15626
15627 if (cur_mask == NULL) break;
15628
15629 masks[maskcnt] = cur_mask;
15630
15631 maskcnt++;
15632
15633 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15634 }
15635 }
15636 }
15637
15638 data.pw_min = pw_min;
15639 data.pw_max = pw_max;
15640
15641 /**
15642 * weak hash check
15643 */
15644
15645 if (weak_hash_threshold >= salts_cnt)
15646 {
15647 hc_device_param_t *device_param = NULL;
15648
15649 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15650 {
15651 device_param = &data.devices_param[device_id];
15652
15653 if (device_param->skipped) continue;
15654
15655 break;
15656 }
15657
15658 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15659
15660 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15661 {
15662 weak_hash_check (device_param, salt_pos);
15663 }
15664 }
15665
15666 // Display hack, guarantee that there is at least one \r before real start
15667
15668 if (data.quiet == 0) log_info_nn ("");
15669
15670 /**
15671 * status and monitor threads
15672 */
15673
15674 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15675
15676 hc_thread_t i_thread = 0;
15677
15678 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15679 {
15680 hc_thread_create (i_thread, thread_keypress, &benchmark);
15681 }
15682
15683 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15684
15685 uint ni_threads_cnt = 0;
15686
15687 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15688
15689 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15690
15691 ni_threads_cnt++;
15692
15693 /**
15694 * Outfile remove
15695 */
15696
15697 if (keyspace == 0)
15698 {
15699 if (outfile_check_timer != 0)
15700 {
15701 if (data.outfile_check_directory != NULL)
15702 {
15703 if ((hash_mode != 5200) &&
15704 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15705 (hash_mode != 9000))
15706 {
15707 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15708
15709 ni_threads_cnt++;
15710 }
15711 else
15712 {
15713 outfile_check_timer = 0;
15714 }
15715 }
15716 else
15717 {
15718 outfile_check_timer = 0;
15719 }
15720 }
15721 }
15722
15723 /**
15724 * Inform the user if we got some hashes remove because of the pot file remove feature
15725 */
15726
15727 if (data.quiet == 0)
15728 {
15729 if (potfile_remove_cracks > 0)
15730 {
15731 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15732 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15733 }
15734 }
15735
15736 data.outfile_check_timer = outfile_check_timer;
15737
15738 /**
15739 * main loop
15740 */
15741
15742 char **induction_dictionaries = NULL;
15743
15744 int induction_dictionaries_cnt = 0;
15745
15746 hcstat_table_t *root_table_buf = NULL;
15747 hcstat_table_t *markov_table_buf = NULL;
15748
15749 uint initial_restore_done = 0;
15750
15751 data.maskcnt = maskcnt;
15752
15753 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15754 {
15755 if (data.devices_status == STATUS_CRACKED) break;
15756
15757 data.devices_status = STATUS_INIT;
15758
15759 if (maskpos > rd->maskpos)
15760 {
15761 rd->dictpos = 0;
15762 }
15763
15764 rd->maskpos = maskpos;
15765 data.maskpos = maskpos;
15766
15767 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15768 {
15769 char *mask = masks[maskpos];
15770
15771 if (mask_from_file == 1)
15772 {
15773 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15774
15775 char *str_ptr;
15776 uint str_pos;
15777
15778 uint mask_offset = 0;
15779
15780 uint separator_cnt;
15781
15782 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15783 {
15784 str_ptr = strstr (mask + mask_offset, ",");
15785
15786 if (str_ptr == NULL) break;
15787
15788 str_pos = str_ptr - mask;
15789
15790 // escaped separator, i.e. "\,"
15791
15792 if (str_pos > 0)
15793 {
15794 if (mask[str_pos - 1] == '\\')
15795 {
15796 separator_cnt --;
15797
15798 mask_offset = str_pos + 1;
15799
15800 continue;
15801 }
15802 }
15803
15804 // reset the offset
15805
15806 mask_offset = 0;
15807
15808 mask[str_pos] = '\0';
15809
15810 switch (separator_cnt)
15811 {
15812 case 0:
15813 mp_reset_usr (mp_usr, 0);
15814
15815 custom_charset_1 = mask;
15816 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15817 break;
15818
15819 case 1:
15820 mp_reset_usr (mp_usr, 1);
15821
15822 custom_charset_2 = mask;
15823 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15824 break;
15825
15826 case 2:
15827 mp_reset_usr (mp_usr, 2);
15828
15829 custom_charset_3 = mask;
15830 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15831 break;
15832
15833 case 3:
15834 mp_reset_usr (mp_usr, 3);
15835
15836 custom_charset_4 = mask;
15837 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15838 break;
15839 }
15840
15841 mask = mask + str_pos + 1;
15842 }
15843 }
15844
15845 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15846 {
15847 if (maskpos > 0)
15848 {
15849 local_free (css_buf);
15850 local_free (data.root_css_buf);
15851 local_free (data.markov_css_buf);
15852
15853 local_free (masks[maskpos - 1]);
15854 }
15855
15856 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15857
15858 data.mask = mask;
15859 data.css_cnt = css_cnt;
15860 data.css_buf = css_buf;
15861
15862 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15863
15864 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15865
15866 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15867 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15868
15869 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15870
15871 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15872
15873 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15874 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15875
15876 data.root_css_buf = root_css_buf;
15877 data.markov_css_buf = markov_css_buf;
15878
15879 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15880
15881 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15882
15883 local_free (root_table_buf);
15884 local_free (markov_table_buf);
15885
15886 // args
15887
15888 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15889 {
15890 hc_device_param_t *device_param = &data.devices_param[device_id];
15891
15892 if (device_param->skipped) continue;
15893
15894 device_param->kernel_params_mp[0] = &device_param->d_combs;
15895 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15896 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15897
15898 device_param->kernel_params_mp_buf64[3] = 0;
15899 device_param->kernel_params_mp_buf32[4] = css_cnt;
15900 device_param->kernel_params_mp_buf32[5] = 0;
15901 device_param->kernel_params_mp_buf32[6] = 0;
15902 device_param->kernel_params_mp_buf32[7] = 0;
15903
15904 if (attack_mode == ATTACK_MODE_HYBRID1)
15905 {
15906 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15907 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15908 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15909 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15910 }
15911 else if (attack_mode == ATTACK_MODE_HYBRID2)
15912 {
15913 device_param->kernel_params_mp_buf32[5] = 0;
15914 device_param->kernel_params_mp_buf32[6] = 0;
15915 device_param->kernel_params_mp_buf32[7] = 0;
15916 }
15917
15918 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]);
15919 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]);
15920 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]);
15921
15922 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);
15923 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);
15924 }
15925 }
15926 else if (attack_mode == ATTACK_MODE_BF)
15927 {
15928 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15929
15930 if (increment)
15931 {
15932 for (uint i = 0; i < dictcnt; i++)
15933 {
15934 local_free (dictfiles[i]);
15935 }
15936
15937 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15938 {
15939 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15940
15941 if (l1_filename == NULL) break;
15942
15943 dictcnt++;
15944
15945 dictfiles[dictcnt - 1] = l1_filename;
15946 }
15947 }
15948 else
15949 {
15950 dictcnt++;
15951
15952 dictfiles[dictcnt - 1] = mask;
15953 }
15954
15955 if (dictcnt == 0)
15956 {
15957 log_error ("ERROR: Mask is too small");
15958
15959 return (-1);
15960 }
15961 }
15962 }
15963
15964 free (induction_dictionaries);
15965
15966 // induction_dictionaries_cnt = 0; // implied
15967
15968 if (attack_mode != ATTACK_MODE_BF)
15969 {
15970 if (keyspace == 0)
15971 {
15972 induction_dictionaries = scan_directory (induction_directory);
15973
15974 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15975 }
15976 }
15977
15978 if (induction_dictionaries_cnt)
15979 {
15980 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15981 }
15982
15983 /**
15984 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15985 */
15986 if (keyspace == 1)
15987 {
15988 if ((maskcnt > 1) || (dictcnt > 1))
15989 {
15990 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15991
15992 return (-1);
15993 }
15994 }
15995
15996 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15997 {
15998 char *subid = logfile_generate_subid ();
15999
16000 data.subid = subid;
16001
16002 logfile_sub_msg ("START");
16003
16004 data.devices_status = STATUS_INIT;
16005
16006 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16007 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16008 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16009
16010 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16011
16012 data.cpt_pos = 0;
16013
16014 data.cpt_start = time (NULL);
16015
16016 data.cpt_total = 0;
16017
16018 if (data.restore == 0)
16019 {
16020 rd->words_cur = skip;
16021
16022 skip = 0;
16023
16024 data.skip = 0;
16025 }
16026
16027 data.ms_paused = 0;
16028
16029 data.words_cur = rd->words_cur;
16030
16031 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16032 {
16033 hc_device_param_t *device_param = &data.devices_param[device_id];
16034
16035 if (device_param->skipped) continue;
16036
16037 device_param->speed_pos = 0;
16038
16039 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16040 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16041
16042 device_param->exec_pos = 0;
16043
16044 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16045
16046 device_param->kernel_power = device_param->kernel_power_user;
16047
16048 device_param->outerloop_pos = 0;
16049 device_param->outerloop_left = 0;
16050 device_param->innerloop_pos = 0;
16051 device_param->innerloop_left = 0;
16052
16053 // some more resets:
16054
16055 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16056
16057 device_param->pws_cnt = 0;
16058
16059 device_param->words_off = 0;
16060 device_param->words_done = 0;
16061 }
16062
16063 data.kernel_power_div = 0;
16064
16065 // figure out some workload
16066
16067 if (attack_mode == ATTACK_MODE_STRAIGHT)
16068 {
16069 if (data.wordlist_mode == WL_MODE_FILE)
16070 {
16071 char *dictfile = NULL;
16072
16073 if (induction_dictionaries_cnt)
16074 {
16075 dictfile = induction_dictionaries[0];
16076 }
16077 else
16078 {
16079 dictfile = dictfiles[dictpos];
16080 }
16081
16082 data.dictfile = dictfile;
16083
16084 logfile_sub_string (dictfile);
16085
16086 for (uint i = 0; i < rp_files_cnt; i++)
16087 {
16088 logfile_sub_var_string ("rulefile", rp_files[i]);
16089 }
16090
16091 FILE *fd2 = fopen (dictfile, "rb");
16092
16093 if (fd2 == NULL)
16094 {
16095 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16096
16097 return (-1);
16098 }
16099
16100 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16101
16102 fclose (fd2);
16103
16104 if (data.words_cnt == 0)
16105 {
16106 if (data.devices_status == STATUS_CRACKED) break;
16107 if (data.devices_status == STATUS_ABORTED) break;
16108
16109 dictpos++;
16110
16111 continue;
16112 }
16113 }
16114 }
16115 else if (attack_mode == ATTACK_MODE_COMBI)
16116 {
16117 char *dictfile = data.dictfile;
16118 char *dictfile2 = data.dictfile2;
16119
16120 logfile_sub_string (dictfile);
16121 logfile_sub_string (dictfile2);
16122
16123 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16124 {
16125 FILE *fd2 = fopen (dictfile, "rb");
16126
16127 if (fd2 == NULL)
16128 {
16129 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16130
16131 return (-1);
16132 }
16133
16134 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16135
16136 fclose (fd2);
16137 }
16138 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16139 {
16140 FILE *fd2 = fopen (dictfile2, "rb");
16141
16142 if (fd2 == NULL)
16143 {
16144 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16145
16146 return (-1);
16147 }
16148
16149 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16150
16151 fclose (fd2);
16152 }
16153
16154 if (data.words_cnt == 0)
16155 {
16156 if (data.devices_status == STATUS_CRACKED) break;
16157 if (data.devices_status == STATUS_ABORTED) break;
16158
16159 dictpos++;
16160
16161 continue;
16162 }
16163 }
16164 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16165 {
16166 char *dictfile = NULL;
16167
16168 if (induction_dictionaries_cnt)
16169 {
16170 dictfile = induction_dictionaries[0];
16171 }
16172 else
16173 {
16174 dictfile = dictfiles[dictpos];
16175 }
16176
16177 data.dictfile = dictfile;
16178
16179 char *mask = data.mask;
16180
16181 logfile_sub_string (dictfile);
16182 logfile_sub_string (mask);
16183
16184 FILE *fd2 = fopen (dictfile, "rb");
16185
16186 if (fd2 == NULL)
16187 {
16188 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16189
16190 return (-1);
16191 }
16192
16193 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16194
16195 fclose (fd2);
16196
16197 if (data.words_cnt == 0)
16198 {
16199 if (data.devices_status == STATUS_CRACKED) break;
16200 if (data.devices_status == STATUS_ABORTED) break;
16201
16202 dictpos++;
16203
16204 continue;
16205 }
16206 }
16207 else if (attack_mode == ATTACK_MODE_BF)
16208 {
16209 local_free (css_buf);
16210 local_free (data.root_css_buf);
16211 local_free (data.markov_css_buf);
16212
16213 char *mask = dictfiles[dictpos];
16214
16215 logfile_sub_string (mask);
16216
16217 // base
16218
16219 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16220
16221 if (opts_type & OPTS_TYPE_PT_UNICODE)
16222 {
16223 uint css_cnt_unicode = css_cnt * 2;
16224
16225 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16226
16227 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16228 {
16229 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16230
16231 css_buf_unicode[j + 1].cs_buf[0] = 0;
16232 css_buf_unicode[j + 1].cs_len = 1;
16233 }
16234
16235 free (css_buf);
16236
16237 css_buf = css_buf_unicode;
16238 css_cnt = css_cnt_unicode;
16239 }
16240
16241 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16242
16243 uint mask_min = pw_min;
16244 uint mask_max = pw_max;
16245
16246 if (opts_type & OPTS_TYPE_PT_UNICODE)
16247 {
16248 mask_min *= 2;
16249 mask_max *= 2;
16250 }
16251
16252 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16253 {
16254 if (css_cnt < mask_min)
16255 {
16256 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16257 }
16258
16259 if (css_cnt > mask_max)
16260 {
16261 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16262 }
16263
16264 // skip to next mask
16265
16266 dictpos++;
16267
16268 rd->dictpos = dictpos;
16269
16270 logfile_sub_msg ("STOP");
16271
16272 continue;
16273 }
16274
16275 uint save_css_cnt = css_cnt;
16276
16277 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16278 {
16279 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16280 {
16281 uint salt_len = (uint) data.salts_buf[0].salt_len;
16282 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16283
16284 uint css_cnt_salt = css_cnt + salt_len;
16285
16286 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16287
16288 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16289
16290 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16291 {
16292 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16293 css_buf_salt[j].cs_len = 1;
16294 }
16295
16296 free (css_buf);
16297
16298 css_buf = css_buf_salt;
16299 css_cnt = css_cnt_salt;
16300 }
16301 }
16302
16303 data.mask = mask;
16304 data.css_cnt = css_cnt;
16305 data.css_buf = css_buf;
16306
16307 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16308
16309 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16310
16311 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16312
16313 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16314 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16315
16316 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16317
16318 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16319
16320 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16321 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16322
16323 data.root_css_buf = root_css_buf;
16324 data.markov_css_buf = markov_css_buf;
16325
16326 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16327
16328 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16329
16330 local_free (root_table_buf);
16331 local_free (markov_table_buf);
16332
16333 // copy + args
16334
16335 uint css_cnt_l = css_cnt;
16336 uint css_cnt_r;
16337
16338 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16339 {
16340 if (save_css_cnt < 6)
16341 {
16342 css_cnt_r = 1;
16343 }
16344 else if (save_css_cnt == 6)
16345 {
16346 css_cnt_r = 2;
16347 }
16348 else
16349 {
16350 if (opts_type & OPTS_TYPE_PT_UNICODE)
16351 {
16352 if (save_css_cnt == 8 || save_css_cnt == 10)
16353 {
16354 css_cnt_r = 2;
16355 }
16356 else
16357 {
16358 css_cnt_r = 4;
16359 }
16360 }
16361 else
16362 {
16363 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16364 {
16365 css_cnt_r = 3;
16366 }
16367 else
16368 {
16369 css_cnt_r = 4;
16370 }
16371 }
16372 }
16373 }
16374 else
16375 {
16376 css_cnt_r = 1;
16377
16378 /* unfinished code?
16379 int sum = css_buf[css_cnt_r - 1].cs_len;
16380
16381 for (uint i = 1; i < 4 && i < css_cnt; i++)
16382 {
16383 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16384
16385 css_cnt_r++;
16386
16387 sum *= css_buf[css_cnt_r - 1].cs_len;
16388 }
16389 */
16390 }
16391
16392 css_cnt_l -= css_cnt_r;
16393
16394 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16395
16396 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16397 {
16398 hc_device_param_t *device_param = &data.devices_param[device_id];
16399
16400 if (device_param->skipped) continue;
16401
16402 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16403 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16404 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16405
16406 device_param->kernel_params_mp_l_buf64[3] = 0;
16407 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16408 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16409 device_param->kernel_params_mp_l_buf32[6] = 0;
16410 device_param->kernel_params_mp_l_buf32[7] = 0;
16411 device_param->kernel_params_mp_l_buf32[8] = 0;
16412
16413 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16414 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16415 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16416 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16417
16418 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16419 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16420 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16421
16422 device_param->kernel_params_mp_r_buf64[3] = 0;
16423 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16424 device_param->kernel_params_mp_r_buf32[5] = 0;
16425 device_param->kernel_params_mp_r_buf32[6] = 0;
16426 device_param->kernel_params_mp_r_buf32[7] = 0;
16427
16428 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]);
16429 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]);
16430 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]);
16431
16432 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]);
16433 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]);
16434 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]);
16435
16436 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);
16437 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);
16438 }
16439 }
16440
16441 u64 words_base = data.words_cnt;
16442
16443 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16444 {
16445 if (data.kernel_rules_cnt)
16446 {
16447 words_base /= data.kernel_rules_cnt;
16448 }
16449 }
16450 else if (data.attack_kern == ATTACK_KERN_COMBI)
16451 {
16452 if (data.combs_cnt)
16453 {
16454 words_base /= data.combs_cnt;
16455 }
16456 }
16457 else if (data.attack_kern == ATTACK_KERN_BF)
16458 {
16459 if (data.bfs_cnt)
16460 {
16461 words_base /= data.bfs_cnt;
16462 }
16463 }
16464
16465 data.words_base = words_base;
16466
16467 if (keyspace == 1)
16468 {
16469 log_info ("%llu", (unsigned long long int) words_base);
16470
16471 return (0);
16472 }
16473
16474 if (data.words_cur > data.words_base)
16475 {
16476 log_error ("ERROR: restore value greater keyspace");
16477
16478 return (-1);
16479 }
16480
16481 if (data.words_cur)
16482 {
16483 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16484 {
16485 for (uint i = 0; i < data.salts_cnt; i++)
16486 {
16487 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16488 }
16489 }
16490 else if (data.attack_kern == ATTACK_KERN_COMBI)
16491 {
16492 for (uint i = 0; i < data.salts_cnt; i++)
16493 {
16494 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16495 }
16496 }
16497 else if (data.attack_kern == ATTACK_KERN_BF)
16498 {
16499 for (uint i = 0; i < data.salts_cnt; i++)
16500 {
16501 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16502 }
16503 }
16504 }
16505
16506 /*
16507 * Inform user about possible slow speeds
16508 */
16509
16510 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16511 {
16512 if (data.words_base < kernel_power_all)
16513 {
16514 if (quiet == 0)
16515 {
16516 log_info ("");
16517 log_info ("ATTENTION!");
16518 log_info (" The wordlist or mask you are using is too small.");
16519 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16520 log_info (" The cracking speed will drop.");
16521 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16522 log_info ("");
16523 }
16524 }
16525 }
16526
16527 /*
16528 * Update loopback file
16529 */
16530
16531 if (loopback == 1)
16532 {
16533 time_t now;
16534
16535 time (&now);
16536
16537 uint random_num = get_random_num (0, 9999);
16538
16539 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16540
16541 data.loopback_file = loopback_file;
16542 }
16543
16544 /*
16545 * Update dictionary statistic
16546 */
16547
16548 if (keyspace == 0)
16549 {
16550 dictstat_fp = fopen (dictstat, "wb");
16551
16552 if (dictstat_fp)
16553 {
16554 lock_file (dictstat_fp);
16555
16556 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16557
16558 fclose (dictstat_fp);
16559 }
16560 }
16561
16562 data.devices_status = STATUS_RUNNING;
16563
16564 if (initial_restore_done == 0)
16565 {
16566 if (data.restore_disable == 0) cycle_restore ();
16567
16568 initial_restore_done = 1;
16569 }
16570
16571 hc_timer_set (&data.timer_running);
16572
16573 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16574 {
16575 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16576 {
16577 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16578 if (quiet == 0) fflush (stdout);
16579 }
16580 }
16581 else if (wordlist_mode == WL_MODE_STDIN)
16582 {
16583 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16584 if (data.quiet == 0) log_info ("");
16585 }
16586
16587 time_t runtime_start;
16588
16589 time (&runtime_start);
16590
16591 data.runtime_start = runtime_start;
16592
16593 /**
16594 * create cracker threads
16595 */
16596
16597 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16598
16599 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16600 {
16601 hc_device_param_t *device_param = &devices_param[device_id];
16602
16603 if (wordlist_mode == WL_MODE_STDIN)
16604 {
16605 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16606 }
16607 else
16608 {
16609 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16610 }
16611 }
16612
16613 // wait for crack threads to exit
16614
16615 hc_thread_wait (data.devices_cnt, c_threads);
16616
16617 local_free (c_threads);
16618
16619 data.restore = 0;
16620
16621 // finalize task
16622
16623 logfile_sub_var_uint ("status-after-work", data.devices_status);
16624
16625 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16626
16627 if (data.devices_status == STATUS_CRACKED) break;
16628 if (data.devices_status == STATUS_ABORTED) break;
16629
16630 if (data.devices_status == STATUS_BYPASS)
16631 {
16632 data.devices_status = STATUS_RUNNING;
16633 }
16634
16635 if (induction_dictionaries_cnt)
16636 {
16637 unlink (induction_dictionaries[0]);
16638 }
16639
16640 free (induction_dictionaries);
16641
16642 if (attack_mode != ATTACK_MODE_BF)
16643 {
16644 induction_dictionaries = scan_directory (induction_directory);
16645
16646 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16647 }
16648
16649 if (benchmark == 0)
16650 {
16651 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16652 {
16653 if (quiet == 0) clear_prompt ();
16654
16655 if (quiet == 0) log_info ("");
16656
16657 if (status == 1)
16658 {
16659 status_display ();
16660 }
16661 else
16662 {
16663 if (quiet == 0) status_display ();
16664 }
16665
16666 if (quiet == 0) log_info ("");
16667 }
16668 }
16669
16670 if (attack_mode == ATTACK_MODE_BF)
16671 {
16672 dictpos++;
16673
16674 rd->dictpos = dictpos;
16675 }
16676 else
16677 {
16678 if (induction_dictionaries_cnt)
16679 {
16680 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16681 }
16682 else
16683 {
16684 dictpos++;
16685
16686 rd->dictpos = dictpos;
16687 }
16688 }
16689
16690 time_t runtime_stop;
16691
16692 time (&runtime_stop);
16693
16694 data.runtime_stop = runtime_stop;
16695
16696 logfile_sub_uint (runtime_start);
16697 logfile_sub_uint (runtime_stop);
16698
16699 logfile_sub_msg ("STOP");
16700
16701 global_free (subid);
16702 }
16703
16704 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16705
16706 if (data.devices_status == STATUS_CRACKED) break;
16707 if (data.devices_status == STATUS_ABORTED) break;
16708 if (data.devices_status == STATUS_QUIT) break;
16709
16710 if (data.devices_status == STATUS_BYPASS)
16711 {
16712 data.devices_status = STATUS_RUNNING;
16713 }
16714 }
16715
16716 // 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
16717
16718 if (attack_mode == ATTACK_MODE_STRAIGHT)
16719 {
16720 if (data.wordlist_mode == WL_MODE_FILE)
16721 {
16722 if (data.dictfile == NULL)
16723 {
16724 if (dictfiles != NULL)
16725 {
16726 data.dictfile = dictfiles[0];
16727
16728 hc_timer_set (&data.timer_running);
16729 }
16730 }
16731 }
16732 }
16733 // NOTE: combi is okay because it is already set beforehand
16734 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16735 {
16736 if (data.dictfile == NULL)
16737 {
16738 if (dictfiles != NULL)
16739 {
16740 hc_timer_set (&data.timer_running);
16741
16742 data.dictfile = dictfiles[0];
16743 }
16744 }
16745 }
16746 else if (attack_mode == ATTACK_MODE_BF)
16747 {
16748 if (data.mask == NULL)
16749 {
16750 hc_timer_set (&data.timer_running);
16751
16752 data.mask = masks[0];
16753 }
16754 }
16755
16756 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16757 {
16758 data.devices_status = STATUS_EXHAUSTED;
16759 }
16760
16761 // if cracked / aborted remove last induction dictionary
16762
16763 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16764 {
16765 struct stat induct_stat;
16766
16767 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16768 {
16769 unlink (induction_dictionaries[file_pos]);
16770 }
16771 }
16772
16773 // wait for non-interactive threads
16774
16775 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16776 {
16777 hc_thread_wait (1, &ni_threads[thread_idx]);
16778 }
16779
16780 local_free (ni_threads);
16781
16782 // wait for interactive threads
16783
16784 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16785 {
16786 hc_thread_wait (1, &i_thread);
16787 }
16788
16789 // we dont need restore file anymore
16790 if (data.restore_disable == 0)
16791 {
16792 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16793 {
16794 unlink (eff_restore_file);
16795 unlink (new_restore_file);
16796 }
16797 else
16798 {
16799 cycle_restore ();
16800 }
16801 }
16802
16803 // finally save left hashes
16804
16805 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16806 {
16807 save_hash ();
16808 }
16809
16810 /**
16811 * Clean up
16812 */
16813
16814 if (benchmark == 1)
16815 {
16816 status_benchmark ();
16817
16818 log_info ("");
16819 }
16820 else
16821 {
16822 if (quiet == 0) clear_prompt ();
16823
16824 if (quiet == 0) log_info ("");
16825
16826 if (status == 1)
16827 {
16828 status_display ();
16829 }
16830 else
16831 {
16832 if (quiet == 0) status_display ();
16833 }
16834
16835 if (quiet == 0) log_info ("");
16836 }
16837
16838 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16839 {
16840 hc_device_param_t *device_param = &data.devices_param[device_id];
16841
16842 if (device_param->skipped) continue;
16843
16844 local_free (device_param->result);
16845
16846 local_free (device_param->combs_buf);
16847
16848 local_free (device_param->hooks_buf);
16849
16850 local_free (device_param->device_name);
16851
16852 local_free (device_param->device_name_chksum);
16853
16854 local_free (device_param->device_version);
16855
16856 local_free (device_param->driver_version);
16857
16858 if (device_param->pws_buf) myfree (device_param->pws_buf);
16859 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16860 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16861 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16862 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16863 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16864 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16865 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16866 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16867 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16868 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16869 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16870 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16871 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16872 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16873 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16874 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16875 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16876 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16877 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16878 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16879 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16880 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16881 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16882 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16883 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16884 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16885 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16886 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16887
16888 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16889 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16890 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16891 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16892 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16893 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16894 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16895 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16896 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16897 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16898
16899 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16900 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16901 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16902
16903 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16904 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16905 }
16906
16907 // reset default fan speed
16908
16909 #ifdef HAVE_HWMON
16910 if (gpu_temp_disable == 0)
16911 {
16912 #ifdef HAVE_ADL
16913 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16914 {
16915 hc_thread_mutex_lock (mux_adl);
16916
16917 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16918 {
16919 hc_device_param_t *device_param = &data.devices_param[device_id];
16920
16921 if (device_param->skipped) continue;
16922
16923 if (data.hm_device[device_id].fan_supported == 1)
16924 {
16925 int fanspeed = temp_retain_fanspeed_value[device_id];
16926
16927 if (fanspeed == -1) continue;
16928
16929 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16930
16931 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16932 }
16933 }
16934
16935 hc_thread_mutex_unlock (mux_adl);
16936 }
16937 #endif // HAVE_ADL
16938 }
16939
16940 #ifdef HAVE_ADL
16941 // reset power tuning
16942
16943 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16944 {
16945 hc_thread_mutex_lock (mux_adl);
16946
16947 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16948 {
16949 hc_device_param_t *device_param = &data.devices_param[device_id];
16950
16951 if (device_param->skipped) continue;
16952
16953 if (data.hm_device[device_id].od_version == 6)
16954 {
16955 // check powertune capabilities first, if not available then skip device
16956
16957 int powertune_supported = 0;
16958
16959 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16960 {
16961 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16962
16963 return (-1);
16964 }
16965
16966 if (powertune_supported != 0)
16967 {
16968 // powercontrol settings
16969
16970 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)
16971 {
16972 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16973
16974 return (-1);
16975 }
16976
16977 // clocks
16978
16979 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16980
16981 performance_state->iNumberOfPerformanceLevels = 2;
16982
16983 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16984 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16985 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16986 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16987
16988 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)
16989 {
16990 log_info ("ERROR: Failed to restore ADL performance state");
16991
16992 return (-1);
16993 }
16994
16995 local_free (performance_state);
16996 }
16997 }
16998 }
16999
17000 hc_thread_mutex_unlock (mux_adl);
17001 }
17002 #endif // HAVE_ADL
17003
17004 if (gpu_temp_disable == 0)
17005 {
17006 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17007 if (data.hm_nv)
17008 {
17009 #if defined(LINUX) && defined(HAVE_NVML)
17010
17011 hm_NVML_nvmlShutdown (data.hm_nv);
17012
17013 nvml_close (data.hm_nv);
17014
17015 #elif defined(WIN) && (HAVE_NVAPI)
17016
17017 hm_NvAPI_Unload (data.hm_nv);
17018
17019 nvapi_close (data.hm_nv);
17020
17021 #endif
17022
17023 data.hm_nv = NULL;
17024 }
17025 #endif
17026
17027 #ifdef HAVE_ADL
17028 if (data.hm_amd)
17029 {
17030 hm_ADL_Main_Control_Destroy (data.hm_amd);
17031
17032 adl_close (data.hm_amd);
17033 data.hm_amd = NULL;
17034 }
17035 #endif
17036 }
17037 #endif // HAVE_HWMON
17038
17039 // free memory
17040
17041 local_free (masks);
17042
17043 local_free (dictstat_base);
17044
17045 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17046 {
17047 pot_t *pot_ptr = &pot[pot_pos];
17048
17049 hash_t *hash = &pot_ptr->hash;
17050
17051 local_free (hash->digest);
17052
17053 if (isSalted)
17054 {
17055 local_free (hash->salt);
17056 }
17057 }
17058
17059 local_free (pot);
17060
17061 local_free (all_kernel_rules_cnt);
17062 local_free (all_kernel_rules_buf);
17063
17064 local_free (wl_data->buf);
17065 local_free (wl_data);
17066
17067 local_free (bitmap_s1_a);
17068 local_free (bitmap_s1_b);
17069 local_free (bitmap_s1_c);
17070 local_free (bitmap_s1_d);
17071 local_free (bitmap_s2_a);
17072 local_free (bitmap_s2_b);
17073 local_free (bitmap_s2_c);
17074 local_free (bitmap_s2_d);
17075
17076 #ifdef HAVE_HWMON
17077 local_free (temp_retain_fanspeed_value);
17078 #ifdef HAVE_ADL
17079 local_free (od_clock_mem_status);
17080 local_free (od_power_control_status);
17081 #endif // ADL
17082 #endif
17083
17084 global_free (devices_param);
17085
17086 global_free (kernel_rules_buf);
17087
17088 global_free (root_css_buf);
17089 global_free (markov_css_buf);
17090
17091 global_free (digests_buf);
17092 global_free (digests_shown);
17093 global_free (digests_shown_tmp);
17094
17095 global_free (salts_buf);
17096 global_free (salts_shown);
17097
17098 global_free (esalts_buf);
17099
17100 global_free (words_progress_done);
17101 global_free (words_progress_rejected);
17102 global_free (words_progress_restored);
17103
17104 if (pot_fp) fclose (pot_fp);
17105
17106 if (data.devices_status == STATUS_QUIT) break;
17107 }
17108
17109 // destroy others mutex
17110
17111 hc_thread_mutex_delete (mux_dispatcher);
17112 hc_thread_mutex_delete (mux_counter);
17113 hc_thread_mutex_delete (mux_display);
17114 hc_thread_mutex_delete (mux_adl);
17115
17116 // free memory
17117
17118 local_free (eff_restore_file);
17119 local_free (new_restore_file);
17120
17121 local_free (rd);
17122
17123 // tuning db
17124
17125 tuning_db_destroy (tuning_db);
17126
17127 // loopback
17128
17129 local_free (loopback_file);
17130
17131 if (loopback == 1) unlink (loopback_file);
17132
17133 // induction directory
17134
17135 if (induction_dir == NULL)
17136 {
17137 if (attack_mode != ATTACK_MODE_BF)
17138 {
17139 if (rmdir (induction_directory) == -1)
17140 {
17141 if (errno == ENOENT)
17142 {
17143 // good, we can ignore
17144 }
17145 else if (errno == ENOTEMPTY)
17146 {
17147 // good, we can ignore
17148 }
17149 else
17150 {
17151 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17152
17153 return (-1);
17154 }
17155 }
17156
17157 local_free (induction_directory);
17158 }
17159 }
17160
17161 // outfile-check directory
17162
17163 if (outfile_check_dir == NULL)
17164 {
17165 if (rmdir (outfile_check_directory) == -1)
17166 {
17167 if (errno == ENOENT)
17168 {
17169 // good, we can ignore
17170 }
17171 else if (errno == ENOTEMPTY)
17172 {
17173 // good, we can ignore
17174 }
17175 else
17176 {
17177 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17178
17179 return (-1);
17180 }
17181 }
17182
17183 local_free (outfile_check_directory);
17184 }
17185
17186 time_t proc_stop;
17187
17188 time (&proc_stop);
17189
17190 logfile_top_uint (proc_start);
17191 logfile_top_uint (proc_stop);
17192
17193 logfile_top_msg ("STOP");
17194
17195 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17196 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17197
17198 if (data.ocl) ocl_close (data.ocl);
17199
17200 if (data.devices_status == STATUS_ABORTED) return 2;
17201 if (data.devices_status == STATUS_QUIT) return 2;
17202 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17203 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17204 if (data.devices_status == STATUS_CRACKED) return 0;
17205
17206 return -1;
17207 }
Hashcat additions to support pwdhash