projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Some final fixes for d_return_buf refactorization; Initial kernels vor veracrypts...
[hashcat.git] / src / hashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "hashcat";
19 const uint VERSION_BIN = 300;
20 const uint RESTORE_MIN = 300;
21
22 double TARGET_MS_PROFILE[3] = { 8, 16, 96 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define RESTORE 0
37 #define RESTORE_TIMER 60
38 #define RESTORE_DISABLE 0
39 #define STATUS 0
40 #define STATUS_TIMER 10
41 #define STATUS_AUTOMAT 0
42 #define LOOPBACK 0
43 #define WEAK_HASH_THRESHOLD 100
44 #define SHOW 0
45 #define LEFT 0
46 #define USERNAME 0
47 #define REMOVE 0
48 #define REMOVE_TIMER 60
49 #define SKIP 0
50 #define LIMIT 0
51 #define KEYSPACE 0
52 #define POTFILE_DISABLE 0
53 #define DEBUG_MODE 0
54 #define RP_GEN 0
55 #define RP_GEN_FUNC_MIN 1
56 #define RP_GEN_FUNC_MAX 4
57 #define RP_GEN_SEED 0
58 #define RULE_BUF_L ":"
59 #define RULE_BUF_R ":"
60 #define FORCE 0
61 #define RUNTIME 0
62 #define HEX_CHARSET 0
63 #define HEX_SALT 0
64 #define HEX_WORDLIST 0
65 #define OUTFILE_FORMAT 3
66 #define OUTFILE_AUTOHEX 1
67 #define OUTFILE_CHECK_TIMER 5
68 #define ATTACK_MODE 0
69 #define HASH_MODE 0
70 #define SEGMENT_SIZE 32
71 #define INCREMENT 0
72 #define INCREMENT_MIN 1
73 #define INCREMENT_MAX PW_MAX
74 #define SEPARATOR ':'
75 #define BITMAP_MIN 16
76 #define BITMAP_MAX 24
77 #define GPU_TEMP_DISABLE 0
78 #define GPU_TEMP_ABORT 90
79 #define GPU_TEMP_RETAIN 80
80 #define WORKLOAD_PROFILE 2
81 #define KERNEL_ACCEL 0
82 #define KERNEL_LOOPS 0
83 #define KERNEL_RULES 1024
84 #define KERNEL_COMBS 1024
85 #define KERNEL_BFS 1024
86 #define KERNEL_THREADS_MAX 256
87 #define KERNEL_THREADS_MAX_CPU 16
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
152
153 #define global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
168 {
169 900,
170 0,
171 5100,
172 100,
173 1400,
174 10800,
175 1700,
176 5000,
177 10100,
178 6000,
179 6100,
180 6900,
181 11700,
182 11800,
183 400,
184 8900,
185 11900,
186 12000,
187 10900,
188 12100,
189 23,
190 2500,
191 5300,
192 5400,
193 5500,
194 5600,
195 7300,
196 7500,
197 13100,
198 8300,
199 11100,
200 11200,
201 11400,
202 121,
203 2611,
204 2711,
205 2811,
206 8400,
207 11,
208 2612,
209 7900,
210 21,
211 11000,
212 124,
213 10000,
214 3711,
215 7600,
216 12,
217 131,
218 132,
219 1731,
220 200,
221 300,
222 3100,
223 112,
224 12300,
225 8000,
226 141,
227 1441,
228 1600,
229 12600,
230 1421,
231 101,
232 111,
233 1711,
234 3000,
235 1000,
236 1100,
237 2100,
238 12800,
239 1500,
240 12400,
241 500,
242 3200,
243 7400,
244 1800,
245 122,
246 1722,
247 7100,
248 6300,
249 6700,
250 6400,
251 6500,
252 2400,
253 2410,
254 5700,
255 9200,
256 9300,
257 22,
258 501,
259 5800,
260 8100,
261 8500,
262 7200,
263 9900,
264 7700,
265 7800,
266 10300,
267 8600,
268 8700,
269 9100,
270 133,
271 13500,
272 11600,
273 13600,
274 12500,
275 13000,
276 13200,
277 13300,
278 6211,
279 6221,
280 6231,
281 6241,
282 13711,
283 13721,
284 13731,
285 13741,
286 13751,
287 13761,
288 8800,
289 12900,
290 12200,
291 9700,
292 9710,
293 9800,
294 9810,
295 9400,
296 9500,
297 9600,
298 10400,
299 10410,
300 10500,
301 10600,
302 10700,
303 9000,
304 5200,
305 6800,
306 6600,
307 8200,
308 11300,
309 12700,
310 13400,
311 125
312 };
313
314 /**
315 * types
316 */
317
318 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
319
320 /**
321 * globals
322 */
323
324 static unsigned int full01 = 0x01010101;
325 static unsigned int full80 = 0x80808080;
326
327 int SUPPRESS_OUTPUT = 0;
328
329 hc_thread_mutex_t mux_adl;
330 hc_thread_mutex_t mux_counter;
331 hc_thread_mutex_t mux_dispatcher;
332 hc_thread_mutex_t mux_display;
333
334 hc_global_data_t data;
335
336 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
337
338 const char *USAGE_MINI[] =
339 {
340 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
341 "",
342 "Try --help for more help.",
343 NULL
344 };
345
346 const char *USAGE_BIG[] =
347 {
348 "%s, advanced password recovery",
349 "",
350 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
351 "",
352 "=======",
353 "Options",
354 "=======",
355 "",
356 "* General:",
357 "",
358 " -m, --hash-type=NUM Hash-type, see references below",
359 " -a, --attack-mode=NUM Attack-mode, see references below",
360 " -V, --version Print version",
361 " -h, --help Print help",
362 " --quiet Suppress output",
363 "",
364 "* Misc:",
365 "",
366 " --hex-charset Assume charset is given in hex",
367 " --hex-salt Assume salt is given in hex",
368 " --hex-wordlist Assume words in wordlist is given in hex",
369 " --force Ignore warnings",
370 " --status Enable automatic update of the status-screen",
371 " --status-timer=NUM Seconds between status-screen update",
372 " --status-automat Display the status view in a machine readable format",
373 " --loopback Add new plains to induct directory",
374 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
375 "",
376 "* Markov:",
377 "",
378 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
379 " --markov-disable Disables markov-chains, emulates classic brute-force",
380 " --markov-classic Enables classic markov-chains, no per-position enhancement",
381 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
382 "",
383 "* Session:",
384 "",
385 " --runtime=NUM Abort session after NUM seconds of runtime",
386 " --session=STR Define specific session name",
387 " --restore Restore session from --session",
388 " --restore-disable Do not write restore file",
389 "",
390 "* Files:",
391 "",
392 " -o, --outfile=FILE Define outfile for recovered hash",
393 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
394 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
395 " --outfile-check-timer=NUM Seconds between outfile checks",
396 " -p, --separator=CHAR Separator char for hashlists and outfile",
397 " --show Show cracked passwords only",
398 " --left Show un-cracked passwords only",
399 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
400 " --remove Enable remove of hash once it is cracked",
401 " --remove-timer=NUM Update input hash file each NUM seconds",
402 " --potfile-disable Do not write potfile",
403 " --potfile-path Specific path to potfile",
404 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
405 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
406 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
407 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
408 " --logfile-disable Disable the logfile",
409 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
410 " --veracrypt-keyfiles=FILE Keyfiles used, separate with comma",
411 " --veracrypt-pim=NUM VeraCrypt personal iterations multiplier",
412 "",
413 "* Resources:",
414 "",
415 " -b, --benchmark Run benchmark",
416 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
417 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
418 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
419 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
420 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
421 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
422 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
423 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
424 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
425 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
426 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
427 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
428 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
429 #ifdef HAVE_HWMON
430 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
431 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
432 #ifdef HAVE_ADL
433 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
434 #endif
435 #endif
436 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
437 "",
438 "* Distributed:",
439 "",
440 " -s, --skip=NUM Skip number of words",
441 " -l, --limit=NUM Limit number of words",
442 " --keyspace Show keyspace base:mod values and quit",
443 "",
444 "* Rules:",
445 "",
446 " -j, --rule-left=RULE Single rule applied to each word from left dict",
447 " -k, --rule-right=RULE Single rule applied to each word from right dict",
448 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
449 " -g, --generate-rules=NUM Generate NUM random rules",
450 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
451 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
452 " --generate-rules-seed=NUM Force RNG seed to NUM",
453 "",
454 "* Custom charsets:",
455 "",
456 " -1, --custom-charset1=CS User-defined charsets",
457 " -2, --custom-charset2=CS Example:",
458 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
459 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
460 "",
461 "* Increment:",
462 "",
463 " -i, --increment Enable increment mode",
464 " --increment-min=NUM Start incrementing at NUM",
465 " --increment-max=NUM Stop incrementing at NUM",
466 "",
467 "==========",
468 "References",
469 "==========",
470 "",
471 "* Workload Profile:",
472 "",
473 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
474 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
475 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
476 "",
477 "* OpenCL device-types:",
478 "",
479 " 1 = CPU devices",
480 " 2 = GPU devices",
481 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
482 "",
483 "* Outfile Formats:",
484 "",
485 " 1 = hash[:salt]",
486 " 2 = plain",
487 " 3 = hash[:salt]:plain",
488 " 4 = hex_plain",
489 " 5 = hash[:salt]:hex_plain",
490 " 6 = plain:hex_plain",
491 " 7 = hash[:salt]:plain:hex_plain",
492 " 8 = crackpos",
493 " 9 = hash[:salt]:crackpos",
494 " 10 = plain:crackpos",
495 " 11 = hash[:salt]:plain:crackpos",
496 " 12 = hex_plain:crackpos",
497 " 13 = hash[:salt]:hex_plain:crackpos",
498 " 14 = plain:hex_plain:crackpos",
499 " 15 = hash[:salt]:plain:hex_plain:crackpos",
500 "",
501 "* Debug mode output formats (for hybrid mode only, by using rules):",
502 "",
503 " 1 = save finding rule",
504 " 2 = save original word",
505 " 3 = save original word and finding rule",
506 " 4 = save original word, finding rule and modified plain",
507 "",
508 "* Built-in charsets:",
509 "",
510 " ?l = abcdefghijklmnopqrstuvwxyz",
511 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
512 " ?d = 0123456789",
513 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
514 " ?a = ?l?u?d?s",
515 " ?b = 0x00 - 0xff",
516 "",
517 "* Attack modes:",
518 "",
519 " 0 = Straight",
520 " 1 = Combination",
521 " 3 = Brute-force",
522 " 6 = Hybrid dict + mask",
523 " 7 = Hybrid mask + dict",
524 "",
525 "* Hash types:",
526 "",
527 "[[ Roll-your-own: Raw Hashes ]]",
528 "",
529 " 900 = MD4",
530 " 0 = MD5",
531 " 5100 = Half MD5",
532 " 100 = SHA1",
533 " 10800 = SHA-384",
534 " 1400 = SHA-256",
535 " 1700 = SHA-512",
536 " 5000 = SHA-3(Keccak)",
537 " 10100 = SipHash",
538 " 6000 = RipeMD160",
539 " 6100 = Whirlpool",
540 " 6900 = GOST R 34.11-94",
541 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
542 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
543 "",
544 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
545 "",
546 " 10 = md5($pass.$salt)",
547 " 20 = md5($salt.$pass)",
548 " 30 = md5(unicode($pass).$salt)",
549 " 40 = md5($salt.unicode($pass))",
550 " 3800 = md5($salt.$pass.$salt)",
551 " 3710 = md5($salt.md5($pass))",
552 " 2600 = md5(md5($pass)",
553 " 4300 = md5(strtoupper(md5($pass)))",
554 " 4400 = md5(sha1($pass))",
555 " 110 = sha1($pass.$salt)",
556 " 120 = sha1($salt.$pass)",
557 " 130 = sha1(unicode($pass).$salt)",
558 " 140 = sha1($salt.unicode($pass))",
559 " 4500 = sha1(sha1($pass)",
560 " 4700 = sha1(md5($pass))",
561 " 4900 = sha1($salt.$pass.$salt)",
562 " 1410 = sha256($pass.$salt)",
563 " 1420 = sha256($salt.$pass)",
564 " 1430 = sha256(unicode($pass).$salt)",
565 " 1440 = sha256($salt.unicode($pass))",
566 " 1710 = sha512($pass.$salt)",
567 " 1720 = sha512($salt.$pass)",
568 " 1730 = sha512(unicode($pass).$salt)",
569 " 1740 = sha512($salt.unicode($pass))",
570 "",
571 "[[ Roll-your-own: Authenticated Hashes ]]",
572 "",
573 " 50 = HMAC-MD5 (key = $pass)",
574 " 60 = HMAC-MD5 (key = $salt)",
575 " 150 = HMAC-SHA1 (key = $pass)",
576 " 160 = HMAC-SHA1 (key = $salt)",
577 " 1450 = HMAC-SHA256 (key = $pass)",
578 " 1460 = HMAC-SHA256 (key = $salt)",
579 " 1750 = HMAC-SHA512 (key = $pass)",
580 " 1760 = HMAC-SHA512 (key = $salt)",
581 "",
582 "[[ Generic KDF ]]",
583 "",
584 " 400 = phpass",
585 " 8900 = scrypt",
586 " 11900 = PBKDF2-HMAC-MD5",
587 " 12000 = PBKDF2-HMAC-SHA1",
588 " 10900 = PBKDF2-HMAC-SHA256",
589 " 12100 = PBKDF2-HMAC-SHA512",
590 "",
591 "[[ Network protocols, Challenge-Response ]]",
592 "",
593 " 23 = Skype",
594 " 2500 = WPA/WPA2",
595 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
596 " 5300 = IKE-PSK MD5",
597 " 5400 = IKE-PSK SHA1",
598 " 5500 = NetNTLMv1",
599 " 5500 = NetNTLMv1 + ESS",
600 " 5600 = NetNTLMv2",
601 " 7300 = IPMI2 RAKP HMAC-SHA1",
602 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
603 " 8300 = DNSSEC (NSEC3)",
604 " 10200 = Cram MD5",
605 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
606 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
607 " 11400 = SIP digest authentication (MD5)",
608 " 13100 = Kerberos 5 TGS-REP etype 23",
609 "",
610 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
611 "",
612 " 121 = SMF (Simple Machines Forum)",
613 " 400 = phpBB3",
614 " 2611 = vBulletin < v3.8.5",
615 " 2711 = vBulletin > v3.8.5",
616 " 2811 = MyBB",
617 " 2811 = IPB (Invison Power Board)",
618 " 8400 = WBB3 (Woltlab Burning Board)",
619 " 11 = Joomla < 2.5.18",
620 " 400 = Joomla > 2.5.18",
621 " 400 = Wordpress",
622 " 2612 = PHPS",
623 " 7900 = Drupal7",
624 " 21 = osCommerce",
625 " 21 = xt:Commerce",
626 " 11000 = PrestaShop",
627 " 124 = Django (SHA-1)",
628 " 10000 = Django (PBKDF2-SHA256)",
629 " 3711 = Mediawiki B type",
630 " 7600 = Redmine",
631 "",
632 "[[ Database Server ]]",
633 "",
634 " 12 = PostgreSQL",
635 " 131 = MSSQL(2000)",
636 " 132 = MSSQL(2005)",
637 " 1731 = MSSQL(2012)",
638 " 1731 = MSSQL(2014)",
639 " 200 = MySQL323",
640 " 300 = MySQL4.1/MySQL5",
641 " 3100 = Oracle H: Type (Oracle 7+)",
642 " 112 = Oracle S: Type (Oracle 11+)",
643 " 12300 = Oracle T: Type (Oracle 12+)",
644 " 8000 = Sybase ASE",
645 "",
646 "[[ HTTP, SMTP, LDAP Server ]]",
647 "",
648 " 141 = EPiServer 6.x < v4",
649 " 1441 = EPiServer 6.x > v4",
650 " 1600 = Apache $apr1$",
651 " 12600 = ColdFusion 10+",
652 " 1421 = hMailServer",
653 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
654 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
655 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
656 "",
657 "[[ Checksums ]]",
658 "",
659 " 11500 = CRC32",
660 "",
661 "[[ Operating-Systems ]]",
662 "",
663 " 3000 = LM",
664 " 1000 = NTLM",
665 " 1100 = Domain Cached Credentials (DCC), MS Cache",
666 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
667 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
668 " 1500 = descrypt, DES(Unix), Traditional DES",
669 " 12400 = BSDiCrypt, Extended DES",
670 " 500 = md5crypt $1$, MD5(Unix)",
671 " 3200 = bcrypt $2*$, Blowfish(Unix)",
672 " 7400 = sha256crypt $5$, SHA256(Unix)",
673 " 1800 = sha512crypt $6$, SHA512(Unix)",
674 " 122 = OSX v10.4",
675 " 122 = OSX v10.5",
676 " 122 = OSX v10.6",
677 " 1722 = OSX v10.7",
678 " 7100 = OSX v10.8",
679 " 7100 = OSX v10.9",
680 " 7100 = OSX v10.10",
681 " 6300 = AIX {smd5}",
682 " 6700 = AIX {ssha1}",
683 " 6400 = AIX {ssha256}",
684 " 6500 = AIX {ssha512}",
685 " 2400 = Cisco-PIX",
686 " 2410 = Cisco-ASA",
687 " 500 = Cisco-IOS $1$",
688 " 5700 = Cisco-IOS $4$",
689 " 9200 = Cisco-IOS $8$",
690 " 9300 = Cisco-IOS $9$",
691 " 22 = Juniper Netscreen/SSG (ScreenOS)",
692 " 501 = Juniper IVE",
693 " 5800 = Android PIN",
694 " 8100 = Citrix Netscaler",
695 " 8500 = RACF",
696 " 7200 = GRUB 2",
697 " 9900 = Radmin2",
698 " 125 = ArubaOS",
699 "",
700 "[[ Enterprise Application Software (EAS) ]]",
701 "",
702 " 7700 = SAP CODVN B (BCODE)",
703 " 7800 = SAP CODVN F/G (PASSCODE)",
704 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
705 " 8600 = Lotus Notes/Domino 5",
706 " 8700 = Lotus Notes/Domino 6",
707 " 9100 = Lotus Notes/Domino 8",
708 " 133 = PeopleSoft",
709 " 13500 = PeopleSoft Token",
710 "",
711 "[[ Archives ]]",
712 "",
713 " 11600 = 7-Zip",
714 " 12500 = RAR3-hp",
715 " 13000 = RAR5",
716 " 13200 = AxCrypt",
717 " 13300 = AxCrypt in memory SHA1",
718 " 13600 = WinZip",
719 "",
720 "[[ Full-Disk encryptions (FDE) ]]",
721 "",
722 " 62XY = TrueCrypt",
723 " X = 1 = PBKDF2-HMAC-RipeMD160",
724 " X = 2 = PBKDF2-HMAC-SHA512",
725 " X = 3 = PBKDF2-HMAC-Whirlpool",
726 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
727 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
728 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
729 " Y = 3 = XTS 1536 bit (Ciphers: All)",
730 " 8800 = Android FDE < v4.3",
731 " 12900 = Android FDE (Samsung DEK)",
732 " 12200 = eCryptfs",
733 " 137XY = VeraCrypt",
734 " X = 1 = PBKDF2-HMAC-RipeMD160",
735 " X = 2 = PBKDF2-HMAC-SHA512",
736 " X = 3 = PBKDF2-HMAC-Whirlpool",
737 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
738 " X = 5 = PBKDF2-HMAC-SHA256",
739 " X = 6 = PBKDF2-HMAC-SHA256 + boot-mode",
740 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
741 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
742 " Y = 3 = XTS 1536 bit (Ciphers: All)",
743 "",
744 "[[ Documents ]]",
745 "",
746 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
747 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
748 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
749 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
750 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
751 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
752 " 9400 = MS Office 2007",
753 " 9500 = MS Office 2010",
754 " 9600 = MS Office 2013",
755 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
756 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
757 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
758 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
759 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
760 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
761 "",
762 "[[ Password Managers ]]",
763 "",
764 " 9000 = Password Safe v2",
765 " 5200 = Password Safe v3",
766 " 6800 = Lastpass",
767 " 6600 = 1Password, agilekeychain",
768 " 8200 = 1Password, cloudkeychain",
769 " 11300 = Bitcoin/Litecoin wallet.dat",
770 " 12700 = Blockchain, My Wallet",
771 " 13400 = Keepass 1 (AES/Twofish) and Keepass 2 (AES)",
772 "",
773 NULL
774 };
775
776 /**
777 * hashcat specific functions
778 */
779
780 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
781 {
782 int exec_pos = (int) device_param->exec_pos - last_num_entries;
783
784 if (exec_pos < 0) exec_pos += EXEC_CACHE;
785
786 double exec_ms_sum = 0;
787
788 int exec_ms_cnt = 0;
789
790 for (int i = 0; i < last_num_entries; i++)
791 {
792 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
793
794 if (exec_ms)
795 {
796 exec_ms_sum += exec_ms;
797
798 exec_ms_cnt++;
799 }
800 }
801
802 if (exec_ms_cnt == 0) return 0;
803
804 return exec_ms_sum / exec_ms_cnt;
805 }
806
807 void status_display_automat ()
808 {
809 FILE *out = stdout;
810
811 fprintf (out, "STATUS\t%u\t", data.devices_status);
812
813 /**
814 * speed new
815 */
816
817 fprintf (out, "SPEED\t");
818
819 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
820 {
821 hc_device_param_t *device_param = &data.devices_param[device_id];
822
823 if (device_param->skipped) continue;
824
825 u64 speed_cnt = 0;
826 double speed_ms = 0;
827
828 for (int i = 0; i < SPEED_CACHE; i++)
829 {
830 speed_cnt += device_param->speed_cnt[i];
831 speed_ms += device_param->speed_ms[i];
832 }
833
834 speed_cnt /= SPEED_CACHE;
835 speed_ms /= SPEED_CACHE;
836
837 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
838 }
839
840 /**
841 * exec time
842 */
843
844 fprintf (out, "EXEC_RUNTIME\t");
845
846 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
847 {
848 hc_device_param_t *device_param = &data.devices_param[device_id];
849
850 if (device_param->skipped) continue;
851
852 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
853
854 fprintf (out, "%f\t", exec_ms_avg);
855 }
856
857 /**
858 * words_cur
859 */
860
861 u64 words_cur = get_lowest_words_done ();
862
863 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
864
865 /**
866 * counter
867 */
868
869 u64 progress_total = data.words_cnt * data.salts_cnt;
870
871 u64 all_done = 0;
872 u64 all_rejected = 0;
873 u64 all_restored = 0;
874
875 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
876 {
877 all_done += data.words_progress_done[salt_pos];
878 all_rejected += data.words_progress_rejected[salt_pos];
879 all_restored += data.words_progress_restored[salt_pos];
880 }
881
882 u64 progress_cur = all_restored + all_done + all_rejected;
883 u64 progress_end = progress_total;
884
885 u64 progress_skip = 0;
886
887 if (data.skip)
888 {
889 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
890
891 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
892 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
893 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
894 }
895
896 if (data.limit)
897 {
898 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
899
900 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
901 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
902 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
903 }
904
905 u64 progress_cur_relative_skip = progress_cur - progress_skip;
906 u64 progress_end_relative_skip = progress_end - progress_skip;
907
908 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
909
910 /**
911 * cracks
912 */
913
914 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
915 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
916
917 /**
918 * temperature
919 */
920
921 #ifdef HAVE_HWMON
922 if (data.gpu_temp_disable == 0)
923 {
924 fprintf (out, "TEMP\t");
925
926 hc_thread_mutex_lock (mux_adl);
927
928 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
929 {
930 hc_device_param_t *device_param = &data.devices_param[device_id];
931
932 if (device_param->skipped) continue;
933
934 int temp = hm_get_temperature_with_device_id (device_id);
935
936 fprintf (out, "%d\t", temp);
937 }
938
939 hc_thread_mutex_unlock (mux_adl);
940 }
941 #endif // HAVE_HWMON
942
943 /**
944 * flush
945 */
946
947 #ifdef _WIN
948 fputc ('\r', out);
949 fputc ('\n', out);
950 #endif
951
952 #ifdef _POSIX
953 fputc ('\n', out);
954 #endif
955
956 fflush (out);
957 }
958
959 void status_display ()
960 {
961 if (data.devices_status == STATUS_INIT) return;
962 if (data.devices_status == STATUS_STARTING) return;
963 if (data.devices_status == STATUS_BYPASS) return;
964
965 if (data.status_automat == 1)
966 {
967 status_display_automat ();
968
969 return;
970 }
971
972 char tmp_buf[1000] = { 0 };
973
974 uint tmp_len = 0;
975
976 log_info ("Session.Name...: %s", data.session);
977
978 char *status_type = strstatus (data.devices_status);
979
980 uint hash_mode = data.hash_mode;
981
982 char *hash_type = strhashtype (hash_mode); // not a bug
983
984 log_info ("Status.........: %s", status_type);
985
986 /**
987 * show rules
988 */
989
990 if (data.rp_files_cnt)
991 {
992 uint i;
993
994 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
995 {
996 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
997 }
998
999 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
1000
1001 log_info ("Rules.Type.....: %s", tmp_buf);
1002
1003 tmp_len = 0;
1004 }
1005
1006 if (data.rp_gen)
1007 {
1008 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
1009
1010 if (data.rp_gen_seed)
1011 {
1012 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
1013 }
1014 }
1015
1016 /**
1017 * show input
1018 */
1019
1020 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1021 {
1022 if (data.wordlist_mode == WL_MODE_FILE)
1023 {
1024 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1025 }
1026 else if (data.wordlist_mode == WL_MODE_STDIN)
1027 {
1028 log_info ("Input.Mode.....: Pipe");
1029 }
1030 }
1031 else if (data.attack_mode == ATTACK_MODE_COMBI)
1032 {
1033 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1034 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1035 }
1036 else if (data.attack_mode == ATTACK_MODE_BF)
1037 {
1038 char *mask = data.mask;
1039
1040 if (mask != NULL)
1041 {
1042 uint mask_len = data.css_cnt;
1043
1044 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1045
1046 if (mask_len > 0)
1047 {
1048 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1049 {
1050 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1051 {
1052 mask_len -= data.salts_buf[0].salt_len;
1053 }
1054 }
1055
1056 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1057
1058 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1059 }
1060
1061 if (data.maskcnt > 1)
1062 {
1063 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1064
1065 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1066 }
1067
1068 log_info ("Input.Mode.....: %s", tmp_buf);
1069 }
1070
1071 tmp_len = 0;
1072 }
1073 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1074 {
1075 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1076 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1077 }
1078 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1079 {
1080 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1081 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1082 }
1083
1084 if (data.digests_cnt == 1)
1085 {
1086 if (data.hash_mode == 2500)
1087 {
1088 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1089
1090 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1091 (char *) data.salts_buf[0].salt_buf,
1092 wpa->orig_mac1[0],
1093 wpa->orig_mac1[1],
1094 wpa->orig_mac1[2],
1095 wpa->orig_mac1[3],
1096 wpa->orig_mac1[4],
1097 wpa->orig_mac1[5],
1098 wpa->orig_mac2[0],
1099 wpa->orig_mac2[1],
1100 wpa->orig_mac2[2],
1101 wpa->orig_mac2[3],
1102 wpa->orig_mac2[4],
1103 wpa->orig_mac2[5]);
1104 }
1105 else if (data.hash_mode == 5200)
1106 {
1107 log_info ("Hash.Target....: File (%s)", data.hashfile);
1108 }
1109 else if (data.hash_mode == 9000)
1110 {
1111 log_info ("Hash.Target....: File (%s)", data.hashfile);
1112 }
1113 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1114 {
1115 log_info ("Hash.Target....: File (%s)", data.hashfile);
1116 }
1117 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1118 {
1119 log_info ("Hash.Target....: File (%s)", data.hashfile);
1120 }
1121 else
1122 {
1123 char out_buf[HCBUFSIZ] = { 0 };
1124
1125 ascii_digest (out_buf, 0, 0);
1126
1127 // limit length
1128 if (strlen (out_buf) > 40)
1129 {
1130 out_buf[41] = '.';
1131 out_buf[42] = '.';
1132 out_buf[43] = '.';
1133 out_buf[44] = 0;
1134 }
1135
1136 log_info ("Hash.Target....: %s", out_buf);
1137 }
1138 }
1139 else
1140 {
1141 if (data.hash_mode == 3000)
1142 {
1143 char out_buf1[32] = { 0 };
1144 char out_buf2[32] = { 0 };
1145
1146 ascii_digest (out_buf1, 0, 0);
1147 ascii_digest (out_buf2, 0, 1);
1148
1149 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1150 }
1151 else
1152 {
1153 log_info ("Hash.Target....: File (%s)", data.hashfile);
1154 }
1155 }
1156
1157 log_info ("Hash.Type......: %s", hash_type);
1158
1159 /**
1160 * speed new
1161 */
1162
1163 u64 speed_cnt[DEVICES_MAX] = { 0 };
1164 double speed_ms[DEVICES_MAX] = { 0 };
1165
1166 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1167 {
1168 hc_device_param_t *device_param = &data.devices_param[device_id];
1169
1170 if (device_param->skipped) continue;
1171
1172 speed_cnt[device_id] = 0;
1173 speed_ms[device_id] = 0;
1174
1175 for (int i = 0; i < SPEED_CACHE; i++)
1176 {
1177 speed_cnt[device_id] += device_param->speed_cnt[i];
1178 speed_ms[device_id] += device_param->speed_ms[i];
1179 }
1180
1181 speed_cnt[device_id] /= SPEED_CACHE;
1182 speed_ms[device_id] /= SPEED_CACHE;
1183 }
1184
1185 double hashes_all_ms = 0;
1186
1187 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1188
1189 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1190 {
1191 hc_device_param_t *device_param = &data.devices_param[device_id];
1192
1193 if (device_param->skipped) continue;
1194
1195 hashes_dev_ms[device_id] = 0;
1196
1197 if (speed_ms[device_id])
1198 {
1199 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1200
1201 hashes_all_ms += hashes_dev_ms[device_id];
1202 }
1203 }
1204
1205 /**
1206 * exec time
1207 */
1208
1209 double exec_all_ms[DEVICES_MAX] = { 0 };
1210
1211 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1212 {
1213 hc_device_param_t *device_param = &data.devices_param[device_id];
1214
1215 if (device_param->skipped) continue;
1216
1217 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1218
1219 exec_all_ms[device_id] = exec_ms_avg;
1220 }
1221
1222 /**
1223 * timers
1224 */
1225
1226 double ms_running = 0;
1227
1228 hc_timer_get (data.timer_running, ms_running);
1229
1230 double ms_paused = data.ms_paused;
1231
1232 if (data.devices_status == STATUS_PAUSED)
1233 {
1234 double ms_paused_tmp = 0;
1235
1236 hc_timer_get (data.timer_paused, ms_paused_tmp);
1237
1238 ms_paused += ms_paused_tmp;
1239 }
1240
1241 #ifdef WIN
1242
1243 __time64_t sec_run = ms_running / 1000;
1244
1245 #else
1246
1247 time_t sec_run = ms_running / 1000;
1248
1249 #endif
1250
1251 if (sec_run)
1252 {
1253 char display_run[32] = { 0 };
1254
1255 struct tm tm_run;
1256
1257 struct tm *tmp = NULL;
1258
1259 #ifdef WIN
1260
1261 tmp = _gmtime64 (&sec_run);
1262
1263 #else
1264
1265 tmp = gmtime (&sec_run);
1266
1267 #endif
1268
1269 if (tmp != NULL)
1270 {
1271 memset (&tm_run, 0, sizeof (tm_run));
1272
1273 memcpy (&tm_run, tmp, sizeof (tm_run));
1274
1275 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1276
1277 char *start = ctime (&data.proc_start);
1278
1279 size_t start_len = strlen (start);
1280
1281 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1282 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1283
1284 log_info ("Time.Started...: %s (%s)", start, display_run);
1285 }
1286 }
1287 else
1288 {
1289 log_info ("Time.Started...: 0 secs");
1290 }
1291
1292 /**
1293 * counters
1294 */
1295
1296 u64 progress_total = data.words_cnt * data.salts_cnt;
1297
1298 u64 all_done = 0;
1299 u64 all_rejected = 0;
1300 u64 all_restored = 0;
1301
1302 u64 progress_noneed = 0;
1303
1304 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1305 {
1306 all_done += data.words_progress_done[salt_pos];
1307 all_rejected += data.words_progress_rejected[salt_pos];
1308 all_restored += data.words_progress_restored[salt_pos];
1309
1310 // Important for ETA only
1311
1312 if (data.salts_shown[salt_pos] == 1)
1313 {
1314 const u64 all = data.words_progress_done[salt_pos]
1315 + data.words_progress_rejected[salt_pos]
1316 + data.words_progress_restored[salt_pos];
1317
1318 const u64 left = data.words_cnt - all;
1319
1320 progress_noneed += left;
1321 }
1322 }
1323
1324 u64 progress_cur = all_restored + all_done + all_rejected;
1325 u64 progress_end = progress_total;
1326
1327 u64 progress_skip = 0;
1328
1329 if (data.skip)
1330 {
1331 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1332
1333 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1334 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1335 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1336 }
1337
1338 if (data.limit)
1339 {
1340 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1341
1342 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1343 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1344 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1345 }
1346
1347 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1348 u64 progress_end_relative_skip = progress_end - progress_skip;
1349
1350 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1351 {
1352 if (data.devices_status != STATUS_CRACKED)
1353 {
1354 #ifdef WIN
1355 __time64_t sec_etc = 0;
1356 #else
1357 time_t sec_etc = 0;
1358 #endif
1359
1360 if (hashes_all_ms)
1361 {
1362 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1363
1364 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1365
1366 sec_etc = ms_left / 1000;
1367 }
1368
1369 if (sec_etc == 0)
1370 {
1371 //log_info ("Time.Estimated.: 0 secs");
1372 }
1373 else if ((u64) sec_etc > ETC_MAX)
1374 {
1375 log_info ("Time.Estimated.: > 10 Years");
1376 }
1377 else
1378 {
1379 char display_etc[32] = { 0 };
1380
1381 struct tm tm_etc;
1382
1383 struct tm *tmp = NULL;
1384
1385 #ifdef WIN
1386
1387 tmp = _gmtime64 (&sec_etc);
1388
1389 #else
1390
1391 tmp = gmtime (&sec_etc);
1392
1393 #endif
1394
1395 if (tmp != NULL)
1396 {
1397 memset (&tm_etc, 0, sizeof (tm_etc));
1398
1399 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1400
1401 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1402
1403 time_t now;
1404
1405 time (&now);
1406
1407 now += sec_etc;
1408
1409 char *etc = ctime (&now);
1410
1411 size_t etc_len = strlen (etc);
1412
1413 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1414 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1415
1416 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1417 }
1418 }
1419 }
1420 }
1421
1422 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1423 {
1424 hc_device_param_t *device_param = &data.devices_param[device_id];
1425
1426 if (device_param->skipped) continue;
1427
1428 char display_dev_cur[16] = { 0 };
1429
1430 strncpy (display_dev_cur, "0.00", 4);
1431
1432 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1433
1434 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1435 }
1436
1437 char display_all_cur[16] = { 0 };
1438
1439 strncpy (display_all_cur, "0.00", 4);
1440
1441 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1442
1443 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1444
1445 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1446 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1447
1448 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);
1449
1450 // crack-per-time
1451
1452 if (data.digests_cnt > 100)
1453 {
1454 time_t now = time (NULL);
1455
1456 int cpt_cur_min = 0;
1457 int cpt_cur_hour = 0;
1458 int cpt_cur_day = 0;
1459
1460 for (int i = 0; i < CPT_BUF; i++)
1461 {
1462 const uint cracked = data.cpt_buf[i].cracked;
1463 const time_t timestamp = data.cpt_buf[i].timestamp;
1464
1465 if ((timestamp + 60) > now)
1466 {
1467 cpt_cur_min += cracked;
1468 }
1469
1470 if ((timestamp + 3600) > now)
1471 {
1472 cpt_cur_hour += cracked;
1473 }
1474
1475 if ((timestamp + 86400) > now)
1476 {
1477 cpt_cur_day += cracked;
1478 }
1479 }
1480
1481 double ms_real = ms_running - ms_paused;
1482
1483 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1484 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1485 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1486
1487 if ((data.cpt_start + 86400) < now)
1488 {
1489 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1490 cpt_cur_min,
1491 cpt_cur_hour,
1492 cpt_cur_day,
1493 cpt_avg_min,
1494 cpt_avg_hour,
1495 cpt_avg_day);
1496 }
1497 else if ((data.cpt_start + 3600) < now)
1498 {
1499 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1500 cpt_cur_min,
1501 cpt_cur_hour,
1502 cpt_avg_min,
1503 cpt_avg_hour,
1504 cpt_avg_day);
1505 }
1506 else if ((data.cpt_start + 60) < now)
1507 {
1508 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1509 cpt_cur_min,
1510 cpt_avg_min,
1511 cpt_avg_hour,
1512 cpt_avg_day);
1513 }
1514 else
1515 {
1516 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1517 cpt_avg_min,
1518 cpt_avg_hour,
1519 cpt_avg_day);
1520 }
1521 }
1522
1523 // Restore point
1524
1525 u64 restore_point = get_lowest_words_done ();
1526
1527 u64 restore_total = data.words_base;
1528
1529 float percent_restore = 0;
1530
1531 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1532
1533 if (progress_end_relative_skip)
1534 {
1535 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1536 {
1537 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1538 float percent_rejected = 0.0;
1539
1540 if (progress_cur)
1541 {
1542 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1543 }
1544
1545 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);
1546 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1547
1548 if (data.restore_disable == 0)
1549 {
1550 if (percent_finished != 1)
1551 {
1552 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1553 }
1554 }
1555 }
1556 }
1557 else
1558 {
1559 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1560 {
1561 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1562 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1563
1564 if (data.restore_disable == 0)
1565 {
1566 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1567 }
1568 }
1569 else
1570 {
1571 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1572 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1573
1574 // --restore not allowed if stdin is used -- really? why?
1575
1576 //if (data.restore_disable == 0)
1577 //{
1578 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1579 //}
1580 }
1581 }
1582
1583 #ifdef HAVE_HWMON
1584 if (data.gpu_temp_disable == 0)
1585 {
1586 hc_thread_mutex_lock (mux_adl);
1587
1588 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1589 {
1590 hc_device_param_t *device_param = &data.devices_param[device_id];
1591
1592 if (device_param->skipped) continue;
1593
1594 #define HM_STR_BUF_SIZE 255
1595
1596 if (data.hm_device[device_id].fan_supported == 1)
1597 {
1598 char utilization[HM_STR_BUF_SIZE] = { 0 };
1599 char temperature[HM_STR_BUF_SIZE] = { 0 };
1600 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1601
1602 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1603 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1604
1605 if (device_param->vendor_id == VENDOR_ID_AMD)
1606 {
1607 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1608 }
1609 else if (device_param->vendor_id == VENDOR_ID_NV)
1610 {
1611 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1612 }
1613
1614 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1615 }
1616 else
1617 {
1618 char utilization[HM_STR_BUF_SIZE] = { 0 };
1619 char temperature[HM_STR_BUF_SIZE] = { 0 };
1620
1621 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1622 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1623
1624 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1625 }
1626 }
1627
1628 hc_thread_mutex_unlock (mux_adl);
1629 }
1630 #endif // HAVE_HWMON
1631 }
1632
1633 static void status_benchmark_automat ()
1634 {
1635 u64 speed_cnt[DEVICES_MAX] = { 0 };
1636 double speed_ms[DEVICES_MAX] = { 0 };
1637
1638 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1639 {
1640 hc_device_param_t *device_param = &data.devices_param[device_id];
1641
1642 if (device_param->skipped) continue;
1643
1644 speed_cnt[device_id] = device_param->speed_cnt[0];
1645 speed_ms[device_id] = device_param->speed_ms[0];
1646 }
1647
1648 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1649
1650 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1651 {
1652 hc_device_param_t *device_param = &data.devices_param[device_id];
1653
1654 if (device_param->skipped) continue;
1655
1656 hashes_dev_ms[device_id] = 0;
1657
1658 if (speed_ms[device_id])
1659 {
1660 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1661 }
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 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1671 }
1672 }
1673
1674 static void status_benchmark ()
1675 {
1676 if (data.devices_status == STATUS_INIT) return;
1677 if (data.devices_status == STATUS_STARTING) return;
1678 if (data.devices_status == STATUS_BYPASS) return;
1679
1680 if (data.status_automat == 1)
1681 {
1682 status_benchmark_automat ();
1683
1684 return;
1685 }
1686
1687 u64 speed_cnt[DEVICES_MAX] = { 0 };
1688 double speed_ms[DEVICES_MAX] = { 0 };
1689
1690 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1691 {
1692 hc_device_param_t *device_param = &data.devices_param[device_id];
1693
1694 if (device_param->skipped) continue;
1695
1696 speed_cnt[device_id] = device_param->speed_cnt[0];
1697 speed_ms[device_id] = device_param->speed_ms[0];
1698 }
1699
1700 double hashes_all_ms = 0;
1701
1702 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1703
1704 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1705 {
1706 hc_device_param_t *device_param = &data.devices_param[device_id];
1707
1708 if (device_param->skipped) continue;
1709
1710 hashes_dev_ms[device_id] = 0;
1711
1712 if (speed_ms[device_id])
1713 {
1714 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1715
1716 hashes_all_ms += hashes_dev_ms[device_id];
1717 }
1718 }
1719
1720 /**
1721 * exec time
1722 */
1723
1724 double exec_all_ms[DEVICES_MAX] = { 0 };
1725
1726 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1727 {
1728 hc_device_param_t *device_param = &data.devices_param[device_id];
1729
1730 if (device_param->skipped) continue;
1731
1732 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1733
1734 exec_all_ms[device_id] = exec_ms_avg;
1735 }
1736
1737 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1738 {
1739 hc_device_param_t *device_param = &data.devices_param[device_id];
1740
1741 if (device_param->skipped) continue;
1742
1743 char display_dev_cur[16] = { 0 };
1744
1745 strncpy (display_dev_cur, "0.00", 4);
1746
1747 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1748
1749 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1750 }
1751
1752 char display_all_cur[16] = { 0 };
1753
1754 strncpy (display_all_cur, "0.00", 4);
1755
1756 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1757
1758 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1759 }
1760
1761 /**
1762 * hashcat -only- functions
1763 */
1764
1765 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1766 {
1767 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1768 {
1769 if (attack_kern == ATTACK_KERN_STRAIGHT)
1770 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1771 else if (attack_kern == ATTACK_KERN_COMBI)
1772 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1773 else if (attack_kern == ATTACK_KERN_BF)
1774 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1775 }
1776 else
1777 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1778 }
1779
1780 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)
1781 {
1782 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1783 {
1784 if (attack_kern == ATTACK_KERN_STRAIGHT)
1785 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1786 else if (attack_kern == ATTACK_KERN_COMBI)
1787 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1788 else if (attack_kern == ATTACK_KERN_BF)
1789 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1790 }
1791 else
1792 {
1793 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1794 }
1795 }
1796
1797 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1798 {
1799 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1800 {
1801 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1802 }
1803 else
1804 {
1805 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1806 }
1807 }
1808
1809 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)
1810 {
1811 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1812 {
1813 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1814 }
1815 else
1816 {
1817 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1818 }
1819 }
1820
1821 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1822 {
1823 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1824 }
1825
1826 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1827 {
1828 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1829 }
1830
1831 static uint convert_from_hex (char *line_buf, const uint line_len)
1832 {
1833 if (line_len & 1) return (line_len); // not in hex
1834
1835 if (data.hex_wordlist == 1)
1836 {
1837 uint i;
1838 uint j;
1839
1840 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1841 {
1842 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1843 }
1844
1845 memset (line_buf + i, 0, line_len - i);
1846
1847 return (i);
1848 }
1849 else if (line_len >= 6) // $HEX[] = 6
1850 {
1851 if (line_buf[0] != '$') return (line_len);
1852 if (line_buf[1] != 'H') return (line_len);
1853 if (line_buf[2] != 'E') return (line_len);
1854 if (line_buf[3] != 'X') return (line_len);
1855 if (line_buf[4] != '[') return (line_len);
1856 if (line_buf[line_len - 1] != ']') return (line_len);
1857
1858 uint i;
1859 uint j;
1860
1861 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1862 {
1863 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1864 }
1865
1866 memset (line_buf + i, 0, line_len - i);
1867
1868 return (i);
1869 }
1870
1871 return (line_len);
1872 }
1873
1874 static void clear_prompt ()
1875 {
1876 fputc ('\r', stdout);
1877
1878 for (size_t i = 0; i < strlen (PROMPT); i++)
1879 {
1880 fputc (' ', stdout);
1881 }
1882
1883 fputc ('\r', stdout);
1884
1885 fflush (stdout);
1886 }
1887
1888 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1889 {
1890 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);
1891 }
1892
1893 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1894 {
1895 char *outfile = data.outfile;
1896 uint quiet = data.quiet;
1897 FILE *pot_fp = data.pot_fp;
1898 uint loopback = data.loopback;
1899 uint debug_mode = data.debug_mode;
1900 char *debug_file = data.debug_file;
1901
1902 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1903 int debug_rule_len = 0; // -1 error
1904 uint debug_plain_len = 0;
1905
1906 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1907
1908 // hash
1909
1910 char out_buf[HCBUFSIZ] = { 0 };
1911
1912 const u32 salt_pos = plain->salt_pos;
1913 const u32 digest_pos = plain->digest_pos; // relative
1914 const u32 gidvid = plain->gidvid;
1915 const u32 il_pos = plain->il_pos;
1916
1917 ascii_digest (out_buf, salt_pos, digest_pos);
1918
1919 // plain
1920
1921 u64 crackpos = device_param->words_off;
1922
1923 uint plain_buf[16] = { 0 };
1924
1925 u8 *plain_ptr = (u8 *) plain_buf;
1926
1927 unsigned int plain_len = 0;
1928
1929 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1930 {
1931 pw_t pw;
1932
1933 gidd_to_pw_t (device_param, gidvid, &pw);
1934
1935 for (int i = 0; i < 16; i++)
1936 {
1937 plain_buf[i] = pw.i[i];
1938 }
1939
1940 plain_len = pw.pw_len;
1941
1942 const uint off = device_param->innerloop_pos + il_pos;
1943
1944 if (debug_mode > 0)
1945 {
1946 debug_rule_len = 0;
1947
1948 // save rule
1949 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1950 {
1951 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1952
1953 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1954 }
1955
1956 // save plain
1957 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1958 {
1959 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1960
1961 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1962
1963 debug_plain_len = plain_len;
1964 }
1965 }
1966
1967 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1968
1969 crackpos += gidvid;
1970 crackpos *= data.kernel_rules_cnt;
1971 crackpos += device_param->innerloop_pos + il_pos;
1972
1973 if (plain_len > data.pw_max) plain_len = data.pw_max;
1974 }
1975 else if (data.attack_mode == ATTACK_MODE_COMBI)
1976 {
1977 pw_t pw;
1978
1979 gidd_to_pw_t (device_param, gidvid, &pw);
1980
1981 for (int i = 0; i < 16; i++)
1982 {
1983 plain_buf[i] = pw.i[i];
1984 }
1985
1986 plain_len = pw.pw_len;
1987
1988 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1989 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1990
1991 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1992 {
1993 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1994 }
1995 else
1996 {
1997 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1998
1999 memcpy (plain_ptr, comb_buf, comb_len);
2000 }
2001
2002 plain_len += comb_len;
2003
2004 crackpos += gidvid;
2005 crackpos *= data.combs_cnt;
2006 crackpos += device_param->innerloop_pos + il_pos;
2007
2008 if (data.pw_max != PW_DICTMAX1)
2009 {
2010 if (plain_len > data.pw_max) plain_len = data.pw_max;
2011 }
2012 }
2013 else if (data.attack_mode == ATTACK_MODE_BF)
2014 {
2015 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2016 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2017
2018 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2019 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2020
2021 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2022 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2023
2024 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2025 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2026
2027 plain_len = data.css_cnt;
2028
2029 crackpos += gidvid;
2030 crackpos *= data.bfs_cnt;
2031 crackpos += device_param->innerloop_pos + il_pos;
2032 }
2033 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2034 {
2035 pw_t pw;
2036
2037 gidd_to_pw_t (device_param, gidvid, &pw);
2038
2039 for (int i = 0; i < 16; i++)
2040 {
2041 plain_buf[i] = pw.i[i];
2042 }
2043
2044 plain_len = pw.pw_len;
2045
2046 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2047
2048 uint start = 0;
2049 uint stop = device_param->kernel_params_mp_buf32[4];
2050
2051 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2052
2053 plain_len += start + stop;
2054
2055 crackpos += gidvid;
2056 crackpos *= data.combs_cnt;
2057 crackpos += device_param->innerloop_pos + il_pos;
2058
2059 if (data.pw_max != PW_DICTMAX1)
2060 {
2061 if (plain_len > data.pw_max) plain_len = data.pw_max;
2062 }
2063 }
2064 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2065 {
2066 pw_t pw;
2067
2068 gidd_to_pw_t (device_param, gidvid, &pw);
2069
2070 for (int i = 0; i < 16; i++)
2071 {
2072 plain_buf[i] = pw.i[i];
2073 }
2074
2075 plain_len = pw.pw_len;
2076
2077 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2078
2079 uint start = 0;
2080 uint stop = device_param->kernel_params_mp_buf32[4];
2081
2082 memmove (plain_ptr + stop, plain_ptr, plain_len);
2083
2084 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2085
2086 plain_len += start + stop;
2087
2088 crackpos += gidvid;
2089 crackpos *= data.combs_cnt;
2090 crackpos += device_param->innerloop_pos + il_pos;
2091
2092 if (data.pw_max != PW_DICTMAX1)
2093 {
2094 if (plain_len > data.pw_max) plain_len = data.pw_max;
2095 }
2096 }
2097
2098 if (data.attack_mode == ATTACK_MODE_BF)
2099 {
2100 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2101 {
2102 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2103 {
2104 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2105 {
2106 plain_len = plain_len - data.salts_buf[0].salt_len;
2107 }
2108 }
2109
2110 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2111 {
2112 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2113 {
2114 plain_ptr[j] = plain_ptr[i];
2115 }
2116
2117 plain_len = plain_len / 2;
2118 }
2119 }
2120 }
2121
2122 // if enabled, update also the potfile
2123
2124 if (pot_fp)
2125 {
2126 lock_file (pot_fp);
2127
2128 fprintf (pot_fp, "%s:", out_buf);
2129
2130 format_plain (pot_fp, plain_ptr, plain_len, 1);
2131
2132 fputc ('\n', pot_fp);
2133
2134 fflush (pot_fp);
2135
2136 unlock_file (pot_fp);
2137 }
2138
2139 // outfile
2140
2141 FILE *out_fp = NULL;
2142
2143 if (outfile != NULL)
2144 {
2145 if ((out_fp = fopen (outfile, "ab")) == NULL)
2146 {
2147 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2148
2149 out_fp = stdout;
2150 }
2151 lock_file (out_fp);
2152 }
2153 else
2154 {
2155 out_fp = stdout;
2156
2157 if (quiet == 0) clear_prompt ();
2158 }
2159
2160 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2161
2162 if (outfile != NULL)
2163 {
2164 if (out_fp != stdout)
2165 {
2166 fclose (out_fp);
2167 }
2168 }
2169 else
2170 {
2171 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2172 {
2173 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2174 {
2175 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2176 if (quiet == 0) fflush (stdout);
2177 }
2178 }
2179 }
2180
2181 // loopback
2182
2183 if (loopback)
2184 {
2185 char *loopback_file = data.loopback_file;
2186
2187 FILE *fb_fp = NULL;
2188
2189 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2190 {
2191 lock_file (fb_fp);
2192
2193 format_plain (fb_fp, plain_ptr, plain_len, 1);
2194
2195 fputc ('\n', fb_fp);
2196
2197 fclose (fb_fp);
2198 }
2199 }
2200
2201 // (rule) debug mode
2202
2203 // the next check implies that:
2204 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2205 // - debug_mode > 0
2206
2207 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2208 {
2209 if (debug_rule_len < 0) debug_rule_len = 0;
2210
2211 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2212
2213 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2214
2215 if ((quiet == 0) && (debug_file == NULL))
2216 {
2217 fprintf (stdout, "%s", PROMPT);
2218
2219 fflush (stdout);
2220 }
2221 }
2222 }
2223
2224 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2225 {
2226 salt_t *salt_buf = &data.salts_buf[salt_pos];
2227
2228 u32 num_cracked;
2229
2230 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2231
2232 if (num_cracked)
2233 {
2234 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2235
2236 log_info_nn ("");
2237
2238 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2239
2240 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, 0, num_cracked * sizeof (plain_t), cracked, 0, NULL, NULL);
2241
2242 uint cpt_cracked = 0;
2243
2244 for (uint i = 0; i < num_cracked; i++)
2245 {
2246 const uint hash_pos = cracked[i].hash_pos;
2247
2248 if (data.digests_shown[hash_pos] == 1) continue;
2249
2250 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2251 {
2252 data.digests_shown[hash_pos] = 1;
2253
2254 data.digests_done++;
2255
2256 cpt_cracked++;
2257
2258 salt_buf->digests_done++;
2259
2260 if (salt_buf->digests_done == salt_buf->digests_cnt)
2261 {
2262 data.salts_shown[salt_pos] = 1;
2263
2264 data.salts_done++;
2265 }
2266 }
2267
2268 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2269
2270 check_hash (device_param, &cracked[i]);
2271 }
2272
2273 myfree (cracked);
2274
2275 if (cpt_cracked > 0)
2276 {
2277 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2278 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2279
2280 data.cpt_pos++;
2281
2282 data.cpt_total += cpt_cracked;
2283
2284 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2285 }
2286
2287 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2288 {
2289 // we need to reset cracked state on the device
2290 // otherwise host thinks again and again the hash was cracked
2291 // and returns invalid password each time
2292
2293 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2294
2295 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);
2296 }
2297
2298 num_cracked = 0;
2299
2300 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2301 }
2302 }
2303
2304 static void save_hash ()
2305 {
2306 char *hashfile = data.hashfile;
2307
2308 char new_hashfile[256] = { 0 };
2309 char old_hashfile[256] = { 0 };
2310
2311 snprintf (new_hashfile, 255, "%s.new", hashfile);
2312 snprintf (old_hashfile, 255, "%s.old", hashfile);
2313
2314 unlink (new_hashfile);
2315
2316 char separator = data.separator;
2317
2318 FILE *fp = fopen (new_hashfile, "wb");
2319
2320 if (fp == NULL)
2321 {
2322 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2323
2324 exit (-1);
2325 }
2326
2327 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2328 {
2329 if (data.salts_shown[salt_pos] == 1) continue;
2330
2331 salt_t *salt_buf = &data.salts_buf[salt_pos];
2332
2333 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2334 {
2335 uint idx = salt_buf->digests_offset + digest_pos;
2336
2337 if (data.digests_shown[idx] == 1) continue;
2338
2339 if (data.hash_mode != 2500)
2340 {
2341 char out_buf[HCBUFSIZ] = { 0 };
2342
2343 if (data.username == 1)
2344 {
2345 user_t *user = data.hash_info[idx]->user;
2346
2347 uint i;
2348
2349 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2350
2351 fputc (separator, fp);
2352 }
2353
2354 ascii_digest (out_buf, salt_pos, digest_pos);
2355
2356 fputs (out_buf, fp);
2357
2358 log_out (fp, "");
2359 }
2360 else
2361 {
2362 hccap_t hccap;
2363
2364 to_hccap_t (&hccap, salt_pos, digest_pos);
2365
2366 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2367 }
2368 }
2369 }
2370
2371 fflush (fp);
2372
2373 fclose (fp);
2374
2375 unlink (old_hashfile);
2376
2377 if (rename (hashfile, old_hashfile) != 0)
2378 {
2379 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2380
2381 exit (-1);
2382 }
2383
2384 unlink (hashfile);
2385
2386 if (rename (new_hashfile, hashfile) != 0)
2387 {
2388 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2389
2390 exit (-1);
2391 }
2392
2393 unlink (old_hashfile);
2394 }
2395
2396 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2397 {
2398 // function called only in case kernel_power_all > words_left
2399
2400 float kernel_power_div = (float) (total_left) / kernel_power_all;
2401
2402 kernel_power_div += kernel_power_div / 100;
2403
2404 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2405
2406 while (kernel_power_new < total_left)
2407 {
2408 kernel_power_div += kernel_power_div / 100;
2409
2410 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2411 }
2412
2413 if (data.quiet == 0)
2414 {
2415 clear_prompt ();
2416
2417 //log_info ("");
2418
2419 log_info ("INFO: approaching final keyspace, workload adjusted");
2420 log_info ("");
2421
2422 fprintf (stdout, "%s", PROMPT);
2423
2424 fflush (stdout);
2425 }
2426
2427 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2428
2429 return kernel_power_div;
2430 }
2431
2432 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2433 {
2434 uint num_elements = num;
2435
2436 device_param->kernel_params_buf32[30] = data.combs_mode;
2437 device_param->kernel_params_buf32[31] = num;
2438
2439 uint kernel_threads = device_param->kernel_threads;
2440
2441 while (num_elements % kernel_threads) num_elements++;
2442
2443 cl_kernel kernel = NULL;
2444
2445 switch (kern_run)
2446 {
2447 case KERN_RUN_1: kernel = device_param->kernel1; break;
2448 case KERN_RUN_12: kernel = device_param->kernel12; break;
2449 case KERN_RUN_2: kernel = device_param->kernel2; break;
2450 case KERN_RUN_23: kernel = device_param->kernel23; break;
2451 case KERN_RUN_3: kernel = device_param->kernel3; break;
2452 }
2453
2454 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2455 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2456 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2457 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2458 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2459 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2460 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2461 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2462 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2463 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2464 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2465
2466 cl_event event;
2467
2468 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2469 {
2470 const size_t global_work_size[3] = { num_elements, 32, 1 };
2471 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2472
2473 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2474 }
2475 else
2476 {
2477 if (kern_run == KERN_RUN_2)
2478 {
2479 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2480 {
2481 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2482 }
2483 }
2484
2485 while (num_elements % kernel_threads) num_elements++;
2486
2487 const size_t global_work_size[3] = { num_elements, 1, 1 };
2488 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2489
2490 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2491 }
2492
2493 hc_clFlush (data.ocl, device_param->command_queue);
2494
2495 hc_clWaitForEvents (data.ocl, 1, &event);
2496
2497 if (event_update)
2498 {
2499 cl_ulong time_start;
2500 cl_ulong time_end;
2501
2502 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2503 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2504
2505 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2506
2507 uint exec_pos = device_param->exec_pos;
2508
2509 device_param->exec_ms[exec_pos] = exec_time;
2510
2511 exec_pos++;
2512
2513 if (exec_pos == EXEC_CACHE)
2514 {
2515 exec_pos = 0;
2516 }
2517
2518 device_param->exec_pos = exec_pos;
2519 }
2520
2521 hc_clReleaseEvent (data.ocl, event);
2522
2523 hc_clFinish (data.ocl, device_param->command_queue);
2524 }
2525
2526 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2527 {
2528 uint num_elements = num;
2529
2530 switch (kern_run)
2531 {
2532 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2533 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2534 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2535 }
2536
2537 // causes problems with special threads like in bcrypt
2538 // const uint kernel_threads = device_param->kernel_threads;
2539
2540 uint kernel_threads = device_param->kernel_threads;
2541
2542 while (num_elements % kernel_threads) num_elements++;
2543
2544 cl_kernel kernel = NULL;
2545
2546 switch (kern_run)
2547 {
2548 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2549 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2550 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2551 }
2552
2553 switch (kern_run)
2554 {
2555 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2556 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2557 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2558 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2559 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2560 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2561 break;
2562 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2563 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2564 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2565 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2566 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2567 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2568 break;
2569 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2570 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2571 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2572 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2573 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2574 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2575 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2576 break;
2577 }
2578
2579 const size_t global_work_size[3] = { num_elements, 1, 1 };
2580 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2581
2582 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2583
2584 hc_clFlush (data.ocl, device_param->command_queue);
2585
2586 hc_clFinish (data.ocl, device_param->command_queue);
2587 }
2588
2589 static void run_kernel_tm (hc_device_param_t *device_param)
2590 {
2591 const uint num_elements = 1024; // fixed
2592
2593 uint kernel_threads = 32;
2594
2595 cl_kernel kernel = device_param->kernel_tm;
2596
2597 const size_t global_work_size[3] = { num_elements, 1, 1 };
2598 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2599
2600 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2601
2602 hc_clFlush (data.ocl, device_param->command_queue);
2603
2604 hc_clFinish (data.ocl, device_param->command_queue);
2605 }
2606
2607 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2608 {
2609 uint num_elements = num;
2610
2611 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2612 device_param->kernel_params_amp_buf32[6] = num_elements;
2613
2614 // causes problems with special threads like in bcrypt
2615 // const uint kernel_threads = device_param->kernel_threads;
2616
2617 uint kernel_threads = device_param->kernel_threads;
2618
2619 while (num_elements % kernel_threads) num_elements++;
2620
2621 cl_kernel kernel = device_param->kernel_amp;
2622
2623 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2624 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2625
2626 const size_t global_work_size[3] = { num_elements, 1, 1 };
2627 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2628
2629 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2630
2631 hc_clFlush (data.ocl, device_param->command_queue);
2632
2633 hc_clFinish (data.ocl, device_param->command_queue);
2634 }
2635
2636 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2637 {
2638 int rc = -1;
2639
2640 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2641 {
2642 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2643
2644 const cl_uchar zero = 0;
2645
2646 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2647 }
2648
2649 if (rc != 0)
2650 {
2651 // NOTE: clEnqueueFillBuffer () always fails with -59
2652 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2653 // How's that possible, OpenCL 1.2 support is advertised??
2654 // We need to workaround...
2655
2656 #define FILLSZ 0x100000
2657
2658 char *tmp = (char *) mymalloc (FILLSZ);
2659
2660 for (size_t i = 0; i < size; i += FILLSZ)
2661 {
2662 const size_t left = size - i;
2663
2664 const size_t fillsz = MIN (FILLSZ, left);
2665
2666 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2667 }
2668
2669 myfree (tmp);
2670 }
2671 }
2672
2673 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)
2674 {
2675 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2676 {
2677 if (attack_mode == ATTACK_MODE_BF)
2678 {
2679 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2680 {
2681 const uint size_tm = 32 * sizeof (bs_word_t);
2682
2683 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2684
2685 run_kernel_tm (device_param);
2686
2687 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);
2688 }
2689 }
2690
2691 if (highest_pw_len < 16)
2692 {
2693 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2694 }
2695 else if (highest_pw_len < 32)
2696 {
2697 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2698 }
2699 else
2700 {
2701 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2702 }
2703 }
2704 else
2705 {
2706 run_kernel_amp (device_param, pws_cnt);
2707
2708 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2709
2710 if (opts_type & OPTS_TYPE_HOOK12)
2711 {
2712 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2713 }
2714
2715 uint iter = salt_buf->salt_iter;
2716
2717 uint loop_step = device_param->kernel_loops;
2718
2719 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2720 {
2721 uint loop_left = iter - loop_pos;
2722
2723 loop_left = MIN (loop_left, loop_step);
2724
2725 device_param->kernel_params_buf32[25] = loop_pos;
2726 device_param->kernel_params_buf32[26] = loop_left;
2727
2728 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2729
2730 if (data.devices_status == STATUS_CRACKED) break;
2731 if (data.devices_status == STATUS_ABORTED) break;
2732 if (data.devices_status == STATUS_QUIT) break;
2733
2734 /**
2735 * speed
2736 */
2737
2738 const float iter_part = (float) (loop_pos + loop_left) / iter;
2739
2740 const u64 perf_sum_all = pws_cnt * iter_part;
2741
2742 double speed_ms;
2743
2744 hc_timer_get (device_param->timer_speed, speed_ms);
2745
2746 const u32 speed_pos = device_param->speed_pos;
2747
2748 device_param->speed_cnt[speed_pos] = perf_sum_all;
2749
2750 device_param->speed_ms[speed_pos] = speed_ms;
2751
2752 if (data.benchmark == 1)
2753 {
2754 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2755 }
2756 }
2757
2758 if (opts_type & OPTS_TYPE_HOOK23)
2759 {
2760 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2761
2762 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);
2763
2764 // do something with data
2765
2766 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);
2767 }
2768
2769 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2770 }
2771 }
2772
2773 static int run_rule_engine (const int rule_len, const char *rule_buf)
2774 {
2775 if (rule_len == 0)
2776 {
2777 return 0;
2778 }
2779 else if (rule_len == 1)
2780 {
2781 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2782 }
2783
2784 return 1;
2785 }
2786
2787 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2788 {
2789 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2790 {
2791 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);
2792 }
2793 else if (data.attack_kern == ATTACK_KERN_COMBI)
2794 {
2795 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2796 {
2797 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2798 {
2799 for (u32 i = 0; i < pws_cnt; i++)
2800 {
2801 const u32 pw_len = device_param->pws_buf[i].pw_len;
2802
2803 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2804
2805 ptr[pw_len] = 0x01;
2806 }
2807 }
2808 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2809 {
2810 for (u32 i = 0; i < pws_cnt; i++)
2811 {
2812 const u32 pw_len = device_param->pws_buf[i].pw_len;
2813
2814 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2815
2816 ptr[pw_len] = 0x80;
2817 }
2818 }
2819 }
2820
2821 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);
2822 }
2823 else if (data.attack_kern == ATTACK_KERN_BF)
2824 {
2825 const u64 off = device_param->words_off;
2826
2827 device_param->kernel_params_mp_l_buf64[3] = off;
2828
2829 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2830 }
2831 }
2832
2833 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2834 {
2835 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2836
2837 device_param->kernel_params_buf32[25] = 0;
2838 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2839 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2840
2841 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2842 {
2843 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2844 }
2845 else
2846 {
2847 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2848 }
2849
2850 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2851
2852 return exec_ms_prev;
2853 }
2854
2855 static void autotune (hc_device_param_t *device_param)
2856 {
2857 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2858
2859 const u32 kernel_accel_min = device_param->kernel_accel_min;
2860 const u32 kernel_accel_max = device_param->kernel_accel_max;
2861
2862 const u32 kernel_loops_min = device_param->kernel_loops_min;
2863 const u32 kernel_loops_max = device_param->kernel_loops_max;
2864
2865 u32 kernel_accel = kernel_accel_min;
2866 u32 kernel_loops = kernel_loops_min;
2867
2868 // init some fake words
2869
2870 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2871
2872 for (u32 i = 0; i < kernel_power_max; i++)
2873 {
2874 device_param->pws_buf[i].i[0] = i;
2875 device_param->pws_buf[i].i[1] = 0x01234567;
2876 device_param->pws_buf[i].pw_len = 7;
2877 }
2878
2879 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2880
2881 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2882 {
2883 run_kernel_amp (device_param, kernel_power_max);
2884 }
2885
2886 // begin actual testing
2887
2888 double exec_ms_final = try_run (device_param, kernel_accel, kernel_loops);
2889
2890 if ((kernel_loops_min == kernel_loops_max) || (kernel_accel_min == kernel_accel_max))
2891 {
2892 // we do this in case the user specified a fixed -u and -n on the commandline
2893 // so we have a cached kernel for benchmark
2894
2895 try_run (device_param, kernel_accel, kernel_loops);
2896 try_run (device_param, kernel_accel, kernel_loops);
2897 try_run (device_param, kernel_accel, kernel_loops);
2898 try_run (device_param, kernel_accel, kernel_loops);
2899 try_run (device_param, kernel_accel, kernel_loops);
2900 }
2901
2902 // first find out highest kernel-loops that stays below target_ms
2903
2904 #define STEPS_CNT 10
2905
2906 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
2907 {
2908 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
2909
2910 if (exec_ms < target_ms) break;
2911 }
2912
2913 // now the same for kernel-accel but with the new kernel-loops from previous loop set
2914
2915 if (kernel_accel_min < kernel_accel_max)
2916 {
2917 for (int i = 0; i < STEPS_CNT; i++)
2918 {
2919 const u32 kernel_accel_try = 1 << i;
2920
2921 if (kernel_accel_try < kernel_accel_min) continue;
2922 if (kernel_accel_try > kernel_accel_max) break;
2923
2924 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
2925
2926 if (exec_ms > target_ms) break;
2927
2928 exec_ms_final = exec_ms;
2929
2930 kernel_accel = kernel_accel_try;
2931 }
2932 }
2933
2934 // there's a chance that we have a fixed kernel_loops but not a fixed kernel_accel
2935 // in such a case the above function would not create any change
2936 // we'll use the runtime to find out if we're allow to do last improvement
2937
2938 if (exec_ms_final > 0)
2939 {
2940 if ((exec_ms_final * 2) <= target_ms)
2941 {
2942 const double exec_left = target_ms / exec_ms_final;
2943
2944 const double accel_left = kernel_accel_max / kernel_accel;
2945
2946 const int exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
2947
2948 if (exec_accel_min >= 2)
2949 {
2950 kernel_accel *= exec_accel_min;
2951 }
2952 }
2953 }
2954
2955 // balancing the workload turns out to be very efficient
2956
2957 if (kernel_loops_min != kernel_loops_max)
2958 {
2959 const u32 kernel_power_balance = kernel_accel * kernel_loops;
2960
2961 u32 sqrtv;
2962
2963 for (sqrtv = 1; sqrtv < 0x100000; sqrtv++)
2964 {
2965 if ((sqrtv * sqrtv) >= kernel_power_balance) break;
2966 }
2967
2968 const u32 kernel_accel_try = sqrtv;
2969 const u32 kernel_loops_try = sqrtv;
2970
2971 if ((kernel_accel_try <= kernel_accel_max) && (kernel_loops_try >= kernel_loops_min))
2972 {
2973 kernel_accel = kernel_accel_try;
2974 kernel_loops = kernel_loops_try;
2975 }
2976 }
2977
2978 // reset fake words
2979
2980 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
2981
2982 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2983 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_amp_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2984
2985 // reset timer
2986
2987 device_param->exec_pos = 0;
2988
2989 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
2990
2991 // store
2992
2993 device_param->kernel_accel = kernel_accel;
2994 device_param->kernel_loops = kernel_loops;
2995
2996 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2997
2998 device_param->kernel_power = kernel_power;
2999
3000 #ifdef DEBUG
3001
3002 if (data.quiet == 0)
3003 {
3004 clear_prompt ();
3005
3006 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3007 "Device #%u: autotuned kernel-loops to %u\n",
3008 device_param->device_id + 1, kernel_accel,
3009 device_param->device_id + 1, kernel_loops);
3010
3011 fprintf (stdout, "%s", PROMPT);
3012
3013 fflush (stdout);
3014 }
3015
3016 #endif
3017 }
3018
3019 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3020 {
3021 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3022
3023 // init speed timer
3024
3025 uint speed_pos = device_param->speed_pos;
3026
3027 #ifdef _POSIX
3028 if (device_param->timer_speed.tv_sec == 0)
3029 {
3030 hc_timer_set (&device_param->timer_speed);
3031 }
3032 #endif
3033
3034 #ifdef _WIN
3035 if (device_param->timer_speed.QuadPart == 0)
3036 {
3037 hc_timer_set (&device_param->timer_speed);
3038 }
3039 #endif
3040
3041 // find higest password length, this is for optimization stuff
3042
3043 uint highest_pw_len = 0;
3044
3045 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3046 {
3047 }
3048 else if (data.attack_kern == ATTACK_KERN_COMBI)
3049 {
3050 }
3051 else if (data.attack_kern == ATTACK_KERN_BF)
3052 {
3053 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3054 + device_param->kernel_params_mp_l_buf32[5];
3055 }
3056
3057 // iteration type
3058
3059 uint innerloop_step = 0;
3060 uint innerloop_cnt = 0;
3061
3062 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3063 else innerloop_step = 1;
3064
3065 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3066 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3067 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3068
3069 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3070
3071 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3072 {
3073 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3074
3075 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3076
3077 if (data.devices_status == STATUS_CRACKED) break;
3078 if (data.devices_status == STATUS_ABORTED) break;
3079 if (data.devices_status == STATUS_QUIT) break;
3080 if (data.devices_status == STATUS_BYPASS) break;
3081
3082 salt_t *salt_buf = &data.salts_buf[salt_pos];
3083
3084 device_param->kernel_params_buf32[24] = salt_pos;
3085 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3086 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3087
3088 FILE *combs_fp = device_param->combs_fp;
3089
3090 if (data.attack_mode == ATTACK_MODE_COMBI)
3091 {
3092 rewind (combs_fp);
3093 }
3094
3095 // innerloops
3096
3097 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3098 {
3099 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3100
3101 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3102
3103 if (data.devices_status == STATUS_CRACKED) break;
3104 if (data.devices_status == STATUS_ABORTED) break;
3105 if (data.devices_status == STATUS_QUIT) break;
3106 if (data.devices_status == STATUS_BYPASS) break;
3107
3108 uint innerloop_left = innerloop_cnt - innerloop_pos;
3109
3110 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3111
3112 device_param->innerloop_pos = innerloop_pos;
3113 device_param->innerloop_left = innerloop_left;
3114
3115 device_param->kernel_params_buf32[27] = innerloop_left;
3116
3117 // i think we can get rid of this
3118 if (innerloop_left == 0)
3119 {
3120 puts ("bug, how should this happen????\n");
3121
3122 continue;
3123 }
3124
3125 if (data.salts_shown[salt_pos] == 1)
3126 {
3127 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3128
3129 continue;
3130 }
3131
3132 // initialize amplifiers
3133
3134 if (data.attack_mode == ATTACK_MODE_COMBI)
3135 {
3136 uint i = 0;
3137
3138 while (i < innerloop_left)
3139 {
3140 if (feof (combs_fp)) break;
3141
3142 int line_len = fgetl (combs_fp, line_buf);
3143
3144 if (line_len >= PW_MAX1) continue;
3145
3146 line_len = convert_from_hex (line_buf, line_len);
3147
3148 char *line_buf_new = line_buf;
3149
3150 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3151 {
3152 char rule_buf_out[BLOCK_SIZE] = { 0 };
3153
3154 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3155
3156 if (rule_len_out < 0)
3157 {
3158 data.words_progress_rejected[salt_pos] += pws_cnt;
3159
3160 continue;
3161 }
3162
3163 line_len = rule_len_out;
3164
3165 line_buf_new = rule_buf_out;
3166 }
3167
3168 line_len = MIN (line_len, PW_DICTMAX);
3169
3170 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3171
3172 memcpy (ptr, line_buf_new, line_len);
3173
3174 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3175
3176 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3177 {
3178 uppercase (ptr, line_len);
3179 }
3180
3181 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3182 {
3183 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3184 {
3185 ptr[line_len] = 0x80;
3186 }
3187
3188 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3189 {
3190 ptr[line_len] = 0x01;
3191 }
3192 }
3193
3194 device_param->combs_buf[i].pw_len = line_len;
3195
3196 i++;
3197 }
3198
3199 for (uint j = i; j < innerloop_left; j++)
3200 {
3201 device_param->combs_buf[j].i[0] = 0;
3202 device_param->combs_buf[j].i[1] = 0;
3203 device_param->combs_buf[j].i[2] = 0;
3204 device_param->combs_buf[j].i[3] = 0;
3205 device_param->combs_buf[j].i[4] = 0;
3206 device_param->combs_buf[j].i[5] = 0;
3207 device_param->combs_buf[j].i[6] = 0;
3208 device_param->combs_buf[j].i[7] = 0;
3209
3210 device_param->combs_buf[j].pw_len = 0;
3211 }
3212
3213 innerloop_left = i;
3214 }
3215 else if (data.attack_mode == ATTACK_MODE_BF)
3216 {
3217 u64 off = innerloop_pos;
3218
3219 device_param->kernel_params_mp_r_buf64[3] = off;
3220
3221 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3222 }
3223 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3224 {
3225 u64 off = innerloop_pos;
3226
3227 device_param->kernel_params_mp_buf64[3] = off;
3228
3229 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3230 }
3231 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3232 {
3233 u64 off = innerloop_pos;
3234
3235 device_param->kernel_params_mp_buf64[3] = off;
3236
3237 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3238 }
3239
3240 // copy amplifiers
3241
3242 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3243 {
3244 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);
3245 }
3246 else if (data.attack_mode == ATTACK_MODE_COMBI)
3247 {
3248 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);
3249 }
3250 else if (data.attack_mode == ATTACK_MODE_BF)
3251 {
3252 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);
3253 }
3254 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3255 {
3256 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);
3257 }
3258 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3259 {
3260 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);
3261 }
3262
3263 if (data.benchmark == 1)
3264 {
3265 hc_timer_set (&device_param->timer_speed);
3266 }
3267
3268 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3269
3270 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3271
3272 if (data.devices_status == STATUS_CRACKED) break;
3273 if (data.devices_status == STATUS_ABORTED) break;
3274 if (data.devices_status == STATUS_QUIT) break;
3275
3276 /**
3277 * result
3278 */
3279
3280 hc_thread_mutex_lock (mux_display);
3281
3282 check_cracked (device_param, salt_pos);
3283
3284 hc_thread_mutex_unlock (mux_display);
3285
3286 /**
3287 * progress
3288 */
3289
3290 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3291
3292 hc_thread_mutex_lock (mux_counter);
3293
3294 data.words_progress_done[salt_pos] += perf_sum_all;
3295
3296 hc_thread_mutex_unlock (mux_counter);
3297
3298 /**
3299 * speed
3300 */
3301
3302 double speed_ms;
3303
3304 hc_timer_get (device_param->timer_speed, speed_ms);
3305
3306 hc_timer_set (&device_param->timer_speed);
3307
3308 hc_thread_mutex_lock (mux_display);
3309
3310 // current speed
3311
3312 device_param->speed_cnt[speed_pos] = perf_sum_all;
3313
3314 device_param->speed_ms[speed_pos] = speed_ms;
3315
3316 hc_thread_mutex_unlock (mux_display);
3317
3318 speed_pos++;
3319
3320 if (speed_pos == SPEED_CACHE)
3321 {
3322 speed_pos = 0;
3323 }
3324
3325 /**
3326 * benchmark
3327 */
3328
3329 if (data.benchmark == 1) break;
3330 }
3331 }
3332
3333 device_param->speed_pos = speed_pos;
3334
3335 myfree (line_buf);
3336 }
3337
3338 static void load_segment (wl_data_t *wl_data, FILE *fd)
3339 {
3340 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3341
3342 wl_data->pos = 0;
3343
3344 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3345
3346 wl_data->buf[wl_data->cnt] = 0;
3347
3348 if (wl_data->cnt == 0) return;
3349
3350 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3351
3352 while (!feof (fd))
3353 {
3354 if (wl_data->cnt == wl_data->avail)
3355 {
3356 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3357
3358 wl_data->avail += wl_data->incr;
3359 }
3360
3361 const int c = fgetc (fd);
3362
3363 if (c == EOF) break;
3364
3365 wl_data->buf[wl_data->cnt] = (char) c;
3366
3367 wl_data->cnt++;
3368
3369 if (c == '\n') break;
3370 }
3371
3372 // ensure stream ends with a newline
3373
3374 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3375 {
3376 wl_data->cnt++;
3377
3378 wl_data->buf[wl_data->cnt - 1] = '\n';
3379 }
3380
3381 return;
3382 }
3383
3384 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3385 {
3386 char *ptr = buf;
3387
3388 for (u32 i = 0; i < sz; i++, ptr++)
3389 {
3390 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3391
3392 if (i == 7)
3393 {
3394 *off = i;
3395 *len = i;
3396
3397 return;
3398 }
3399
3400 if (*ptr != '\n') continue;
3401
3402 *off = i + 1;
3403
3404 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3405
3406 *len = i;
3407
3408 return;
3409 }
3410
3411 *off = sz;
3412 *len = sz;
3413 }
3414
3415 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3416 {
3417 char *ptr = buf;
3418
3419 for (u32 i = 0; i < sz; i++, ptr++)
3420 {
3421 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3422
3423 if (*ptr != '\n') continue;
3424
3425 *off = i + 1;
3426
3427 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3428
3429 *len = i;
3430
3431 return;
3432 }
3433
3434 *off = sz;
3435 *len = sz;
3436 }
3437
3438 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3439 {
3440 char *ptr = buf;
3441
3442 for (u32 i = 0; i < sz; i++, ptr++)
3443 {
3444 if (*ptr != '\n') continue;
3445
3446 *off = i + 1;
3447
3448 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3449
3450 *len = i;
3451
3452 return;
3453 }
3454
3455 *off = sz;
3456 *len = sz;
3457 }
3458
3459 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3460 {
3461 while (wl_data->pos < wl_data->cnt)
3462 {
3463 uint off;
3464 uint len;
3465
3466 char *ptr = wl_data->buf + wl_data->pos;
3467
3468 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3469
3470 wl_data->pos += off;
3471
3472 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3473 {
3474 char rule_buf_out[BLOCK_SIZE] = { 0 };
3475
3476 int rule_len_out = -1;
3477
3478 if (len < BLOCK_SIZE)
3479 {
3480 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3481 }
3482
3483 if (rule_len_out < 0)
3484 {
3485 continue;
3486 }
3487
3488 if (rule_len_out > PW_MAX)
3489 {
3490 continue;
3491 }
3492 }
3493 else
3494 {
3495 if (len > PW_MAX)
3496 {
3497 continue;
3498 }
3499 }
3500
3501 *out_buf = ptr;
3502 *out_len = len;
3503
3504 return;
3505 }
3506
3507 if (feof (fd))
3508 {
3509 fprintf (stderr, "BUG feof()!!\n");
3510
3511 return;
3512 }
3513
3514 load_segment (wl_data, fd);
3515
3516 get_next_word (wl_data, fd, out_buf, out_len);
3517 }
3518
3519 #ifdef _POSIX
3520 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3521 #endif
3522
3523 #ifdef _WIN
3524 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3525 #endif
3526 {
3527 hc_signal (NULL);
3528
3529 dictstat_t d;
3530
3531 d.cnt = 0;
3532
3533 #ifdef _POSIX
3534 fstat (fileno (fd), &d.stat);
3535 #endif
3536
3537 #ifdef _WIN
3538 _fstat64 (fileno (fd), &d.stat);
3539 #endif
3540
3541 d.stat.st_mode = 0;
3542 d.stat.st_nlink = 0;
3543 d.stat.st_uid = 0;
3544 d.stat.st_gid = 0;
3545 d.stat.st_rdev = 0;
3546 d.stat.st_atime = 0;
3547
3548 #ifdef _POSIX
3549 d.stat.st_blksize = 0;
3550 d.stat.st_blocks = 0;
3551 #endif
3552
3553 if (d.stat.st_size == 0) return 0;
3554
3555 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3556
3557 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3558 {
3559 if (d_cache)
3560 {
3561 u64 cnt = d_cache->cnt;
3562
3563 u64 keyspace = cnt;
3564
3565 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3566 {
3567 keyspace *= data.kernel_rules_cnt;
3568 }
3569 else if (data.attack_kern == ATTACK_KERN_COMBI)
3570 {
3571 keyspace *= data.combs_cnt;
3572 }
3573
3574 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);
3575 if (data.quiet == 0) log_info ("");
3576
3577 hc_signal (sigHandler_default);
3578
3579 return (keyspace);
3580 }
3581 }
3582
3583 time_t now = 0;
3584 time_t prev = 0;
3585
3586 u64 comp = 0;
3587 u64 cnt = 0;
3588 u64 cnt2 = 0;
3589
3590 while (!feof (fd))
3591 {
3592 load_segment (wl_data, fd);
3593
3594 comp += wl_data->cnt;
3595
3596 u32 i = 0;
3597
3598 while (i < wl_data->cnt)
3599 {
3600 u32 len;
3601 u32 off;
3602
3603 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3604
3605 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3606 {
3607 char rule_buf_out[BLOCK_SIZE] = { 0 };
3608
3609 int rule_len_out = -1;
3610
3611 if (len < BLOCK_SIZE)
3612 {
3613 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3614 }
3615
3616 if (rule_len_out < 0)
3617 {
3618 len = PW_MAX1;
3619 }
3620 else
3621 {
3622 len = rule_len_out;
3623 }
3624 }
3625
3626 if (len < PW_MAX1)
3627 {
3628 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3629 {
3630 cnt += data.kernel_rules_cnt;
3631 }
3632 else if (data.attack_kern == ATTACK_KERN_COMBI)
3633 {
3634 cnt += data.combs_cnt;
3635 }
3636
3637 d.cnt++;
3638 }
3639
3640 i += off;
3641
3642 cnt2++;
3643 }
3644
3645 time (&now);
3646
3647 if ((now - prev) == 0) continue;
3648
3649 float percent = (float) comp / (float) d.stat.st_size;
3650
3651 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);
3652
3653 time (&prev);
3654 }
3655
3656 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);
3657 if (data.quiet == 0) log_info ("");
3658
3659 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3660
3661 hc_signal (sigHandler_default);
3662
3663 return (cnt);
3664 }
3665
3666 static void *thread_monitor (void *p)
3667 {
3668 uint runtime_check = 0;
3669 uint remove_check = 0;
3670 uint status_check = 0;
3671 uint restore_check = 0;
3672
3673 uint restore_left = data.restore_timer;
3674 uint remove_left = data.remove_timer;
3675 uint status_left = data.status_timer;
3676
3677 #ifdef HAVE_HWMON
3678 uint hwmon_check = 0;
3679
3680 // these variables are mainly used for fan control (AMD only)
3681
3682 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3683
3684 // temperature controller "loopback" values
3685
3686 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3687 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3688
3689 #ifdef HAVE_ADL
3690 int temp_threshold = 1; // degrees celcius
3691
3692 int fan_speed_min = 15; // in percentage
3693 int fan_speed_max = 100;
3694 #endif // HAVE_ADL
3695
3696 time_t last_temp_check_time;
3697 #endif // HAVE_HWMON
3698
3699 uint sleep_time = 1;
3700
3701 if (data.runtime)
3702 {
3703 runtime_check = 1;
3704 }
3705
3706 if (data.restore_timer)
3707 {
3708 restore_check = 1;
3709 }
3710
3711 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3712 {
3713 remove_check = 1;
3714 }
3715
3716 if (data.status == 1)
3717 {
3718 status_check = 1;
3719 }
3720
3721 #ifdef HAVE_HWMON
3722 if (data.gpu_temp_disable == 0)
3723 {
3724 time (&last_temp_check_time);
3725
3726 hwmon_check = 1;
3727 }
3728 #endif
3729
3730 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3731 {
3732 #ifdef HAVE_HWMON
3733 if (hwmon_check == 0)
3734 #endif
3735 return (p);
3736 }
3737
3738 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3739 {
3740 hc_sleep (sleep_time);
3741
3742 if (data.devices_status != STATUS_RUNNING) continue;
3743
3744 #ifdef HAVE_HWMON
3745 if (hwmon_check == 1)
3746 {
3747 hc_thread_mutex_lock (mux_adl);
3748
3749 time_t temp_check_time;
3750
3751 time (&temp_check_time);
3752
3753 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3754
3755 if (Ta == 0) Ta = 1;
3756
3757 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3758 {
3759 hc_device_param_t *device_param = &data.devices_param[device_id];
3760
3761 if (device_param->skipped) continue;
3762
3763 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3764
3765 const int temperature = hm_get_temperature_with_device_id (device_id);
3766
3767 if (temperature > (int) data.gpu_temp_abort)
3768 {
3769 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3770
3771 if (data.devices_status != STATUS_QUIT) myabort ();
3772
3773 break;
3774 }
3775
3776 #ifdef HAVE_ADL
3777 const int gpu_temp_retain = data.gpu_temp_retain;
3778
3779 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3780 {
3781 if (data.hm_device[device_id].fan_supported == 1)
3782 {
3783 int temp_cur = temperature;
3784
3785 int temp_diff_new = gpu_temp_retain - temp_cur;
3786
3787 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3788
3789 // calculate Ta value (time difference in seconds between the last check and this check)
3790
3791 last_temp_check_time = temp_check_time;
3792
3793 float Kp = 1.8;
3794 float Ki = 0.005;
3795 float Kd = 6;
3796
3797 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3798
3799 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);
3800
3801 if (abs (fan_diff_required) >= temp_threshold)
3802 {
3803 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3804
3805 int fan_speed_level = fan_speed_cur;
3806
3807 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3808
3809 int fan_speed_new = fan_speed_level - fan_diff_required;
3810
3811 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3812 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3813
3814 if (fan_speed_new != fan_speed_cur)
3815 {
3816 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3817 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3818
3819 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3820 {
3821 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3822
3823 fan_speed_chgd[device_id] = 1;
3824 }
3825
3826 temp_diff_old[device_id] = temp_diff_new;
3827 }
3828 }
3829 }
3830 }
3831 #endif // HAVE_ADL
3832 }
3833
3834 hc_thread_mutex_unlock (mux_adl);
3835 }
3836 #endif // HAVE_HWMON
3837
3838 if (restore_check == 1)
3839 {
3840 restore_left--;
3841
3842 if (restore_left == 0)
3843 {
3844 if (data.restore_disable == 0) cycle_restore ();
3845
3846 restore_left = data.restore_timer;
3847 }
3848 }
3849
3850 if ((runtime_check == 1) && (data.runtime_start > 0))
3851 {
3852 time_t runtime_cur;
3853
3854 time (&runtime_cur);
3855
3856 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3857
3858 if (runtime_left <= 0)
3859 {
3860 if (data.benchmark == 0)
3861 {
3862 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3863 }
3864
3865 if (data.devices_status != STATUS_QUIT) myabort ();
3866 }
3867 }
3868
3869 if (remove_check == 1)
3870 {
3871 remove_left--;
3872
3873 if (remove_left == 0)
3874 {
3875 if (data.digests_saved != data.digests_done)
3876 {
3877 data.digests_saved = data.digests_done;
3878
3879 save_hash ();
3880 }
3881
3882 remove_left = data.remove_timer;
3883 }
3884 }
3885
3886 if (status_check == 1)
3887 {
3888 status_left--;
3889
3890 if (status_left == 0)
3891 {
3892 hc_thread_mutex_lock (mux_display);
3893
3894 if (data.quiet == 0) clear_prompt ();
3895
3896 if (data.quiet == 0) log_info ("");
3897
3898 status_display ();
3899
3900 if (data.quiet == 0) log_info ("");
3901
3902 hc_thread_mutex_unlock (mux_display);
3903
3904 status_left = data.status_timer;
3905 }
3906 }
3907 }
3908
3909 #ifdef HAVE_HWMON
3910 myfree (fan_speed_chgd);
3911
3912 myfree (temp_diff_old);
3913 myfree (temp_diff_sum);
3914 #endif
3915
3916 p = NULL;
3917
3918 return (p);
3919 }
3920
3921 static void *thread_outfile_remove (void *p)
3922 {
3923 // some hash-dependent constants
3924 char *outfile_dir = data.outfile_check_directory;
3925 uint dgst_size = data.dgst_size;
3926 uint isSalted = data.isSalted;
3927 uint esalt_size = data.esalt_size;
3928 uint hash_mode = data.hash_mode;
3929
3930 uint outfile_check_timer = data.outfile_check_timer;
3931
3932 char separator = data.separator;
3933
3934 // some hash-dependent functions
3935 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3936 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3937
3938 // buffers
3939 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3940
3941 hash_buf.digest = mymalloc (dgst_size);
3942
3943 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3944
3945 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3946
3947 uint digest_buf[64] = { 0 };
3948
3949 outfile_data_t *out_info = NULL;
3950
3951 char **out_files = NULL;
3952
3953 time_t folder_mtime = 0;
3954
3955 int out_cnt = 0;
3956
3957 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3958
3959 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3960 {
3961 hc_sleep (1);
3962
3963 if (data.devices_status != STATUS_RUNNING) continue;
3964
3965 check_left--;
3966
3967 if (check_left == 0)
3968 {
3969 struct stat outfile_check_stat;
3970
3971 if (stat (outfile_dir, &outfile_check_stat) == 0)
3972 {
3973 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3974
3975 if (is_dir == 1)
3976 {
3977 if (outfile_check_stat.st_mtime > folder_mtime)
3978 {
3979 char **out_files_new = scan_directory (outfile_dir);
3980
3981 int out_cnt_new = count_dictionaries (out_files_new);
3982
3983 outfile_data_t *out_info_new = NULL;
3984
3985 if (out_cnt_new > 0)
3986 {
3987 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3988
3989 for (int i = 0; i < out_cnt_new; i++)
3990 {
3991 out_info_new[i].file_name = out_files_new[i];
3992
3993 // check if there are files that we have seen/checked before (and not changed)
3994
3995 for (int j = 0; j < out_cnt; j++)
3996 {
3997 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3998 {
3999 struct stat outfile_stat;
4000
4001 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4002 {
4003 if (outfile_stat.st_ctime == out_info[j].ctime)
4004 {
4005 out_info_new[i].ctime = out_info[j].ctime;
4006 out_info_new[i].seek = out_info[j].seek;
4007 }
4008 }
4009 }
4010 }
4011 }
4012 }
4013
4014 local_free (out_info);
4015 local_free (out_files);
4016
4017 out_files = out_files_new;
4018 out_cnt = out_cnt_new;
4019 out_info = out_info_new;
4020
4021 folder_mtime = outfile_check_stat.st_mtime;
4022 }
4023
4024 for (int j = 0; j < out_cnt; j++)
4025 {
4026 FILE *fp = fopen (out_info[j].file_name, "rb");
4027
4028 if (fp != NULL)
4029 {
4030 //hc_thread_mutex_lock (mux_display);
4031
4032 #ifdef _POSIX
4033 struct stat outfile_stat;
4034
4035 fstat (fileno (fp), &outfile_stat);
4036 #endif
4037
4038 #ifdef _WIN
4039 struct stat64 outfile_stat;
4040
4041 _fstat64 (fileno (fp), &outfile_stat);
4042 #endif
4043
4044 if (outfile_stat.st_ctime > out_info[j].ctime)
4045 {
4046 out_info[j].ctime = outfile_stat.st_ctime;
4047 out_info[j].seek = 0;
4048 }
4049
4050 fseek (fp, out_info[j].seek, SEEK_SET);
4051
4052 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4053
4054 while (!feof (fp))
4055 {
4056 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4057
4058 if (ptr == NULL) break;
4059
4060 int line_len = strlen (line_buf);
4061
4062 if (line_len <= 0) continue;
4063
4064 int iter = MAX_CUT_TRIES;
4065
4066 for (uint i = line_len - 1; i && iter; i--, line_len--)
4067 {
4068 if (line_buf[i] != separator) continue;
4069
4070 int parser_status = PARSER_OK;
4071
4072 if ((hash_mode != 2500) && (hash_mode != 6800))
4073 {
4074 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4075 }
4076
4077 uint found = 0;
4078
4079 if (parser_status == PARSER_OK)
4080 {
4081 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4082 {
4083 if (data.salts_shown[salt_pos] == 1) continue;
4084
4085 salt_t *salt_buf = &data.salts_buf[salt_pos];
4086
4087 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4088 {
4089 uint idx = salt_buf->digests_offset + digest_pos;
4090
4091 if (data.digests_shown[idx] == 1) continue;
4092
4093 uint cracked = 0;
4094
4095 if (hash_mode == 6800)
4096 {
4097 if (i == salt_buf->salt_len)
4098 {
4099 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4100 }
4101 }
4102 else if (hash_mode == 2500)
4103 {
4104 // BSSID : MAC1 : MAC2 (:plain)
4105 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4106 {
4107 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4108
4109 if (!cracked) continue;
4110
4111 // now compare MAC1 and MAC2 too, since we have this additional info
4112 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4113 char *mac2_pos = mac1_pos + 12 + 1;
4114
4115 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4116 wpa_t *wpa = &wpas[salt_pos];
4117
4118 // compare hex string(s) vs binary MAC address(es)
4119
4120 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4121 {
4122 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4123 {
4124 cracked = 0;
4125
4126 break;
4127 }
4128 }
4129
4130 // early skip ;)
4131 if (!cracked) continue;
4132
4133 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4134 {
4135 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4136 {
4137 cracked = 0;
4138
4139 break;
4140 }
4141 }
4142 }
4143 }
4144 else
4145 {
4146 char *digests_buf_ptr = (char *) data.digests_buf;
4147
4148 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4149
4150 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4151 }
4152
4153 if (cracked == 1)
4154 {
4155 found = 1;
4156
4157 data.digests_shown[idx] = 1;
4158
4159 data.digests_done++;
4160
4161 salt_buf->digests_done++;
4162
4163 if (salt_buf->digests_done == salt_buf->digests_cnt)
4164 {
4165 data.salts_shown[salt_pos] = 1;
4166
4167 data.salts_done++;
4168
4169 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4170 }
4171 }
4172 }
4173
4174 if (data.devices_status == STATUS_CRACKED) break;
4175 }
4176 }
4177
4178 if (found) break;
4179
4180 if (data.devices_status == STATUS_CRACKED) break;
4181
4182 iter--;
4183 }
4184
4185 if (data.devices_status == STATUS_CRACKED) break;
4186 }
4187
4188 myfree (line_buf);
4189
4190 out_info[j].seek = ftell (fp);
4191
4192 //hc_thread_mutex_unlock (mux_display);
4193
4194 fclose (fp);
4195 }
4196 }
4197 }
4198 }
4199
4200 check_left = outfile_check_timer;
4201 }
4202 }
4203
4204 if (esalt_size) local_free (hash_buf.esalt);
4205
4206 if (isSalted) local_free (hash_buf.salt);
4207
4208 local_free (hash_buf.digest);
4209
4210 local_free (out_info);
4211
4212 local_free (out_files);
4213
4214 p = NULL;
4215
4216 return (p);
4217 }
4218
4219 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4220 {
4221 if (device_param->pws_cnt < device_param->kernel_power)
4222 {
4223 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4224
4225 u8 *ptr = (u8 *) pw->i;
4226
4227 memcpy (ptr, pw_buf, pw_len);
4228
4229 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4230
4231 pw->pw_len = pw_len;
4232
4233 device_param->pws_cnt++;
4234 }
4235 else
4236 {
4237 fprintf (stderr, "BUG pw_add()!!\n");
4238
4239 return;
4240 }
4241 }
4242
4243 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4244 {
4245 hc_thread_mutex_lock (mux_dispatcher);
4246
4247 const u64 words_cur = data.words_cur;
4248 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4249
4250 device_param->words_off = words_cur;
4251
4252 const u64 words_left = words_base - words_cur;
4253
4254 if (allow_div)
4255 {
4256 if (data.kernel_power_all > words_left)
4257 {
4258 if (data.kernel_power_div == 0)
4259 {
4260 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4261 }
4262 }
4263
4264 if (data.kernel_power_div)
4265 {
4266 if (device_param->kernel_power == device_param->kernel_power_user)
4267 {
4268 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4269
4270 if (kernel_power_new < device_param->kernel_power)
4271 {
4272 device_param->kernel_power = kernel_power_new;
4273 }
4274 }
4275 }
4276 }
4277
4278 const uint kernel_power = device_param->kernel_power;
4279
4280 uint work = MIN (words_left, kernel_power);
4281
4282 work = MIN (work, max);
4283
4284 data.words_cur += work;
4285
4286 hc_thread_mutex_unlock (mux_dispatcher);
4287
4288 return work;
4289 }
4290
4291 static void *thread_calc_stdin (void *p)
4292 {
4293 hc_device_param_t *device_param = (hc_device_param_t *) p;
4294
4295 if (device_param->skipped) return NULL;
4296
4297 autotune (device_param);
4298
4299 char *buf = (char *) mymalloc (HCBUFSIZ);
4300
4301 const uint attack_kern = data.attack_kern;
4302
4303 const uint kernel_power = device_param->kernel_power;
4304
4305 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4306 {
4307 hc_thread_mutex_lock (mux_dispatcher);
4308
4309 if (feof (stdin) != 0)
4310 {
4311 hc_thread_mutex_unlock (mux_dispatcher);
4312
4313 break;
4314 }
4315
4316 uint words_cur = 0;
4317
4318 while (words_cur < kernel_power)
4319 {
4320 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4321
4322 if (line_buf == NULL) break;
4323
4324 uint line_len = in_superchop (line_buf);
4325
4326 line_len = convert_from_hex (line_buf, line_len);
4327
4328 // post-process rule engine
4329
4330 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4331 {
4332 char rule_buf_out[BLOCK_SIZE] = { 0 };
4333
4334 int rule_len_out = -1;
4335
4336 if (line_len < BLOCK_SIZE)
4337 {
4338 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4339 }
4340
4341 if (rule_len_out < 0) continue;
4342
4343 line_buf = rule_buf_out;
4344 line_len = rule_len_out;
4345 }
4346
4347 if (line_len > PW_MAX)
4348 {
4349 continue;
4350 }
4351
4352 if (attack_kern == ATTACK_KERN_STRAIGHT)
4353 {
4354 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4355 {
4356 hc_thread_mutex_lock (mux_counter);
4357
4358 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4359 {
4360 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4361 }
4362
4363 hc_thread_mutex_unlock (mux_counter);
4364
4365 continue;
4366 }
4367 }
4368 else if (attack_kern == ATTACK_KERN_COMBI)
4369 {
4370 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4371 // since we still need to combine the plains
4372
4373 if (line_len > data.pw_max)
4374 {
4375 hc_thread_mutex_lock (mux_counter);
4376
4377 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4378 {
4379 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4380 }
4381
4382 hc_thread_mutex_unlock (mux_counter);
4383
4384 continue;
4385 }
4386 }
4387
4388 pw_add (device_param, (u8 *) line_buf, line_len);
4389
4390 words_cur++;
4391
4392 if (data.devices_status == STATUS_CRACKED) break;
4393 if (data.devices_status == STATUS_ABORTED) break;
4394 if (data.devices_status == STATUS_QUIT) break;
4395 if (data.devices_status == STATUS_BYPASS) break;
4396 }
4397
4398 hc_thread_mutex_unlock (mux_dispatcher);
4399
4400 if (data.devices_status == STATUS_CRACKED) break;
4401 if (data.devices_status == STATUS_ABORTED) break;
4402 if (data.devices_status == STATUS_QUIT) break;
4403 if (data.devices_status == STATUS_BYPASS) break;
4404
4405 // flush
4406
4407 const uint pws_cnt = device_param->pws_cnt;
4408
4409 if (pws_cnt)
4410 {
4411 run_copy (device_param, pws_cnt);
4412
4413 run_cracker (device_param, pws_cnt);
4414
4415 device_param->pws_cnt = 0;
4416
4417 /*
4418 still required?
4419 if (attack_kern == ATTACK_KERN_STRAIGHT)
4420 {
4421 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4422 }
4423 else if (attack_kern == ATTACK_KERN_COMBI)
4424 {
4425 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4426 }
4427 */
4428 }
4429 }
4430
4431 device_param->kernel_accel = 0;
4432 device_param->kernel_loops = 0;
4433
4434 myfree (buf);
4435
4436 return NULL;
4437 }
4438
4439 static void *thread_calc (void *p)
4440 {
4441 hc_device_param_t *device_param = (hc_device_param_t *) p;
4442
4443 if (device_param->skipped) return NULL;
4444
4445 autotune (device_param);
4446
4447 const uint attack_mode = data.attack_mode;
4448 const uint attack_kern = data.attack_kern;
4449
4450 if (attack_mode == ATTACK_MODE_BF)
4451 {
4452 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4453 {
4454 const uint work = get_work (device_param, -1, true);
4455
4456 if (work == 0) break;
4457
4458 const u64 words_off = device_param->words_off;
4459 const u64 words_fin = words_off + work;
4460
4461 const uint pws_cnt = work;
4462
4463 device_param->pws_cnt = 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 /*
4474 still required?
4475 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4476 */
4477 }
4478
4479 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4480
4481 if (data.devices_status == STATUS_CRACKED) break;
4482 if (data.devices_status == STATUS_ABORTED) break;
4483 if (data.devices_status == STATUS_QUIT) break;
4484 if (data.devices_status == STATUS_BYPASS) break;
4485
4486 if (data.benchmark == 1) break;
4487
4488 device_param->words_done = words_fin;
4489 }
4490 }
4491 else
4492 {
4493 const uint segment_size = data.segment_size;
4494
4495 char *dictfile = data.dictfile;
4496
4497 if (attack_mode == ATTACK_MODE_COMBI)
4498 {
4499 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4500 {
4501 dictfile = data.dictfile2;
4502 }
4503 }
4504
4505 FILE *fd = fopen (dictfile, "rb");
4506
4507 if (fd == NULL)
4508 {
4509 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4510
4511 return NULL;
4512 }
4513
4514 if (attack_mode == ATTACK_MODE_COMBI)
4515 {
4516 const uint combs_mode = data.combs_mode;
4517
4518 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4519 {
4520 const char *dictfilec = data.dictfile2;
4521
4522 FILE *combs_fp = fopen (dictfilec, "rb");
4523
4524 if (combs_fp == NULL)
4525 {
4526 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4527
4528 fclose (fd);
4529
4530 return NULL;
4531 }
4532
4533 device_param->combs_fp = combs_fp;
4534 }
4535 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4536 {
4537 const char *dictfilec = data.dictfile;
4538
4539 FILE *combs_fp = fopen (dictfilec, "rb");
4540
4541 if (combs_fp == NULL)
4542 {
4543 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4544
4545 fclose (fd);
4546
4547 return NULL;
4548 }
4549
4550 device_param->combs_fp = combs_fp;
4551 }
4552 }
4553
4554 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4555
4556 wl_data->buf = (char *) mymalloc (segment_size);
4557 wl_data->avail = segment_size;
4558 wl_data->incr = segment_size;
4559 wl_data->cnt = 0;
4560 wl_data->pos = 0;
4561
4562 u64 words_cur = 0;
4563
4564 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4565 {
4566 u64 words_off = 0;
4567 u64 words_fin = 0;
4568
4569 bool allow_div = true;
4570
4571 u64 max = -1;
4572
4573 while (max)
4574 {
4575 const uint work = get_work (device_param, max, allow_div);
4576
4577 allow_div = false;
4578
4579 if (work == 0) break;
4580
4581 words_off = device_param->words_off;
4582 words_fin = words_off + work;
4583
4584 char *line_buf;
4585 uint line_len;
4586
4587 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4588
4589 max = 0;
4590
4591 for ( ; words_cur < words_fin; words_cur++)
4592 {
4593 get_next_word (wl_data, fd, &line_buf, &line_len);
4594
4595 line_len = convert_from_hex (line_buf, line_len);
4596
4597 // post-process rule engine
4598
4599 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4600 {
4601 char rule_buf_out[BLOCK_SIZE] = { 0 };
4602
4603 int rule_len_out = -1;
4604
4605 if (line_len < BLOCK_SIZE)
4606 {
4607 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4608 }
4609
4610 if (rule_len_out < 0) continue;
4611
4612 line_buf = rule_buf_out;
4613 line_len = rule_len_out;
4614 }
4615
4616 if (attack_kern == ATTACK_KERN_STRAIGHT)
4617 {
4618 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4619 {
4620 max++;
4621
4622 hc_thread_mutex_lock (mux_counter);
4623
4624 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4625 {
4626 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4627 }
4628
4629 hc_thread_mutex_unlock (mux_counter);
4630
4631 continue;
4632 }
4633 }
4634 else if (attack_kern == ATTACK_KERN_COMBI)
4635 {
4636 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4637 // since we still need to combine the plains
4638
4639 if (line_len > data.pw_max)
4640 {
4641 max++;
4642
4643 hc_thread_mutex_lock (mux_counter);
4644
4645 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4646 {
4647 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4648 }
4649
4650 hc_thread_mutex_unlock (mux_counter);
4651
4652 continue;
4653 }
4654 }
4655
4656 pw_add (device_param, (u8 *) line_buf, line_len);
4657
4658 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4659
4660 if (data.devices_status == STATUS_CRACKED) break;
4661 if (data.devices_status == STATUS_ABORTED) break;
4662 if (data.devices_status == STATUS_QUIT) break;
4663 if (data.devices_status == STATUS_BYPASS) break;
4664 }
4665
4666 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4667
4668 if (data.devices_status == STATUS_CRACKED) break;
4669 if (data.devices_status == STATUS_ABORTED) break;
4670 if (data.devices_status == STATUS_QUIT) break;
4671 if (data.devices_status == STATUS_BYPASS) break;
4672 }
4673
4674 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4675
4676 if (data.devices_status == STATUS_CRACKED) break;
4677 if (data.devices_status == STATUS_ABORTED) break;
4678 if (data.devices_status == STATUS_QUIT) break;
4679 if (data.devices_status == STATUS_BYPASS) break;
4680
4681 //
4682 // flush
4683 //
4684
4685 const uint pws_cnt = device_param->pws_cnt;
4686
4687 if (pws_cnt)
4688 {
4689 run_copy (device_param, pws_cnt);
4690
4691 run_cracker (device_param, pws_cnt);
4692
4693 device_param->pws_cnt = 0;
4694
4695 /*
4696 still required?
4697 if (attack_kern == ATTACK_KERN_STRAIGHT)
4698 {
4699 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4700 }
4701 else if (attack_kern == ATTACK_KERN_COMBI)
4702 {
4703 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4704 }
4705 */
4706 }
4707
4708 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4709
4710 if (data.devices_status == STATUS_CRACKED) break;
4711 if (data.devices_status == STATUS_ABORTED) break;
4712 if (data.devices_status == STATUS_QUIT) break;
4713 if (data.devices_status == STATUS_BYPASS) break;
4714
4715 if (words_fin == 0) break;
4716
4717 device_param->words_done = words_fin;
4718 }
4719
4720 if (attack_mode == ATTACK_MODE_COMBI)
4721 {
4722 fclose (device_param->combs_fp);
4723 }
4724
4725 free (wl_data->buf);
4726 free (wl_data);
4727
4728 fclose (fd);
4729 }
4730
4731 device_param->kernel_accel = 0;
4732 device_param->kernel_loops = 0;
4733
4734 return NULL;
4735 }
4736
4737 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4738 {
4739 if (!device_param)
4740 {
4741 log_error ("ERROR: %s : Invalid argument", __func__);
4742
4743 exit (-1);
4744 }
4745
4746 salt_t *salt_buf = &data.salts_buf[salt_pos];
4747
4748 device_param->kernel_params_buf32[24] = salt_pos;
4749 device_param->kernel_params_buf32[27] = 1;
4750 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4751 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4752 device_param->kernel_params_buf32[30] = 0;
4753 device_param->kernel_params_buf32[31] = 1;
4754
4755 char *dictfile_old = data.dictfile;
4756
4757 const char *weak_hash_check = "weak-hash-check";
4758
4759 data.dictfile = (char *) weak_hash_check;
4760
4761 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4762
4763 data.kernel_rules_buf[0].cmds[0] = 0;
4764
4765 /**
4766 * run the kernel
4767 */
4768
4769 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4770 {
4771 run_kernel (KERN_RUN_1, device_param, 1, false);
4772 }
4773 else
4774 {
4775 run_kernel (KERN_RUN_1, device_param, 1, false);
4776
4777 uint loop_step = 16;
4778
4779 const uint iter = salt_buf->salt_iter;
4780
4781 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4782 {
4783 uint loop_left = iter - loop_pos;
4784
4785 loop_left = MIN (loop_left, loop_step);
4786
4787 device_param->kernel_params_buf32[25] = loop_pos;
4788 device_param->kernel_params_buf32[26] = loop_left;
4789
4790 run_kernel (KERN_RUN_2, device_param, 1, false);
4791 }
4792
4793 run_kernel (KERN_RUN_3, device_param, 1, false);
4794 }
4795
4796 /**
4797 * result
4798 */
4799
4800 check_cracked (device_param, salt_pos);
4801
4802 /**
4803 * cleanup
4804 */
4805
4806 device_param->kernel_params_buf32[24] = 0;
4807 device_param->kernel_params_buf32[25] = 0;
4808 device_param->kernel_params_buf32[26] = 0;
4809 device_param->kernel_params_buf32[27] = 0;
4810 device_param->kernel_params_buf32[28] = 0;
4811 device_param->kernel_params_buf32[29] = 0;
4812 device_param->kernel_params_buf32[30] = 0;
4813 device_param->kernel_params_buf32[31] = 0;
4814
4815 data.dictfile = dictfile_old;
4816
4817 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4818 }
4819
4820 // hlfmt hashcat
4821
4822 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4823 {
4824 if (data.username == 0)
4825 {
4826 *hashbuf_pos = line_buf;
4827 *hashbuf_len = line_len;
4828 }
4829 else
4830 {
4831 char *pos = line_buf;
4832 int len = line_len;
4833
4834 for (int i = 0; i < line_len; i++, pos++, len--)
4835 {
4836 if (line_buf[i] == data.separator)
4837 {
4838 pos++;
4839
4840 len--;
4841
4842 break;
4843 }
4844 }
4845
4846 *hashbuf_pos = pos;
4847 *hashbuf_len = len;
4848 }
4849 }
4850
4851 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4852 {
4853 char *pos = NULL;
4854 int len = 0;
4855
4856 int sep_cnt = 0;
4857
4858 for (int i = 0; i < line_len; i++)
4859 {
4860 if (line_buf[i] == data.separator)
4861 {
4862 sep_cnt++;
4863
4864 continue;
4865 }
4866
4867 if (sep_cnt == 0)
4868 {
4869 if (pos == NULL) pos = line_buf + i;
4870
4871 len++;
4872 }
4873 }
4874
4875 *userbuf_pos = pos;
4876 *userbuf_len = len;
4877 }
4878
4879 // hlfmt pwdump
4880
4881 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4882 {
4883 int sep_cnt = 0;
4884
4885 int sep2_len = 0;
4886 int sep3_len = 0;
4887
4888 for (int i = 0; i < line_len; i++)
4889 {
4890 if (line_buf[i] == ':')
4891 {
4892 sep_cnt++;
4893
4894 continue;
4895 }
4896
4897 if (sep_cnt == 2) sep2_len++;
4898 if (sep_cnt == 3) sep3_len++;
4899 }
4900
4901 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4902
4903 return 0;
4904 }
4905
4906 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4907 {
4908 char *pos = NULL;
4909 int len = 0;
4910
4911 int sep_cnt = 0;
4912
4913 for (int i = 0; i < line_len; i++)
4914 {
4915 if (line_buf[i] == ':')
4916 {
4917 sep_cnt++;
4918
4919 continue;
4920 }
4921
4922 if (data.hash_mode == 1000)
4923 {
4924 if (sep_cnt == 3)
4925 {
4926 if (pos == NULL) pos = line_buf + i;
4927
4928 len++;
4929 }
4930 }
4931 else if (data.hash_mode == 3000)
4932 {
4933 if (sep_cnt == 2)
4934 {
4935 if (pos == NULL) pos = line_buf + i;
4936
4937 len++;
4938 }
4939 }
4940 }
4941
4942 *hashbuf_pos = pos;
4943 *hashbuf_len = len;
4944 }
4945
4946 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4947 {
4948 char *pos = NULL;
4949 int len = 0;
4950
4951 int sep_cnt = 0;
4952
4953 for (int i = 0; i < line_len; i++)
4954 {
4955 if (line_buf[i] == ':')
4956 {
4957 sep_cnt++;
4958
4959 continue;
4960 }
4961
4962 if (sep_cnt == 0)
4963 {
4964 if (pos == NULL) pos = line_buf + i;
4965
4966 len++;
4967 }
4968 }
4969
4970 *userbuf_pos = pos;
4971 *userbuf_len = len;
4972 }
4973
4974 // hlfmt passwd
4975
4976 static int hlfmt_detect_passwd (char *line_buf, int line_len)
4977 {
4978 int sep_cnt = 0;
4979
4980 char sep5_first = 0;
4981 char sep6_first = 0;
4982
4983 for (int i = 0; i < line_len; i++)
4984 {
4985 if (line_buf[i] == ':')
4986 {
4987 sep_cnt++;
4988
4989 continue;
4990 }
4991
4992 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4993 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4994 }
4995
4996 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4997
4998 return 0;
4999 }
5000
5001 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5002 {
5003 char *pos = NULL;
5004 int len = 0;
5005
5006 int sep_cnt = 0;
5007
5008 for (int i = 0; i < line_len; i++)
5009 {
5010 if (line_buf[i] == ':')
5011 {
5012 sep_cnt++;
5013
5014 continue;
5015 }
5016
5017 if (sep_cnt == 1)
5018 {
5019 if (pos == NULL) pos = line_buf + i;
5020
5021 len++;
5022 }
5023 }
5024
5025 *hashbuf_pos = pos;
5026 *hashbuf_len = len;
5027 }
5028
5029 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5030 {
5031 char *pos = NULL;
5032 int len = 0;
5033
5034 int sep_cnt = 0;
5035
5036 for (int i = 0; i < line_len; i++)
5037 {
5038 if (line_buf[i] == ':')
5039 {
5040 sep_cnt++;
5041
5042 continue;
5043 }
5044
5045 if (sep_cnt == 0)
5046 {
5047 if (pos == NULL) pos = line_buf + i;
5048
5049 len++;
5050 }
5051 }
5052
5053 *userbuf_pos = pos;
5054 *userbuf_len = len;
5055 }
5056
5057 // hlfmt shadow
5058
5059 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5060 {
5061 int sep_cnt = 0;
5062
5063 for (int i = 0; i < line_len; i++)
5064 {
5065 if (line_buf[i] == ':') sep_cnt++;
5066 }
5067
5068 if (sep_cnt == 8) return 1;
5069
5070 return 0;
5071 }
5072
5073 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5074 {
5075 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5076 }
5077
5078 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5079 {
5080 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5081 }
5082
5083 // hlfmt main
5084
5085 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5086 {
5087 switch (hashfile_format)
5088 {
5089 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5090 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5091 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5092 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5093 }
5094 }
5095
5096 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5097 {
5098 switch (hashfile_format)
5099 {
5100 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5101 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5102 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5103 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5104 }
5105 }
5106
5107 char *strhlfmt (const uint hashfile_format)
5108 {
5109 switch (hashfile_format)
5110 {
5111 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5112 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5113 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5114 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5115 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5116 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5117 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5118 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5119 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5120 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5121 }
5122
5123 return ((char *) "Unknown");
5124 }
5125
5126 static uint hlfmt_detect (FILE *fp, uint max_check)
5127 {
5128 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5129
5130 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5131 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5132
5133 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5134
5135 uint num_check = 0;
5136
5137 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5138
5139 while (!feof (fp))
5140 {
5141 int line_len = fgetl (fp, line_buf);
5142
5143 if (line_len == 0) continue;
5144
5145 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5146 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5147 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5148
5149 if (num_check == max_check) break;
5150
5151 num_check++;
5152 }
5153
5154 myfree (line_buf);
5155
5156 uint hashlist_format = HLFMT_HASHCAT;
5157
5158 for (int i = 1; i < HLFMTS_CNT; i++)
5159 {
5160 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5161
5162 hashlist_format = i;
5163 }
5164
5165 free (formats_cnt);
5166
5167 return hashlist_format;
5168 }
5169
5170 /**
5171 * some further helper function
5172 */
5173
5174 // wrapper around mymalloc for ADL
5175
5176 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5177 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5178 {
5179 return mymalloc (iSize);
5180 }
5181 #endif
5182
5183 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)
5184 {
5185 u64 collisions = 0;
5186
5187 const uint dgst_pos0 = data.dgst_pos0;
5188 const uint dgst_pos1 = data.dgst_pos1;
5189 const uint dgst_pos2 = data.dgst_pos2;
5190 const uint dgst_pos3 = data.dgst_pos3;
5191
5192 memset (bitmap_a, 0, bitmap_size);
5193 memset (bitmap_b, 0, bitmap_size);
5194 memset (bitmap_c, 0, bitmap_size);
5195 memset (bitmap_d, 0, bitmap_size);
5196
5197 for (uint i = 0; i < digests_cnt; i++)
5198 {
5199 if (data.digests_shown[i] == 1) continue; // can happen with potfile
5200
5201 uint *digest_ptr = (uint *) digests_buf_ptr;
5202
5203 digests_buf_ptr += dgst_size;
5204
5205 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5206 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5207 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5208 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5209
5210 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5211 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5212 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5213 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5214
5215 if (bitmap_a[idx0] & val0) collisions++;
5216 if (bitmap_b[idx1] & val1) collisions++;
5217 if (bitmap_c[idx2] & val2) collisions++;
5218 if (bitmap_d[idx3] & val3) collisions++;
5219
5220 bitmap_a[idx0] |= val0;
5221 bitmap_b[idx1] |= val1;
5222 bitmap_c[idx2] |= val2;
5223 bitmap_d[idx3] |= val3;
5224
5225 if (collisions >= collisions_max) return 0x7fffffff;
5226 }
5227
5228 return collisions;
5229 }
5230
5231 /**
5232 * main
5233 */
5234
5235 int main (int argc, char **argv)
5236 {
5237 /**
5238 * To help users a bit
5239 */
5240
5241 char *compute = getenv ("COMPUTE");
5242
5243 if (compute)
5244 {
5245 static char display[100];
5246
5247 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5248
5249 putenv (display);
5250 }
5251 else
5252 {
5253 if (getenv ("DISPLAY") == NULL)
5254 putenv ((char *) "DISPLAY=:0");
5255 }
5256
5257 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5258 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5259
5260 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5261 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5262
5263 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5264 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5265
5266 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5267 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5268
5269 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5270 putenv ((char *) "POCL_KERNEL_CACHE=0");
5271
5272 umask (077);
5273
5274 /**
5275 * Real init
5276 */
5277
5278 memset (&data, 0, sizeof (hc_global_data_t));
5279
5280 time_t proc_start;
5281
5282 time (&proc_start);
5283
5284 data.proc_start = proc_start;
5285
5286 int myargc = argc;
5287 char **myargv = argv;
5288
5289 hc_thread_mutex_init (mux_dispatcher);
5290 hc_thread_mutex_init (mux_counter);
5291 hc_thread_mutex_init (mux_display);
5292 hc_thread_mutex_init (mux_adl);
5293
5294 /**
5295 * commandline parameters
5296 */
5297
5298 uint usage = USAGE;
5299 uint version = VERSION;
5300 uint quiet = QUIET;
5301 uint benchmark = BENCHMARK;
5302 uint show = SHOW;
5303 uint left = LEFT;
5304 uint username = USERNAME;
5305 uint remove = REMOVE;
5306 uint remove_timer = REMOVE_TIMER;
5307 u64 skip = SKIP;
5308 u64 limit = LIMIT;
5309 uint keyspace = KEYSPACE;
5310 uint potfile_disable = POTFILE_DISABLE;
5311 char *potfile_path = NULL;
5312 uint debug_mode = DEBUG_MODE;
5313 char *debug_file = NULL;
5314 char *induction_dir = NULL;
5315 char *outfile_check_dir = NULL;
5316 uint force = FORCE;
5317 uint runtime = RUNTIME;
5318 uint hash_mode = HASH_MODE;
5319 uint attack_mode = ATTACK_MODE;
5320 uint markov_disable = MARKOV_DISABLE;
5321 uint markov_classic = MARKOV_CLASSIC;
5322 uint markov_threshold = MARKOV_THRESHOLD;
5323 char *markov_hcstat = NULL;
5324 char *outfile = NULL;
5325 uint outfile_format = OUTFILE_FORMAT;
5326 uint outfile_autohex = OUTFILE_AUTOHEX;
5327 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5328 uint restore = RESTORE;
5329 uint restore_timer = RESTORE_TIMER;
5330 uint restore_disable = RESTORE_DISABLE;
5331 uint status = STATUS;
5332 uint status_timer = STATUS_TIMER;
5333 uint status_automat = STATUS_AUTOMAT;
5334 uint loopback = LOOPBACK;
5335 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5336 char *session = NULL;
5337 uint hex_charset = HEX_CHARSET;
5338 uint hex_salt = HEX_SALT;
5339 uint hex_wordlist = HEX_WORDLIST;
5340 uint rp_gen = RP_GEN;
5341 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5342 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5343 uint rp_gen_seed = RP_GEN_SEED;
5344 char *rule_buf_l = (char *) RULE_BUF_L;
5345 char *rule_buf_r = (char *) RULE_BUF_R;
5346 uint increment = INCREMENT;
5347 uint increment_min = INCREMENT_MIN;
5348 uint increment_max = INCREMENT_MAX;
5349 char *cpu_affinity = NULL;
5350 OCL_PTR *ocl = NULL;
5351 char *opencl_devices = NULL;
5352 char *opencl_platforms = NULL;
5353 char *opencl_device_types = NULL;
5354 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5355 char *truecrypt_keyfiles = NULL;
5356 char *veracrypt_keyfiles = NULL;
5357 uint veracrypt_pim = 0;
5358 uint workload_profile = WORKLOAD_PROFILE;
5359 uint kernel_accel = KERNEL_ACCEL;
5360 uint kernel_loops = KERNEL_LOOPS;
5361 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5362 #ifdef HAVE_HWMON
5363 uint gpu_temp_abort = GPU_TEMP_ABORT;
5364 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5365 #ifdef HAVE_ADL
5366 uint powertune_enable = POWERTUNE_ENABLE;
5367 #endif
5368 #endif
5369 uint logfile_disable = LOGFILE_DISABLE;
5370 uint segment_size = SEGMENT_SIZE;
5371 uint scrypt_tmto = SCRYPT_TMTO;
5372 char separator = SEPARATOR;
5373 uint bitmap_min = BITMAP_MIN;
5374 uint bitmap_max = BITMAP_MAX;
5375 char *custom_charset_1 = NULL;
5376 char *custom_charset_2 = NULL;
5377 char *custom_charset_3 = NULL;
5378 char *custom_charset_4 = NULL;
5379
5380 #define IDX_HELP 'h'
5381 #define IDX_VERSION 'V'
5382 #define IDX_VERSION_LOWER 'v'
5383 #define IDX_QUIET 0xff02
5384 #define IDX_SHOW 0xff03
5385 #define IDX_LEFT 0xff04
5386 #define IDX_REMOVE 0xff05
5387 #define IDX_REMOVE_TIMER 0xff37
5388 #define IDX_SKIP 's'
5389 #define IDX_LIMIT 'l'
5390 #define IDX_KEYSPACE 0xff35
5391 #define IDX_POTFILE_DISABLE 0xff06
5392 #define IDX_POTFILE_PATH 0xffe0
5393 #define IDX_DEBUG_MODE 0xff43
5394 #define IDX_DEBUG_FILE 0xff44
5395 #define IDX_INDUCTION_DIR 0xff46
5396 #define IDX_OUTFILE_CHECK_DIR 0xff47
5397 #define IDX_USERNAME 0xff07
5398 #define IDX_FORCE 0xff08
5399 #define IDX_RUNTIME 0xff09
5400 #define IDX_BENCHMARK 'b'
5401 #define IDX_HASH_MODE 'm'
5402 #define IDX_ATTACK_MODE 'a'
5403 #define IDX_RP_FILE 'r'
5404 #define IDX_RP_GEN 'g'
5405 #define IDX_RP_GEN_FUNC_MIN 0xff10
5406 #define IDX_RP_GEN_FUNC_MAX 0xff11
5407 #define IDX_RP_GEN_SEED 0xff34
5408 #define IDX_RULE_BUF_L 'j'
5409 #define IDX_RULE_BUF_R 'k'
5410 #define IDX_INCREMENT 'i'
5411 #define IDX_INCREMENT_MIN 0xff12
5412 #define IDX_INCREMENT_MAX 0xff13
5413 #define IDX_OUTFILE 'o'
5414 #define IDX_OUTFILE_FORMAT 0xff14
5415 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5416 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5417 #define IDX_RESTORE 0xff15
5418 #define IDX_RESTORE_DISABLE 0xff27
5419 #define IDX_STATUS 0xff17
5420 #define IDX_STATUS_TIMER 0xff18
5421 #define IDX_STATUS_AUTOMAT 0xff50
5422 #define IDX_LOOPBACK 0xff38
5423 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5424 #define IDX_SESSION 0xff19
5425 #define IDX_HEX_CHARSET 0xff20
5426 #define IDX_HEX_SALT 0xff21
5427 #define IDX_HEX_WORDLIST 0xff40
5428 #define IDX_MARKOV_DISABLE 0xff22
5429 #define IDX_MARKOV_CLASSIC 0xff23
5430 #define IDX_MARKOV_THRESHOLD 't'
5431 #define IDX_MARKOV_HCSTAT 0xff24
5432 #define IDX_CPU_AFFINITY 0xff25
5433 #define IDX_OPENCL_DEVICES 'd'
5434 #define IDX_OPENCL_PLATFORMS 0xff72
5435 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5436 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5437 #define IDX_WORKLOAD_PROFILE 'w'
5438 #define IDX_KERNEL_ACCEL 'n'
5439 #define IDX_KERNEL_LOOPS 'u'
5440 #define IDX_GPU_TEMP_DISABLE 0xff29
5441 #define IDX_GPU_TEMP_ABORT 0xff30
5442 #define IDX_GPU_TEMP_RETAIN 0xff31
5443 #define IDX_POWERTUNE_ENABLE 0xff41
5444 #define IDX_LOGFILE_DISABLE 0xff51
5445 #define IDX_TRUECRYPT_KEYFILES 0xff52
5446 #define IDX_VERACRYPT_KEYFILES 0xff53
5447 #define IDX_VERACRYPT_PIM 0xff54
5448 #define IDX_SCRYPT_TMTO 0xff61
5449 #define IDX_SEGMENT_SIZE 'c'
5450 #define IDX_SEPARATOR 'p'
5451 #define IDX_BITMAP_MIN 0xff70
5452 #define IDX_BITMAP_MAX 0xff71
5453 #define IDX_CUSTOM_CHARSET_1 '1'
5454 #define IDX_CUSTOM_CHARSET_2 '2'
5455 #define IDX_CUSTOM_CHARSET_3 '3'
5456 #define IDX_CUSTOM_CHARSET_4 '4'
5457
5458 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5459
5460 struct option long_options[] =
5461 {
5462 {"help", no_argument, 0, IDX_HELP},
5463 {"version", no_argument, 0, IDX_VERSION},
5464 {"quiet", no_argument, 0, IDX_QUIET},
5465 {"show", no_argument, 0, IDX_SHOW},
5466 {"left", no_argument, 0, IDX_LEFT},
5467 {"username", no_argument, 0, IDX_USERNAME},
5468 {"remove", no_argument, 0, IDX_REMOVE},
5469 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5470 {"skip", required_argument, 0, IDX_SKIP},
5471 {"limit", required_argument, 0, IDX_LIMIT},
5472 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5473 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5474 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5475 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5476 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5477 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5478 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5479 {"force", no_argument, 0, IDX_FORCE},
5480 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5481 {"restore", no_argument, 0, IDX_RESTORE},
5482 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5483 {"status", no_argument, 0, IDX_STATUS},
5484 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5485 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5486 {"loopback", no_argument, 0, IDX_LOOPBACK},
5487 {"weak-hash-threshold",
5488 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5489 {"session", required_argument, 0, IDX_SESSION},
5490 {"runtime", required_argument, 0, IDX_RUNTIME},
5491 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5492 {"generate-rules-func-min",
5493 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5494 {"generate-rules-func-max",
5495 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5496 {"generate-rules-seed",
5497 required_argument, 0, IDX_RP_GEN_SEED},
5498 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5499 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5500 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5501 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5502 {"rules-file", required_argument, 0, IDX_RP_FILE},
5503 {"outfile", required_argument, 0, IDX_OUTFILE},
5504 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5505 {"outfile-autohex-disable",
5506 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5507 {"outfile-check-timer",
5508 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5509 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5510 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5511 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5512 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5513 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5514 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5515 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5516 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5517 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5518 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5519 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5520 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5521 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5522 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5523 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5524 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5525 #ifdef HAVE_HWMON
5526 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5527 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5528 #ifdef HAVE_ADL
5529 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5530 #endif
5531 #endif // HAVE_HWMON
5532 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5533 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5534 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5535 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5536 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5537 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5538 // deprecated
5539 {"seperator", required_argument, 0, IDX_SEPARATOR},
5540 {"separator", required_argument, 0, IDX_SEPARATOR},
5541 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5542 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5543 {"increment", no_argument, 0, IDX_INCREMENT},
5544 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5545 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5546 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5547 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5548 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5549 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5550
5551 {0, 0, 0, 0}
5552 };
5553
5554 uint rp_files_cnt = 0;
5555
5556 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5557
5558 int option_index = 0;
5559 int c = -1;
5560
5561 optind = 1;
5562 optopt = 0;
5563
5564 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5565 {
5566 switch (c)
5567 {
5568 case IDX_HELP: usage = 1; break;
5569 case IDX_VERSION:
5570 case IDX_VERSION_LOWER: version = 1; break;
5571 case IDX_RESTORE: restore = 1; break;
5572 case IDX_SESSION: session = optarg; break;
5573 case IDX_SHOW: show = 1; break;
5574 case IDX_LEFT: left = 1; break;
5575 case '?': return (-1);
5576 }
5577 }
5578
5579 if (optopt != 0)
5580 {
5581 log_error ("ERROR: Invalid argument specified");
5582
5583 return (-1);
5584 }
5585
5586 /**
5587 * exit functions
5588 */
5589
5590 if (version)
5591 {
5592 log_info ("%s", VERSION_TAG);
5593
5594 return (0);
5595 }
5596
5597 if (usage)
5598 {
5599 usage_big_print (PROGNAME);
5600
5601 return (0);
5602 }
5603
5604 /**
5605 * session needs to be set, always!
5606 */
5607
5608 if (session == NULL) session = (char *) PROGNAME;
5609
5610 /**
5611 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5612 */
5613
5614 char *exec_path = get_exec_path ();
5615
5616 #ifdef LINUX
5617
5618 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5619 char *resolved_exec_path = realpath (exec_path, NULL);
5620
5621 char *install_dir = get_install_dir (resolved_exec_path);
5622 char *profile_dir = NULL;
5623 char *session_dir = NULL;
5624 char *shared_dir = NULL;
5625
5626 if (strcmp (install_dir, resolved_install_folder) == 0)
5627 {
5628 struct passwd *pw = getpwuid (getuid ());
5629
5630 const char *homedir = pw->pw_dir;
5631
5632 profile_dir = get_profile_dir (homedir);
5633 session_dir = get_session_dir (profile_dir);
5634 shared_dir = strdup (SHARED_FOLDER);
5635
5636 mkdir (profile_dir, 0700);
5637 mkdir (session_dir, 0700);
5638 }
5639 else
5640 {
5641 profile_dir = install_dir;
5642 session_dir = install_dir;
5643 shared_dir = install_dir;
5644 }
5645
5646 myfree (resolved_install_folder);
5647 myfree (resolved_exec_path);
5648
5649 #else
5650
5651 char *install_dir = get_install_dir (exec_path);
5652 char *profile_dir = install_dir;
5653 char *session_dir = install_dir;
5654 char *shared_dir = install_dir;
5655
5656 #endif
5657
5658 data.install_dir = install_dir;
5659 data.profile_dir = profile_dir;
5660 data.session_dir = session_dir;
5661 data.shared_dir = shared_dir;
5662
5663 myfree (exec_path);
5664
5665 /**
5666 * kernel cache, we need to make sure folder exist
5667 */
5668
5669 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5670
5671 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5672
5673 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5674
5675 mkdir (kernels_folder, 0700);
5676
5677 myfree (kernels_folder);
5678
5679 /**
5680 * session
5681 */
5682
5683 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5684
5685 data.session = session;
5686
5687 char *eff_restore_file = (char *) mymalloc (session_size);
5688 char *new_restore_file = (char *) mymalloc (session_size);
5689
5690 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5691 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5692
5693 data.eff_restore_file = eff_restore_file;
5694 data.new_restore_file = new_restore_file;
5695
5696 if (((show == 1) || (left == 1)) && (restore == 1))
5697 {
5698 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5699 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5700
5701 return (-1);
5702 }
5703
5704 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5705 if ((show == 1) || (left == 1))
5706 {
5707 restore_disable = 1;
5708
5709 restore = 0;
5710 }
5711
5712 data.restore_disable = restore_disable;
5713
5714 restore_data_t *rd = init_restore (argc, argv);
5715
5716 data.rd = rd;
5717
5718 /**
5719 * restore file
5720 */
5721
5722 if (restore == 1)
5723 {
5724 read_restore (eff_restore_file, rd);
5725
5726 if (rd->version_bin < RESTORE_MIN)
5727 {
5728 log_error ("ERROR: Incompatible restore-file version");
5729
5730 return (-1);
5731 }
5732
5733 myargc = rd->argc;
5734 myargv = rd->argv;
5735
5736 #ifdef _POSIX
5737 rd->pid = getpid ();
5738 #elif _WIN
5739 rd->pid = GetCurrentProcessId ();
5740 #endif
5741 }
5742
5743 uint hash_mode_chgd = 0;
5744 uint runtime_chgd = 0;
5745 uint kernel_loops_chgd = 0;
5746 uint kernel_accel_chgd = 0;
5747 uint attack_mode_chgd = 0;
5748 uint outfile_format_chgd = 0;
5749 uint rp_gen_seed_chgd = 0;
5750 uint remove_timer_chgd = 0;
5751 uint increment_min_chgd = 0;
5752 uint increment_max_chgd = 0;
5753 uint workload_profile_chgd = 0;
5754 uint opencl_vector_width_chgd = 0;
5755
5756 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5757 uint gpu_temp_retain_chgd = 0;
5758 uint gpu_temp_abort_chgd = 0;
5759 #endif
5760
5761 optind = 1;
5762 optopt = 0;
5763 option_index = 0;
5764
5765 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5766 {
5767 switch (c)
5768 {
5769 //case IDX_HELP: usage = 1; break;
5770 //case IDX_VERSION: version = 1; break;
5771 //case IDX_RESTORE: restore = 1; break;
5772 case IDX_QUIET: quiet = 1; break;
5773 //case IDX_SHOW: show = 1; break;
5774 case IDX_SHOW: break;
5775 //case IDX_LEFT: left = 1; break;
5776 case IDX_LEFT: break;
5777 case IDX_USERNAME: username = 1; break;
5778 case IDX_REMOVE: remove = 1; break;
5779 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5780 remove_timer_chgd = 1; break;
5781 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5782 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5783 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5784 case IDX_DEBUG_FILE: debug_file = optarg; break;
5785 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5786 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5787 case IDX_FORCE: force = 1; break;
5788 case IDX_SKIP: skip = atoll (optarg); break;
5789 case IDX_LIMIT: limit = atoll (optarg); break;
5790 case IDX_KEYSPACE: keyspace = 1; break;
5791 case IDX_BENCHMARK: benchmark = 1; break;
5792 case IDX_RESTORE: break;
5793 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5794 case IDX_STATUS: status = 1; break;
5795 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5796 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5797 case IDX_LOOPBACK: loopback = 1; break;
5798 case IDX_WEAK_HASH_THRESHOLD:
5799 weak_hash_threshold = atoi (optarg); break;
5800 //case IDX_SESSION: session = optarg; break;
5801 case IDX_SESSION: break;
5802 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5803 hash_mode_chgd = 1; break;
5804 case IDX_RUNTIME: runtime = atoi (optarg);
5805 runtime_chgd = 1; break;
5806 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5807 attack_mode_chgd = 1; break;
5808 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5809 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5810 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5811 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5812 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5813 rp_gen_seed_chgd = 1; break;
5814 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5815 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5816 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5817 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5818 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5819 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5820 case IDX_OUTFILE: outfile = optarg; break;
5821 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5822 outfile_format_chgd = 1; break;
5823 case IDX_OUTFILE_AUTOHEX_DISABLE:
5824 outfile_autohex = 0; break;
5825 case IDX_OUTFILE_CHECK_TIMER:
5826 outfile_check_timer = atoi (optarg); break;
5827 case IDX_HEX_CHARSET: hex_charset = 1; break;
5828 case IDX_HEX_SALT: hex_salt = 1; break;
5829 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5830 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5831 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5832 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5833 case IDX_OPENCL_DEVICE_TYPES:
5834 opencl_device_types = optarg; break;
5835 case IDX_OPENCL_VECTOR_WIDTH:
5836 opencl_vector_width = atoi (optarg);
5837 opencl_vector_width_chgd = 1; break;
5838 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5839 workload_profile_chgd = 1; break;
5840 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5841 kernel_accel_chgd = 1; break;
5842 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5843 kernel_loops_chgd = 1; break;
5844 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5845 #ifdef HAVE_HWMON
5846 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5847 #ifdef HAVE_ADL
5848 gpu_temp_abort_chgd = 1;
5849 #endif
5850 break;
5851 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5852 #ifdef HAVE_ADL
5853 gpu_temp_retain_chgd = 1;
5854 #endif
5855 break;
5856 #ifdef HAVE_ADL
5857 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5858 #endif
5859 #endif // HAVE_HWMON
5860 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5861 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5862 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
5863 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
5864 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5865 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5866 case IDX_SEPARATOR: separator = optarg[0]; break;
5867 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5868 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5869 case IDX_INCREMENT: increment = 1; break;
5870 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5871 increment_min_chgd = 1; break;
5872 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5873 increment_max_chgd = 1; break;
5874 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5875 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5876 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5877 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5878
5879 default:
5880 log_error ("ERROR: Invalid argument specified");
5881 return (-1);
5882 }
5883 }
5884
5885 if (optopt != 0)
5886 {
5887 log_error ("ERROR: Invalid argument specified");
5888
5889 return (-1);
5890 }
5891
5892 /**
5893 * Inform user things getting started,
5894 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5895 * - we do not need to check algorithm_pos
5896 */
5897
5898 if (quiet == 0)
5899 {
5900 if (benchmark == 1)
5901 {
5902 if (status_automat == 0)
5903 {
5904 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
5905 log_info ("");
5906 }
5907 else
5908 {
5909 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
5910 }
5911 }
5912 else if (restore == 1)
5913 {
5914 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
5915 log_info ("");
5916 }
5917 else
5918 {
5919 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
5920 log_info ("");
5921 }
5922 }
5923
5924 /**
5925 * sanity check
5926 */
5927
5928 if (attack_mode > 7)
5929 {
5930 log_error ("ERROR: Invalid attack-mode specified");
5931
5932 return (-1);
5933 }
5934
5935 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5936 {
5937 log_error ("ERROR: Invalid runtime specified");
5938
5939 return (-1);
5940 }
5941
5942 if (hash_mode_chgd && hash_mode > 13799) // just added to remove compiler warnings for hash_mode_chgd
5943 {
5944 log_error ("ERROR: Invalid hash-type specified");
5945
5946 return (-1);
5947 }
5948
5949 // renamed hash modes
5950
5951 if (hash_mode_chgd)
5952 {
5953 int n = -1;
5954
5955 switch (hash_mode)
5956 {
5957 case 123: n = 124;
5958 break;
5959 }
5960
5961 if (n >= 0)
5962 {
5963 log_error ("Old -m specified, use -m %d instead", n);
5964
5965 return (-1);
5966 }
5967 }
5968
5969 if (username == 1)
5970 {
5971 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
5972 {
5973 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5974
5975 return (-1);
5976 }
5977 }
5978
5979 if (outfile_format > 16)
5980 {
5981 log_error ("ERROR: Invalid outfile-format specified");
5982
5983 return (-1);
5984 }
5985
5986 if (left == 1)
5987 {
5988 if (outfile_format_chgd == 1)
5989 {
5990 if (outfile_format > 1)
5991 {
5992 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5993
5994 return (-1);
5995 }
5996 }
5997 else
5998 {
5999 outfile_format = OUTFILE_FMT_HASH;
6000 }
6001 }
6002
6003 if (show == 1)
6004 {
6005 if (outfile_format_chgd == 1)
6006 {
6007 if ((outfile_format > 7) && (outfile_format < 16))
6008 {
6009 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6010
6011 return (-1);
6012 }
6013 }
6014 }
6015
6016 if (increment_min < INCREMENT_MIN)
6017 {
6018 log_error ("ERROR: Invalid increment-min specified");
6019
6020 return (-1);
6021 }
6022
6023 if (increment_max > INCREMENT_MAX)
6024 {
6025 log_error ("ERROR: Invalid increment-max specified");
6026
6027 return (-1);
6028 }
6029
6030 if (increment_min > increment_max)
6031 {
6032 log_error ("ERROR: Invalid increment-min specified");
6033
6034 return (-1);
6035 }
6036
6037 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6038 {
6039 log_error ("ERROR: increment is not allowed in attack-mode 0");
6040
6041 return (-1);
6042 }
6043
6044 if ((increment == 0) && (increment_min_chgd == 1))
6045 {
6046 log_error ("ERROR: increment-min is only supported together with increment switch");
6047
6048 return (-1);
6049 }
6050
6051 if ((increment == 0) && (increment_max_chgd == 1))
6052 {
6053 log_error ("ERROR: increment-max is only supported together with increment switch");
6054
6055 return (-1);
6056 }
6057
6058 if (rp_files_cnt && rp_gen)
6059 {
6060 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6061
6062 return (-1);
6063 }
6064
6065 if (rp_files_cnt || rp_gen)
6066 {
6067 if (attack_mode != ATTACK_MODE_STRAIGHT)
6068 {
6069 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6070
6071 return (-1);
6072 }
6073 }
6074
6075 if (rp_gen_func_min > rp_gen_func_max)
6076 {
6077 log_error ("ERROR: Invalid rp-gen-func-min specified");
6078
6079 return (-1);
6080 }
6081
6082 if (kernel_accel_chgd == 1)
6083 {
6084 if (kernel_accel < 1)
6085 {
6086 log_error ("ERROR: Invalid kernel-accel specified");
6087
6088 return (-1);
6089 }
6090
6091 if (kernel_accel > 1024)
6092 {
6093 log_error ("ERROR: Invalid kernel-accel specified");
6094
6095 return (-1);
6096 }
6097 }
6098
6099 if (kernel_loops_chgd == 1)
6100 {
6101 if (kernel_loops < 1)
6102 {
6103 log_error ("ERROR: Invalid kernel-loops specified");
6104
6105 return (-1);
6106 }
6107
6108 if (kernel_loops > 1024)
6109 {
6110 log_error ("ERROR: Invalid kernel-loops specified");
6111
6112 return (-1);
6113 }
6114 }
6115
6116 if ((workload_profile < 1) || (workload_profile > 3))
6117 {
6118 log_error ("ERROR: workload-profile %i not available", workload_profile);
6119
6120 return (-1);
6121 }
6122
6123 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6124 {
6125 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6126
6127 return (-1);
6128 }
6129
6130 if (show == 1 || left == 1)
6131 {
6132 attack_mode = ATTACK_MODE_NONE;
6133
6134 if (remove == 1)
6135 {
6136 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6137
6138 return (-1);
6139 }
6140
6141 if (potfile_disable == 1)
6142 {
6143 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6144
6145 return (-1);
6146 }
6147 }
6148
6149 uint attack_kern = ATTACK_KERN_NONE;
6150
6151 switch (attack_mode)
6152 {
6153 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6154 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6155 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6156 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6157 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6158 }
6159
6160 if (benchmark == 0)
6161 {
6162 if (keyspace == 1)
6163 {
6164 int num_additional_params = 1;
6165
6166 if (attack_kern == ATTACK_KERN_COMBI)
6167 {
6168 num_additional_params = 2;
6169 }
6170
6171 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6172
6173 if (keyspace_wordlist_specified == 0) optind--;
6174 }
6175
6176 if (attack_kern == ATTACK_KERN_NONE)
6177 {
6178 if ((optind + 1) != myargc)
6179 {
6180 usage_mini_print (myargv[0]);
6181
6182 return (-1);
6183 }
6184 }
6185 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6186 {
6187 if ((optind + 1) > myargc)
6188 {
6189 usage_mini_print (myargv[0]);
6190
6191 return (-1);
6192 }
6193 }
6194 else if (attack_kern == ATTACK_KERN_COMBI)
6195 {
6196 if ((optind + 3) != myargc)
6197 {
6198 usage_mini_print (myargv[0]);
6199
6200 return (-1);
6201 }
6202 }
6203 else if (attack_kern == ATTACK_KERN_BF)
6204 {
6205 if ((optind + 1) > myargc)
6206 {
6207 usage_mini_print (myargv[0]);
6208
6209 return (-1);
6210 }
6211 }
6212 else
6213 {
6214 usage_mini_print (myargv[0]);
6215
6216 return (-1);
6217 }
6218 }
6219 else
6220 {
6221 if (myargv[optind] != 0)
6222 {
6223 log_error ("ERROR: Invalid argument for benchmark mode specified");
6224
6225 return (-1);
6226 }
6227
6228 if (attack_mode_chgd == 1)
6229 {
6230 if (attack_mode != ATTACK_MODE_BF)
6231 {
6232 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6233
6234 return (-1);
6235 }
6236 }
6237 }
6238
6239 if (skip != 0 && limit != 0)
6240 {
6241 limit += skip;
6242 }
6243
6244 if (keyspace == 1)
6245 {
6246 if (show == 1)
6247 {
6248 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6249
6250 return (-1);
6251 }
6252 else if (left == 1)
6253 {
6254 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6255
6256 return (-1);
6257 }
6258
6259 potfile_disable = 1;
6260
6261 restore_disable = 1;
6262
6263 restore = 0;
6264
6265 weak_hash_threshold = 0;
6266
6267 quiet = 1;
6268 }
6269
6270 if (remove_timer_chgd == 1)
6271 {
6272 if (remove == 0)
6273 {
6274 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6275
6276 return (-1);
6277 }
6278
6279 if (remove_timer < 1)
6280 {
6281 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6282
6283 return (-1);
6284 }
6285 }
6286
6287 if (loopback == 1)
6288 {
6289 if (attack_mode == ATTACK_MODE_STRAIGHT)
6290 {
6291 if ((rp_files_cnt == 0) && (rp_gen == 0))
6292 {
6293 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6294
6295 return (-1);
6296 }
6297 }
6298 else
6299 {
6300 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6301
6302 return (-1);
6303 }
6304 }
6305
6306 if (debug_mode > 0)
6307 {
6308 if (attack_mode != ATTACK_MODE_STRAIGHT)
6309 {
6310 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6311
6312 return (-1);
6313 }
6314
6315 if ((rp_files_cnt == 0) && (rp_gen == 0))
6316 {
6317 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6318
6319 return (-1);
6320 }
6321 }
6322
6323 if (debug_mode > 4)
6324 {
6325 log_error ("ERROR: Invalid debug-mode specified");
6326
6327 return (-1);
6328 }
6329
6330 if (debug_file != NULL)
6331 {
6332 if (debug_mode < 1)
6333 {
6334 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6335
6336 return (-1);
6337 }
6338 }
6339
6340 if (induction_dir != NULL)
6341 {
6342 if (attack_mode == ATTACK_MODE_BF)
6343 {
6344 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6345
6346 return (-1);
6347 }
6348 }
6349
6350 if (attack_mode != ATTACK_MODE_STRAIGHT)
6351 {
6352 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6353 {
6354 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6355
6356 return (-1);
6357 }
6358
6359 weak_hash_threshold = 0;
6360 }
6361
6362 /**
6363 * induction directory
6364 */
6365
6366 char *induction_directory = NULL;
6367
6368 if (attack_mode != ATTACK_MODE_BF)
6369 {
6370 if (induction_dir == NULL)
6371 {
6372 induction_directory = (char *) mymalloc (session_size);
6373
6374 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6375
6376 // create induction folder if it does not already exist
6377
6378 if (keyspace == 0)
6379 {
6380 if (rmdir (induction_directory) == -1)
6381 {
6382 if (errno == ENOENT)
6383 {
6384 // good, we can ignore
6385 }
6386 else if (errno == ENOTEMPTY)
6387 {
6388 char *induction_directory_mv = (char *) mymalloc (session_size);
6389
6390 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6391
6392 if (rename (induction_directory, induction_directory_mv) != 0)
6393 {
6394 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6395
6396 return (-1);
6397 }
6398 }
6399 else
6400 {
6401 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6402
6403 return (-1);
6404 }
6405 }
6406
6407 if (mkdir (induction_directory, 0700) == -1)
6408 {
6409 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6410
6411 return (-1);
6412 }
6413 }
6414 }
6415 else
6416 {
6417 induction_directory = induction_dir;
6418 }
6419 }
6420
6421 data.induction_directory = induction_directory;
6422
6423 /**
6424 * loopback
6425 */
6426
6427 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6428
6429 char *loopback_file = (char *) mymalloc (loopback_size);
6430
6431 /**
6432 * tuning db
6433 */
6434
6435 char tuning_db_file[256] = { 0 };
6436
6437 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6438
6439 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6440
6441 /**
6442 * outfile-check directory
6443 */
6444
6445 char *outfile_check_directory = NULL;
6446
6447 if (outfile_check_dir == NULL)
6448 {
6449 outfile_check_directory = (char *) mymalloc (session_size);
6450
6451 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6452 }
6453 else
6454 {
6455 outfile_check_directory = outfile_check_dir;
6456 }
6457
6458 data.outfile_check_directory = outfile_check_directory;
6459
6460 if (keyspace == 0)
6461 {
6462 struct stat outfile_check_stat;
6463
6464 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6465 {
6466 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6467
6468 if (is_dir == 0)
6469 {
6470 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6471
6472 return (-1);
6473 }
6474 }
6475 else if (outfile_check_dir == NULL)
6476 {
6477 if (mkdir (outfile_check_directory, 0700) == -1)
6478 {
6479 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6480
6481 return (-1);
6482 }
6483 }
6484 }
6485
6486 /**
6487 * special other stuff
6488 */
6489
6490 if (hash_mode == 9710)
6491 {
6492 outfile_format = 5;
6493 outfile_format_chgd = 1;
6494 }
6495
6496 if (hash_mode == 9810)
6497 {
6498 outfile_format = 5;
6499 outfile_format_chgd = 1;
6500 }
6501
6502 if (hash_mode == 10410)
6503 {
6504 outfile_format = 5;
6505 outfile_format_chgd = 1;
6506 }
6507
6508 /**
6509 * store stuff
6510 */
6511
6512 data.hash_mode = hash_mode;
6513 data.restore = restore;
6514 data.restore_timer = restore_timer;
6515 data.restore_disable = restore_disable;
6516 data.status = status;
6517 data.status_timer = status_timer;
6518 data.status_automat = status_automat;
6519 data.loopback = loopback;
6520 data.runtime = runtime;
6521 data.remove = remove;
6522 data.remove_timer = remove_timer;
6523 data.debug_mode = debug_mode;
6524 data.debug_file = debug_file;
6525 data.username = username;
6526 data.quiet = quiet;
6527 data.outfile = outfile;
6528 data.outfile_format = outfile_format;
6529 data.outfile_autohex = outfile_autohex;
6530 data.hex_charset = hex_charset;
6531 data.hex_salt = hex_salt;
6532 data.hex_wordlist = hex_wordlist;
6533 data.separator = separator;
6534 data.rp_files = rp_files;
6535 data.rp_files_cnt = rp_files_cnt;
6536 data.rp_gen = rp_gen;
6537 data.rp_gen_seed = rp_gen_seed;
6538 data.force = force;
6539 data.benchmark = benchmark;
6540 data.skip = skip;
6541 data.limit = limit;
6542 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6543 data.powertune_enable = powertune_enable;
6544 #endif
6545 data.logfile_disable = logfile_disable;
6546 data.truecrypt_keyfiles = truecrypt_keyfiles;
6547 data.veracrypt_keyfiles = veracrypt_keyfiles;
6548 data.veracrypt_pim = veracrypt_pim;
6549 data.scrypt_tmto = scrypt_tmto;
6550 data.workload_profile = workload_profile;
6551
6552 /**
6553 * cpu affinity
6554 */
6555
6556 if (cpu_affinity)
6557 {
6558 set_cpu_affinity (cpu_affinity);
6559 }
6560
6561 if (rp_gen_seed_chgd == 0)
6562 {
6563 srand (proc_start);
6564 }
6565 else
6566 {
6567 srand (rp_gen_seed);
6568 }
6569
6570 /**
6571 * logfile init
6572 */
6573
6574 if (logfile_disable == 0)
6575 {
6576 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6577
6578 char *logfile = (char *) mymalloc (logfile_size);
6579
6580 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6581
6582 data.logfile = logfile;
6583
6584 char *topid = logfile_generate_topid ();
6585
6586 data.topid = topid;
6587 }
6588
6589 // logfile_append() checks for logfile_disable internally to make it easier from here
6590
6591 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6592 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6593 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6594 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6595 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6596 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6597 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6598 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6599 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6600 #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));
6601
6602 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6603 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6604 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6605 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6606 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6607 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6608 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6609 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6610
6611 logfile_top_msg ("START");
6612
6613 logfile_top_uint (attack_mode);
6614 logfile_top_uint (attack_kern);
6615 logfile_top_uint (benchmark);
6616 logfile_top_uint (bitmap_min);
6617 logfile_top_uint (bitmap_max);
6618 logfile_top_uint (debug_mode);
6619 logfile_top_uint (force);
6620 logfile_top_uint (kernel_accel);
6621 logfile_top_uint (kernel_loops);
6622 logfile_top_uint (gpu_temp_disable);
6623 #ifdef HAVE_HWMON
6624 logfile_top_uint (gpu_temp_abort);
6625 logfile_top_uint (gpu_temp_retain);
6626 #endif
6627 logfile_top_uint (hash_mode);
6628 logfile_top_uint (hex_charset);
6629 logfile_top_uint (hex_salt);
6630 logfile_top_uint (hex_wordlist);
6631 logfile_top_uint (increment);
6632 logfile_top_uint (increment_max);
6633 logfile_top_uint (increment_min);
6634 logfile_top_uint (keyspace);
6635 logfile_top_uint (left);
6636 logfile_top_uint (logfile_disable);
6637 logfile_top_uint (loopback);
6638 logfile_top_uint (markov_classic);
6639 logfile_top_uint (markov_disable);
6640 logfile_top_uint (markov_threshold);
6641 logfile_top_uint (outfile_autohex);
6642 logfile_top_uint (outfile_check_timer);
6643 logfile_top_uint (outfile_format);
6644 logfile_top_uint (potfile_disable);
6645 logfile_top_string (potfile_path);
6646 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6647 logfile_top_uint (powertune_enable);
6648 #endif
6649 logfile_top_uint (scrypt_tmto);
6650 logfile_top_uint (quiet);
6651 logfile_top_uint (remove);
6652 logfile_top_uint (remove_timer);
6653 logfile_top_uint (restore);
6654 logfile_top_uint (restore_disable);
6655 logfile_top_uint (restore_timer);
6656 logfile_top_uint (rp_gen);
6657 logfile_top_uint (rp_gen_func_max);
6658 logfile_top_uint (rp_gen_func_min);
6659 logfile_top_uint (rp_gen_seed);
6660 logfile_top_uint (runtime);
6661 logfile_top_uint (segment_size);
6662 logfile_top_uint (show);
6663 logfile_top_uint (status);
6664 logfile_top_uint (status_automat);
6665 logfile_top_uint (status_timer);
6666 logfile_top_uint (usage);
6667 logfile_top_uint (username);
6668 logfile_top_uint (version);
6669 logfile_top_uint (weak_hash_threshold);
6670 logfile_top_uint (workload_profile);
6671 logfile_top_uint64 (limit);
6672 logfile_top_uint64 (skip);
6673 logfile_top_char (separator);
6674 logfile_top_string (cpu_affinity);
6675 logfile_top_string (custom_charset_1);
6676 logfile_top_string (custom_charset_2);
6677 logfile_top_string (custom_charset_3);
6678 logfile_top_string (custom_charset_4);
6679 logfile_top_string (debug_file);
6680 logfile_top_string (opencl_devices);
6681 logfile_top_string (opencl_platforms);
6682 logfile_top_string (opencl_device_types);
6683 logfile_top_uint (opencl_vector_width);
6684 logfile_top_string (induction_dir);
6685 logfile_top_string (markov_hcstat);
6686 logfile_top_string (outfile);
6687 logfile_top_string (outfile_check_dir);
6688 logfile_top_string (rule_buf_l);
6689 logfile_top_string (rule_buf_r);
6690 logfile_top_string (session);
6691 logfile_top_string (truecrypt_keyfiles);
6692 logfile_top_string (veracrypt_keyfiles);
6693 logfile_top_uint (veracrypt_pim);
6694
6695 /**
6696 * Init OpenCL library loader
6697 */
6698
6699 if (keyspace == 0)
6700 {
6701 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6702
6703 ocl_init (ocl);
6704
6705 data.ocl = ocl;
6706 }
6707
6708 /**
6709 * OpenCL platform selection
6710 */
6711
6712 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6713
6714 /**
6715 * OpenCL device selection
6716 */
6717
6718 u32 devices_filter = setup_devices_filter (opencl_devices);
6719
6720 /**
6721 * OpenCL device type selection
6722 */
6723
6724 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6725
6726 /**
6727 * benchmark
6728 */
6729
6730 if (benchmark == 1)
6731 {
6732 /**
6733 * disable useless stuff for benchmark
6734 */
6735
6736 status_timer = 0;
6737 restore_timer = 0;
6738 restore_disable = 1;
6739 potfile_disable = 1;
6740 weak_hash_threshold = 0;
6741 gpu_temp_disable = 1;
6742
6743 data.status_timer = status_timer;
6744 data.restore_timer = restore_timer;
6745 data.restore_disable = restore_disable;
6746
6747 /**
6748 * force attack mode to be bruteforce
6749 */
6750
6751 attack_mode = ATTACK_MODE_BF;
6752 attack_kern = ATTACK_KERN_BF;
6753
6754 if (workload_profile_chgd == 0)
6755 {
6756 workload_profile = 3;
6757
6758 data.workload_profile = workload_profile;
6759 }
6760 }
6761
6762 /**
6763 * config
6764 */
6765
6766 uint hash_type = 0;
6767 uint salt_type = 0;
6768 uint attack_exec = 0;
6769 uint opts_type = 0;
6770 uint kern_type = 0;
6771 uint dgst_size = 0;
6772 uint esalt_size = 0;
6773 uint opti_type = 0;
6774 uint dgst_pos0 = -1;
6775 uint dgst_pos1 = -1;
6776 uint dgst_pos2 = -1;
6777 uint dgst_pos3 = -1;
6778
6779 int (*parse_func) (char *, uint, hash_t *);
6780 int (*sort_by_digest) (const void *, const void *);
6781
6782 uint algorithm_pos = 0;
6783 uint algorithm_max = 1;
6784
6785 uint *algorithms = default_benchmark_algorithms;
6786
6787 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6788
6789 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6790 {
6791 /*
6792 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6793 * the following algos are skipped entirely
6794 */
6795
6796 if (algorithm_pos > 0)
6797 {
6798 local_free (rd);
6799
6800 rd = init_restore (argc, argv);
6801
6802 data.rd = rd;
6803 }
6804
6805 /**
6806 * update hash_mode in case of multihash benchmark
6807 */
6808
6809 if (benchmark == 1)
6810 {
6811 if (hash_mode_chgd == 0)
6812 {
6813 hash_mode = algorithms[algorithm_pos];
6814
6815 data.hash_mode = hash_mode;
6816 }
6817
6818 quiet = 1;
6819
6820 data.quiet = quiet;
6821 }
6822
6823 switch (hash_mode)
6824 {
6825 case 0: hash_type = HASH_TYPE_MD5;
6826 salt_type = SALT_TYPE_NONE;
6827 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6828 opts_type = OPTS_TYPE_PT_GENERATE_LE
6829 | OPTS_TYPE_PT_ADD80
6830 | OPTS_TYPE_PT_ADDBITS14;
6831 kern_type = KERN_TYPE_MD5;
6832 dgst_size = DGST_SIZE_4_4;
6833 parse_func = md5_parse_hash;
6834 sort_by_digest = sort_by_digest_4_4;
6835 opti_type = OPTI_TYPE_ZERO_BYTE
6836 | OPTI_TYPE_PRECOMPUTE_INIT
6837 | OPTI_TYPE_PRECOMPUTE_MERKLE
6838 | OPTI_TYPE_MEET_IN_MIDDLE
6839 | OPTI_TYPE_EARLY_SKIP
6840 | OPTI_TYPE_NOT_ITERATED
6841 | OPTI_TYPE_NOT_SALTED
6842 | OPTI_TYPE_RAW_HASH;
6843 dgst_pos0 = 0;
6844 dgst_pos1 = 3;
6845 dgst_pos2 = 2;
6846 dgst_pos3 = 1;
6847 break;
6848
6849 case 10: hash_type = HASH_TYPE_MD5;
6850 salt_type = SALT_TYPE_INTERN;
6851 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6852 opts_type = OPTS_TYPE_PT_GENERATE_LE
6853 | OPTS_TYPE_ST_ADD80
6854 | OPTS_TYPE_ST_ADDBITS14;
6855 kern_type = KERN_TYPE_MD5_PWSLT;
6856 dgst_size = DGST_SIZE_4_4;
6857 parse_func = md5s_parse_hash;
6858 sort_by_digest = sort_by_digest_4_4;
6859 opti_type = OPTI_TYPE_ZERO_BYTE
6860 | OPTI_TYPE_PRECOMPUTE_INIT
6861 | OPTI_TYPE_PRECOMPUTE_MERKLE
6862 | OPTI_TYPE_MEET_IN_MIDDLE
6863 | OPTI_TYPE_EARLY_SKIP
6864 | OPTI_TYPE_NOT_ITERATED
6865 | OPTI_TYPE_APPENDED_SALT
6866 | OPTI_TYPE_RAW_HASH;
6867 dgst_pos0 = 0;
6868 dgst_pos1 = 3;
6869 dgst_pos2 = 2;
6870 dgst_pos3 = 1;
6871 break;
6872
6873 case 11: hash_type = HASH_TYPE_MD5;
6874 salt_type = SALT_TYPE_INTERN;
6875 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6876 opts_type = OPTS_TYPE_PT_GENERATE_LE
6877 | OPTS_TYPE_ST_ADD80
6878 | OPTS_TYPE_ST_ADDBITS14;
6879 kern_type = KERN_TYPE_MD5_PWSLT;
6880 dgst_size = DGST_SIZE_4_4;
6881 parse_func = joomla_parse_hash;
6882 sort_by_digest = sort_by_digest_4_4;
6883 opti_type = OPTI_TYPE_ZERO_BYTE
6884 | OPTI_TYPE_PRECOMPUTE_INIT
6885 | OPTI_TYPE_PRECOMPUTE_MERKLE
6886 | OPTI_TYPE_MEET_IN_MIDDLE
6887 | OPTI_TYPE_EARLY_SKIP
6888 | OPTI_TYPE_NOT_ITERATED
6889 | OPTI_TYPE_APPENDED_SALT
6890 | OPTI_TYPE_RAW_HASH;
6891 dgst_pos0 = 0;
6892 dgst_pos1 = 3;
6893 dgst_pos2 = 2;
6894 dgst_pos3 = 1;
6895 break;
6896
6897 case 12: hash_type = HASH_TYPE_MD5;
6898 salt_type = SALT_TYPE_INTERN;
6899 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6900 opts_type = OPTS_TYPE_PT_GENERATE_LE
6901 | OPTS_TYPE_ST_ADD80
6902 | OPTS_TYPE_ST_ADDBITS14;
6903 kern_type = KERN_TYPE_MD5_PWSLT;
6904 dgst_size = DGST_SIZE_4_4;
6905 parse_func = postgresql_parse_hash;
6906 sort_by_digest = sort_by_digest_4_4;
6907 opti_type = OPTI_TYPE_ZERO_BYTE
6908 | OPTI_TYPE_PRECOMPUTE_INIT
6909 | OPTI_TYPE_PRECOMPUTE_MERKLE
6910 | OPTI_TYPE_MEET_IN_MIDDLE
6911 | OPTI_TYPE_EARLY_SKIP
6912 | OPTI_TYPE_NOT_ITERATED
6913 | OPTI_TYPE_APPENDED_SALT
6914 | OPTI_TYPE_RAW_HASH;
6915 dgst_pos0 = 0;
6916 dgst_pos1 = 3;
6917 dgst_pos2 = 2;
6918 dgst_pos3 = 1;
6919 break;
6920
6921 case 20: hash_type = HASH_TYPE_MD5;
6922 salt_type = SALT_TYPE_INTERN;
6923 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6924 opts_type = OPTS_TYPE_PT_GENERATE_LE
6925 | OPTS_TYPE_PT_ADD80
6926 | OPTS_TYPE_PT_ADDBITS14;
6927 kern_type = KERN_TYPE_MD5_SLTPW;
6928 dgst_size = DGST_SIZE_4_4;
6929 parse_func = md5s_parse_hash;
6930 sort_by_digest = sort_by_digest_4_4;
6931 opti_type = OPTI_TYPE_ZERO_BYTE
6932 | OPTI_TYPE_PRECOMPUTE_INIT
6933 | OPTI_TYPE_PRECOMPUTE_MERKLE
6934 | OPTI_TYPE_EARLY_SKIP
6935 | OPTI_TYPE_NOT_ITERATED
6936 | OPTI_TYPE_PREPENDED_SALT
6937 | OPTI_TYPE_RAW_HASH;
6938 dgst_pos0 = 0;
6939 dgst_pos1 = 3;
6940 dgst_pos2 = 2;
6941 dgst_pos3 = 1;
6942 break;
6943
6944 case 21: hash_type = HASH_TYPE_MD5;
6945 salt_type = SALT_TYPE_INTERN;
6946 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6947 opts_type = OPTS_TYPE_PT_GENERATE_LE
6948 | OPTS_TYPE_PT_ADD80
6949 | OPTS_TYPE_PT_ADDBITS14;
6950 kern_type = KERN_TYPE_MD5_SLTPW;
6951 dgst_size = DGST_SIZE_4_4;
6952 parse_func = osc_parse_hash;
6953 sort_by_digest = sort_by_digest_4_4;
6954 opti_type = OPTI_TYPE_ZERO_BYTE
6955 | OPTI_TYPE_PRECOMPUTE_INIT
6956 | OPTI_TYPE_PRECOMPUTE_MERKLE
6957 | OPTI_TYPE_EARLY_SKIP
6958 | OPTI_TYPE_NOT_ITERATED
6959 | OPTI_TYPE_PREPENDED_SALT
6960 | OPTI_TYPE_RAW_HASH;
6961 dgst_pos0 = 0;
6962 dgst_pos1 = 3;
6963 dgst_pos2 = 2;
6964 dgst_pos3 = 1;
6965 break;
6966
6967 case 22: hash_type = HASH_TYPE_MD5;
6968 salt_type = SALT_TYPE_EMBEDDED;
6969 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6970 opts_type = OPTS_TYPE_PT_GENERATE_LE
6971 | OPTS_TYPE_PT_ADD80
6972 | OPTS_TYPE_PT_ADDBITS14;
6973 kern_type = KERN_TYPE_MD5_SLTPW;
6974 dgst_size = DGST_SIZE_4_4;
6975 parse_func = netscreen_parse_hash;
6976 sort_by_digest = sort_by_digest_4_4;
6977 opti_type = OPTI_TYPE_ZERO_BYTE
6978 | OPTI_TYPE_PRECOMPUTE_INIT
6979 | OPTI_TYPE_PRECOMPUTE_MERKLE
6980 | OPTI_TYPE_EARLY_SKIP
6981 | OPTI_TYPE_NOT_ITERATED
6982 | OPTI_TYPE_PREPENDED_SALT
6983 | OPTI_TYPE_RAW_HASH;
6984 dgst_pos0 = 0;
6985 dgst_pos1 = 3;
6986 dgst_pos2 = 2;
6987 dgst_pos3 = 1;
6988 break;
6989
6990 case 23: hash_type = HASH_TYPE_MD5;
6991 salt_type = SALT_TYPE_EMBEDDED;
6992 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6993 opts_type = OPTS_TYPE_PT_GENERATE_LE
6994 | OPTS_TYPE_PT_ADD80
6995 | OPTS_TYPE_PT_ADDBITS14;
6996 kern_type = KERN_TYPE_MD5_SLTPW;
6997 dgst_size = DGST_SIZE_4_4;
6998 parse_func = skype_parse_hash;
6999 sort_by_digest = sort_by_digest_4_4;
7000 opti_type = OPTI_TYPE_ZERO_BYTE
7001 | OPTI_TYPE_PRECOMPUTE_INIT
7002 | OPTI_TYPE_PRECOMPUTE_MERKLE
7003 | OPTI_TYPE_EARLY_SKIP
7004 | OPTI_TYPE_NOT_ITERATED
7005 | OPTI_TYPE_PREPENDED_SALT
7006 | OPTI_TYPE_RAW_HASH;
7007 dgst_pos0 = 0;
7008 dgst_pos1 = 3;
7009 dgst_pos2 = 2;
7010 dgst_pos3 = 1;
7011 break;
7012
7013 case 30: hash_type = HASH_TYPE_MD5;
7014 salt_type = SALT_TYPE_INTERN;
7015 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7016 opts_type = OPTS_TYPE_PT_GENERATE_LE
7017 | OPTS_TYPE_PT_UNICODE
7018 | OPTS_TYPE_ST_ADD80
7019 | OPTS_TYPE_ST_ADDBITS14;
7020 kern_type = KERN_TYPE_MD5_PWUSLT;
7021 dgst_size = DGST_SIZE_4_4;
7022 parse_func = md5s_parse_hash;
7023 sort_by_digest = sort_by_digest_4_4;
7024 opti_type = OPTI_TYPE_ZERO_BYTE
7025 | OPTI_TYPE_PRECOMPUTE_INIT
7026 | OPTI_TYPE_PRECOMPUTE_MERKLE
7027 | OPTI_TYPE_MEET_IN_MIDDLE
7028 | OPTI_TYPE_EARLY_SKIP
7029 | OPTI_TYPE_NOT_ITERATED
7030 | OPTI_TYPE_APPENDED_SALT
7031 | OPTI_TYPE_RAW_HASH;
7032 dgst_pos0 = 0;
7033 dgst_pos1 = 3;
7034 dgst_pos2 = 2;
7035 dgst_pos3 = 1;
7036 break;
7037
7038 case 40: hash_type = HASH_TYPE_MD5;
7039 salt_type = SALT_TYPE_INTERN;
7040 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7041 opts_type = OPTS_TYPE_PT_GENERATE_LE
7042 | OPTS_TYPE_PT_ADD80
7043 | OPTS_TYPE_PT_ADDBITS14
7044 | OPTS_TYPE_PT_UNICODE;
7045 kern_type = KERN_TYPE_MD5_SLTPWU;
7046 dgst_size = DGST_SIZE_4_4;
7047 parse_func = md5s_parse_hash;
7048 sort_by_digest = sort_by_digest_4_4;
7049 opti_type = OPTI_TYPE_ZERO_BYTE
7050 | OPTI_TYPE_PRECOMPUTE_INIT
7051 | OPTI_TYPE_PRECOMPUTE_MERKLE
7052 | OPTI_TYPE_EARLY_SKIP
7053 | OPTI_TYPE_NOT_ITERATED
7054 | OPTI_TYPE_PREPENDED_SALT
7055 | OPTI_TYPE_RAW_HASH;
7056 dgst_pos0 = 0;
7057 dgst_pos1 = 3;
7058 dgst_pos2 = 2;
7059 dgst_pos3 = 1;
7060 break;
7061
7062 case 50: hash_type = HASH_TYPE_MD5;
7063 salt_type = SALT_TYPE_INTERN;
7064 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7065 opts_type = OPTS_TYPE_PT_GENERATE_LE
7066 | OPTS_TYPE_ST_ADD80
7067 | OPTS_TYPE_ST_ADDBITS14;
7068 kern_type = KERN_TYPE_HMACMD5_PW;
7069 dgst_size = DGST_SIZE_4_4;
7070 parse_func = hmacmd5_parse_hash;
7071 sort_by_digest = sort_by_digest_4_4;
7072 opti_type = OPTI_TYPE_ZERO_BYTE
7073 | OPTI_TYPE_NOT_ITERATED;
7074 dgst_pos0 = 0;
7075 dgst_pos1 = 3;
7076 dgst_pos2 = 2;
7077 dgst_pos3 = 1;
7078 break;
7079
7080 case 60: hash_type = HASH_TYPE_MD5;
7081 salt_type = SALT_TYPE_INTERN;
7082 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7083 opts_type = OPTS_TYPE_PT_GENERATE_LE
7084 | OPTS_TYPE_PT_ADD80
7085 | OPTS_TYPE_PT_ADDBITS14;
7086 kern_type = KERN_TYPE_HMACMD5_SLT;
7087 dgst_size = DGST_SIZE_4_4;
7088 parse_func = hmacmd5_parse_hash;
7089 sort_by_digest = sort_by_digest_4_4;
7090 opti_type = OPTI_TYPE_ZERO_BYTE
7091 | OPTI_TYPE_NOT_ITERATED;
7092 dgst_pos0 = 0;
7093 dgst_pos1 = 3;
7094 dgst_pos2 = 2;
7095 dgst_pos3 = 1;
7096 break;
7097
7098 case 100: hash_type = HASH_TYPE_SHA1;
7099 salt_type = SALT_TYPE_NONE;
7100 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7101 opts_type = OPTS_TYPE_PT_GENERATE_BE
7102 | OPTS_TYPE_PT_ADD80
7103 | OPTS_TYPE_PT_ADDBITS15;
7104 kern_type = KERN_TYPE_SHA1;
7105 dgst_size = DGST_SIZE_4_5;
7106 parse_func = sha1_parse_hash;
7107 sort_by_digest = sort_by_digest_4_5;
7108 opti_type = OPTI_TYPE_ZERO_BYTE
7109 | OPTI_TYPE_PRECOMPUTE_INIT
7110 | OPTI_TYPE_PRECOMPUTE_MERKLE
7111 | OPTI_TYPE_EARLY_SKIP
7112 | OPTI_TYPE_NOT_ITERATED
7113 | OPTI_TYPE_NOT_SALTED
7114 | OPTI_TYPE_RAW_HASH;
7115 dgst_pos0 = 3;
7116 dgst_pos1 = 4;
7117 dgst_pos2 = 2;
7118 dgst_pos3 = 1;
7119 break;
7120
7121 case 101: hash_type = HASH_TYPE_SHA1;
7122 salt_type = SALT_TYPE_NONE;
7123 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7124 opts_type = OPTS_TYPE_PT_GENERATE_BE
7125 | OPTS_TYPE_PT_ADD80
7126 | OPTS_TYPE_PT_ADDBITS15;
7127 kern_type = KERN_TYPE_SHA1;
7128 dgst_size = DGST_SIZE_4_5;
7129 parse_func = sha1b64_parse_hash;
7130 sort_by_digest = sort_by_digest_4_5;
7131 opti_type = OPTI_TYPE_ZERO_BYTE
7132 | OPTI_TYPE_PRECOMPUTE_INIT
7133 | OPTI_TYPE_PRECOMPUTE_MERKLE
7134 | OPTI_TYPE_EARLY_SKIP
7135 | OPTI_TYPE_NOT_ITERATED
7136 | OPTI_TYPE_NOT_SALTED
7137 | OPTI_TYPE_RAW_HASH;
7138 dgst_pos0 = 3;
7139 dgst_pos1 = 4;
7140 dgst_pos2 = 2;
7141 dgst_pos3 = 1;
7142 break;
7143
7144 case 110: hash_type = HASH_TYPE_SHA1;
7145 salt_type = SALT_TYPE_INTERN;
7146 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7147 opts_type = OPTS_TYPE_PT_GENERATE_BE
7148 | OPTS_TYPE_ST_ADD80
7149 | OPTS_TYPE_ST_ADDBITS15;
7150 kern_type = KERN_TYPE_SHA1_PWSLT;
7151 dgst_size = DGST_SIZE_4_5;
7152 parse_func = sha1s_parse_hash;
7153 sort_by_digest = sort_by_digest_4_5;
7154 opti_type = OPTI_TYPE_ZERO_BYTE
7155 | OPTI_TYPE_PRECOMPUTE_INIT
7156 | OPTI_TYPE_PRECOMPUTE_MERKLE
7157 | OPTI_TYPE_EARLY_SKIP
7158 | OPTI_TYPE_NOT_ITERATED
7159 | OPTI_TYPE_APPENDED_SALT
7160 | OPTI_TYPE_RAW_HASH;
7161 dgst_pos0 = 3;
7162 dgst_pos1 = 4;
7163 dgst_pos2 = 2;
7164 dgst_pos3 = 1;
7165 break;
7166
7167 case 111: hash_type = HASH_TYPE_SHA1;
7168 salt_type = SALT_TYPE_EMBEDDED;
7169 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7170 opts_type = OPTS_TYPE_PT_GENERATE_BE
7171 | OPTS_TYPE_ST_ADD80
7172 | OPTS_TYPE_ST_ADDBITS15;
7173 kern_type = KERN_TYPE_SHA1_PWSLT;
7174 dgst_size = DGST_SIZE_4_5;
7175 parse_func = sha1b64s_parse_hash;
7176 sort_by_digest = sort_by_digest_4_5;
7177 opti_type = OPTI_TYPE_ZERO_BYTE
7178 | OPTI_TYPE_PRECOMPUTE_INIT
7179 | OPTI_TYPE_PRECOMPUTE_MERKLE
7180 | OPTI_TYPE_EARLY_SKIP
7181 | OPTI_TYPE_NOT_ITERATED
7182 | OPTI_TYPE_APPENDED_SALT
7183 | OPTI_TYPE_RAW_HASH;
7184 dgst_pos0 = 3;
7185 dgst_pos1 = 4;
7186 dgst_pos2 = 2;
7187 dgst_pos3 = 1;
7188 break;
7189
7190 case 112: hash_type = HASH_TYPE_SHA1;
7191 salt_type = SALT_TYPE_INTERN;
7192 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7193 opts_type = OPTS_TYPE_PT_GENERATE_BE
7194 | OPTS_TYPE_ST_ADD80
7195 | OPTS_TYPE_ST_ADDBITS15
7196 | OPTS_TYPE_ST_HEX;
7197 kern_type = KERN_TYPE_SHA1_PWSLT;
7198 dgst_size = DGST_SIZE_4_5;
7199 parse_func = oracles_parse_hash;
7200 sort_by_digest = sort_by_digest_4_5;
7201 opti_type = OPTI_TYPE_ZERO_BYTE
7202 | OPTI_TYPE_PRECOMPUTE_INIT
7203 | OPTI_TYPE_PRECOMPUTE_MERKLE
7204 | OPTI_TYPE_EARLY_SKIP
7205 | OPTI_TYPE_NOT_ITERATED
7206 | OPTI_TYPE_APPENDED_SALT
7207 | OPTI_TYPE_RAW_HASH;
7208 dgst_pos0 = 3;
7209 dgst_pos1 = 4;
7210 dgst_pos2 = 2;
7211 dgst_pos3 = 1;
7212 break;
7213
7214 case 120: hash_type = HASH_TYPE_SHA1;
7215 salt_type = SALT_TYPE_INTERN;
7216 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7217 opts_type = OPTS_TYPE_PT_GENERATE_BE
7218 | OPTS_TYPE_PT_ADD80
7219 | OPTS_TYPE_PT_ADDBITS15;
7220 kern_type = KERN_TYPE_SHA1_SLTPW;
7221 dgst_size = DGST_SIZE_4_5;
7222 parse_func = sha1s_parse_hash;
7223 sort_by_digest = sort_by_digest_4_5;
7224 opti_type = OPTI_TYPE_ZERO_BYTE
7225 | OPTI_TYPE_PRECOMPUTE_INIT
7226 | OPTI_TYPE_PRECOMPUTE_MERKLE
7227 | OPTI_TYPE_EARLY_SKIP
7228 | OPTI_TYPE_NOT_ITERATED
7229 | OPTI_TYPE_PREPENDED_SALT
7230 | OPTI_TYPE_RAW_HASH;
7231 dgst_pos0 = 3;
7232 dgst_pos1 = 4;
7233 dgst_pos2 = 2;
7234 dgst_pos3 = 1;
7235 break;
7236
7237 case 121: hash_type = HASH_TYPE_SHA1;
7238 salt_type = SALT_TYPE_INTERN;
7239 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7240 opts_type = OPTS_TYPE_PT_GENERATE_BE
7241 | OPTS_TYPE_PT_ADD80
7242 | OPTS_TYPE_PT_ADDBITS15
7243 | OPTS_TYPE_ST_LOWER;
7244 kern_type = KERN_TYPE_SHA1_SLTPW;
7245 dgst_size = DGST_SIZE_4_5;
7246 parse_func = smf_parse_hash;
7247 sort_by_digest = sort_by_digest_4_5;
7248 opti_type = OPTI_TYPE_ZERO_BYTE
7249 | OPTI_TYPE_PRECOMPUTE_INIT
7250 | OPTI_TYPE_PRECOMPUTE_MERKLE
7251 | OPTI_TYPE_EARLY_SKIP
7252 | OPTI_TYPE_NOT_ITERATED
7253 | OPTI_TYPE_PREPENDED_SALT
7254 | OPTI_TYPE_RAW_HASH;
7255 dgst_pos0 = 3;
7256 dgst_pos1 = 4;
7257 dgst_pos2 = 2;
7258 dgst_pos3 = 1;
7259 break;
7260
7261 case 122: hash_type = HASH_TYPE_SHA1;
7262 salt_type = SALT_TYPE_EMBEDDED;
7263 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7264 opts_type = OPTS_TYPE_PT_GENERATE_BE
7265 | OPTS_TYPE_PT_ADD80
7266 | OPTS_TYPE_PT_ADDBITS15
7267 | OPTS_TYPE_ST_HEX;
7268 kern_type = KERN_TYPE_SHA1_SLTPW;
7269 dgst_size = DGST_SIZE_4_5;
7270 parse_func = osx1_parse_hash;
7271 sort_by_digest = sort_by_digest_4_5;
7272 opti_type = OPTI_TYPE_ZERO_BYTE
7273 | OPTI_TYPE_PRECOMPUTE_INIT
7274 | OPTI_TYPE_PRECOMPUTE_MERKLE
7275 | OPTI_TYPE_EARLY_SKIP
7276 | OPTI_TYPE_NOT_ITERATED
7277 | OPTI_TYPE_PREPENDED_SALT
7278 | OPTI_TYPE_RAW_HASH;
7279 dgst_pos0 = 3;
7280 dgst_pos1 = 4;
7281 dgst_pos2 = 2;
7282 dgst_pos3 = 1;
7283 break;
7284
7285 case 124: hash_type = HASH_TYPE_SHA1;
7286 salt_type = SALT_TYPE_EMBEDDED;
7287 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7288 opts_type = OPTS_TYPE_PT_GENERATE_BE
7289 | OPTS_TYPE_PT_ADD80
7290 | OPTS_TYPE_PT_ADDBITS15;
7291 kern_type = KERN_TYPE_SHA1_SLTPW;
7292 dgst_size = DGST_SIZE_4_5;
7293 parse_func = djangosha1_parse_hash;
7294 sort_by_digest = sort_by_digest_4_5;
7295 opti_type = OPTI_TYPE_ZERO_BYTE
7296 | OPTI_TYPE_PRECOMPUTE_INIT
7297 | OPTI_TYPE_PRECOMPUTE_MERKLE
7298 | OPTI_TYPE_EARLY_SKIP
7299 | OPTI_TYPE_NOT_ITERATED
7300 | OPTI_TYPE_PREPENDED_SALT
7301 | OPTI_TYPE_RAW_HASH;
7302 dgst_pos0 = 3;
7303 dgst_pos1 = 4;
7304 dgst_pos2 = 2;
7305 dgst_pos3 = 1;
7306 break;
7307
7308 case 125: hash_type = HASH_TYPE_SHA1;
7309 salt_type = SALT_TYPE_EMBEDDED;
7310 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7311 opts_type = OPTS_TYPE_PT_GENERATE_BE
7312 | OPTS_TYPE_PT_ADD80
7313 | OPTS_TYPE_PT_ADDBITS15
7314 | OPTS_TYPE_ST_HEX;
7315 kern_type = KERN_TYPE_SHA1_SLTPW;
7316 dgst_size = DGST_SIZE_4_5;
7317 parse_func = arubaos_parse_hash;
7318 sort_by_digest = sort_by_digest_4_5;
7319 opti_type = OPTI_TYPE_ZERO_BYTE
7320 | OPTI_TYPE_PRECOMPUTE_INIT
7321 | OPTI_TYPE_PRECOMPUTE_MERKLE
7322 | OPTI_TYPE_EARLY_SKIP
7323 | OPTI_TYPE_NOT_ITERATED
7324 | OPTI_TYPE_PREPENDED_SALT
7325 | OPTI_TYPE_RAW_HASH;
7326 dgst_pos0 = 3;
7327 dgst_pos1 = 4;
7328 dgst_pos2 = 2;
7329 dgst_pos3 = 1;
7330 break;
7331
7332 case 130: hash_type = HASH_TYPE_SHA1;
7333 salt_type = SALT_TYPE_INTERN;
7334 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7335 opts_type = OPTS_TYPE_PT_GENERATE_BE
7336 | OPTS_TYPE_PT_UNICODE
7337 | OPTS_TYPE_ST_ADD80
7338 | OPTS_TYPE_ST_ADDBITS15;
7339 kern_type = KERN_TYPE_SHA1_PWUSLT;
7340 dgst_size = DGST_SIZE_4_5;
7341 parse_func = sha1s_parse_hash;
7342 sort_by_digest = sort_by_digest_4_5;
7343 opti_type = OPTI_TYPE_ZERO_BYTE
7344 | OPTI_TYPE_PRECOMPUTE_INIT
7345 | OPTI_TYPE_PRECOMPUTE_MERKLE
7346 | OPTI_TYPE_EARLY_SKIP
7347 | OPTI_TYPE_NOT_ITERATED
7348 | OPTI_TYPE_APPENDED_SALT
7349 | OPTI_TYPE_RAW_HASH;
7350 dgst_pos0 = 3;
7351 dgst_pos1 = 4;
7352 dgst_pos2 = 2;
7353 dgst_pos3 = 1;
7354 break;
7355
7356 case 131: hash_type = HASH_TYPE_SHA1;
7357 salt_type = SALT_TYPE_EMBEDDED;
7358 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7359 opts_type = OPTS_TYPE_PT_GENERATE_BE
7360 | OPTS_TYPE_PT_UNICODE
7361 | OPTS_TYPE_PT_UPPER
7362 | OPTS_TYPE_ST_ADD80
7363 | OPTS_TYPE_ST_ADDBITS15
7364 | OPTS_TYPE_ST_HEX;
7365 kern_type = KERN_TYPE_SHA1_PWUSLT;
7366 dgst_size = DGST_SIZE_4_5;
7367 parse_func = mssql2000_parse_hash;
7368 sort_by_digest = sort_by_digest_4_5;
7369 opti_type = OPTI_TYPE_ZERO_BYTE
7370 | OPTI_TYPE_PRECOMPUTE_INIT
7371 | OPTI_TYPE_PRECOMPUTE_MERKLE
7372 | OPTI_TYPE_EARLY_SKIP
7373 | OPTI_TYPE_NOT_ITERATED
7374 | OPTI_TYPE_APPENDED_SALT
7375 | OPTI_TYPE_RAW_HASH;
7376 dgst_pos0 = 3;
7377 dgst_pos1 = 4;
7378 dgst_pos2 = 2;
7379 dgst_pos3 = 1;
7380 break;
7381
7382 case 132: hash_type = HASH_TYPE_SHA1;
7383 salt_type = SALT_TYPE_EMBEDDED;
7384 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7385 opts_type = OPTS_TYPE_PT_GENERATE_BE
7386 | OPTS_TYPE_PT_UNICODE
7387 | OPTS_TYPE_ST_ADD80
7388 | OPTS_TYPE_ST_ADDBITS15
7389 | OPTS_TYPE_ST_HEX;
7390 kern_type = KERN_TYPE_SHA1_PWUSLT;
7391 dgst_size = DGST_SIZE_4_5;
7392 parse_func = mssql2005_parse_hash;
7393 sort_by_digest = sort_by_digest_4_5;
7394 opti_type = OPTI_TYPE_ZERO_BYTE
7395 | OPTI_TYPE_PRECOMPUTE_INIT
7396 | OPTI_TYPE_PRECOMPUTE_MERKLE
7397 | OPTI_TYPE_EARLY_SKIP
7398 | OPTI_TYPE_NOT_ITERATED
7399 | OPTI_TYPE_APPENDED_SALT
7400 | OPTI_TYPE_RAW_HASH;
7401 dgst_pos0 = 3;
7402 dgst_pos1 = 4;
7403 dgst_pos2 = 2;
7404 dgst_pos3 = 1;
7405 break;
7406
7407 case 133: hash_type = HASH_TYPE_SHA1;
7408 salt_type = SALT_TYPE_EMBEDDED;
7409 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7410 opts_type = OPTS_TYPE_PT_GENERATE_BE
7411 | OPTS_TYPE_PT_UNICODE
7412 | OPTS_TYPE_ST_ADD80
7413 | OPTS_TYPE_ST_ADDBITS15;
7414 kern_type = KERN_TYPE_SHA1_PWUSLT;
7415 dgst_size = DGST_SIZE_4_5;
7416 parse_func = peoplesoft_parse_hash;
7417 sort_by_digest = sort_by_digest_4_5;
7418 opti_type = OPTI_TYPE_ZERO_BYTE
7419 | OPTI_TYPE_PRECOMPUTE_INIT
7420 | OPTI_TYPE_PRECOMPUTE_MERKLE
7421 | OPTI_TYPE_EARLY_SKIP
7422 | OPTI_TYPE_NOT_ITERATED
7423 | OPTI_TYPE_APPENDED_SALT
7424 | OPTI_TYPE_RAW_HASH;
7425 dgst_pos0 = 3;
7426 dgst_pos1 = 4;
7427 dgst_pos2 = 2;
7428 dgst_pos3 = 1;
7429 break;
7430
7431 case 140: hash_type = HASH_TYPE_SHA1;
7432 salt_type = SALT_TYPE_INTERN;
7433 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7434 opts_type = OPTS_TYPE_PT_GENERATE_BE
7435 | OPTS_TYPE_PT_ADD80
7436 | OPTS_TYPE_PT_ADDBITS15
7437 | OPTS_TYPE_PT_UNICODE;
7438 kern_type = KERN_TYPE_SHA1_SLTPWU;
7439 dgst_size = DGST_SIZE_4_5;
7440 parse_func = sha1s_parse_hash;
7441 sort_by_digest = sort_by_digest_4_5;
7442 opti_type = OPTI_TYPE_ZERO_BYTE
7443 | OPTI_TYPE_PRECOMPUTE_INIT
7444 | OPTI_TYPE_PRECOMPUTE_MERKLE
7445 | OPTI_TYPE_EARLY_SKIP
7446 | OPTI_TYPE_NOT_ITERATED
7447 | OPTI_TYPE_PREPENDED_SALT
7448 | OPTI_TYPE_RAW_HASH;
7449 dgst_pos0 = 3;
7450 dgst_pos1 = 4;
7451 dgst_pos2 = 2;
7452 dgst_pos3 = 1;
7453 break;
7454
7455 case 141: hash_type = HASH_TYPE_SHA1;
7456 salt_type = SALT_TYPE_EMBEDDED;
7457 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7458 opts_type = OPTS_TYPE_PT_GENERATE_BE
7459 | OPTS_TYPE_PT_ADD80
7460 | OPTS_TYPE_PT_ADDBITS15
7461 | OPTS_TYPE_PT_UNICODE
7462 | OPTS_TYPE_ST_BASE64;
7463 kern_type = KERN_TYPE_SHA1_SLTPWU;
7464 dgst_size = DGST_SIZE_4_5;
7465 parse_func = episerver_parse_hash;
7466 sort_by_digest = sort_by_digest_4_5;
7467 opti_type = OPTI_TYPE_ZERO_BYTE
7468 | OPTI_TYPE_PRECOMPUTE_INIT
7469 | OPTI_TYPE_PRECOMPUTE_MERKLE
7470 | OPTI_TYPE_EARLY_SKIP
7471 | OPTI_TYPE_NOT_ITERATED
7472 | OPTI_TYPE_PREPENDED_SALT
7473 | OPTI_TYPE_RAW_HASH;
7474 dgst_pos0 = 3;
7475 dgst_pos1 = 4;
7476 dgst_pos2 = 2;
7477 dgst_pos3 = 1;
7478 break;
7479
7480 case 150: hash_type = HASH_TYPE_SHA1;
7481 salt_type = SALT_TYPE_INTERN;
7482 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7483 opts_type = OPTS_TYPE_PT_GENERATE_BE
7484 | OPTS_TYPE_ST_ADD80
7485 | OPTS_TYPE_ST_ADDBITS15;
7486 kern_type = KERN_TYPE_HMACSHA1_PW;
7487 dgst_size = DGST_SIZE_4_5;
7488 parse_func = hmacsha1_parse_hash;
7489 sort_by_digest = sort_by_digest_4_5;
7490 opti_type = OPTI_TYPE_ZERO_BYTE
7491 | OPTI_TYPE_NOT_ITERATED;
7492 dgst_pos0 = 3;
7493 dgst_pos1 = 4;
7494 dgst_pos2 = 2;
7495 dgst_pos3 = 1;
7496 break;
7497
7498 case 160: hash_type = HASH_TYPE_SHA1;
7499 salt_type = SALT_TYPE_INTERN;
7500 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7501 opts_type = OPTS_TYPE_PT_GENERATE_BE
7502 | OPTS_TYPE_PT_ADD80
7503 | OPTS_TYPE_PT_ADDBITS15;
7504 kern_type = KERN_TYPE_HMACSHA1_SLT;
7505 dgst_size = DGST_SIZE_4_5;
7506 parse_func = hmacsha1_parse_hash;
7507 sort_by_digest = sort_by_digest_4_5;
7508 opti_type = OPTI_TYPE_ZERO_BYTE
7509 | OPTI_TYPE_NOT_ITERATED;
7510 dgst_pos0 = 3;
7511 dgst_pos1 = 4;
7512 dgst_pos2 = 2;
7513 dgst_pos3 = 1;
7514 break;
7515
7516 case 190: hash_type = HASH_TYPE_SHA1;
7517 salt_type = SALT_TYPE_NONE;
7518 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7519 opts_type = OPTS_TYPE_PT_GENERATE_BE
7520 | OPTS_TYPE_PT_ADD80
7521 | OPTS_TYPE_PT_ADDBITS15;
7522 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7523 dgst_size = DGST_SIZE_4_5;
7524 parse_func = sha1linkedin_parse_hash;
7525 sort_by_digest = sort_by_digest_4_5;
7526 opti_type = OPTI_TYPE_ZERO_BYTE
7527 | OPTI_TYPE_PRECOMPUTE_INIT
7528 | OPTI_TYPE_EARLY_SKIP
7529 | OPTI_TYPE_NOT_ITERATED
7530 | OPTI_TYPE_NOT_SALTED;
7531 dgst_pos0 = 0;
7532 dgst_pos1 = 4;
7533 dgst_pos2 = 3;
7534 dgst_pos3 = 2;
7535 break;
7536
7537 case 200: hash_type = HASH_TYPE_MYSQL;
7538 salt_type = SALT_TYPE_NONE;
7539 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7540 opts_type = 0;
7541 kern_type = KERN_TYPE_MYSQL;
7542 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7543 parse_func = mysql323_parse_hash;
7544 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7545 opti_type = OPTI_TYPE_ZERO_BYTE;
7546 dgst_pos0 = 0;
7547 dgst_pos1 = 1;
7548 dgst_pos2 = 2;
7549 dgst_pos3 = 3;
7550 break;
7551
7552 case 300: hash_type = HASH_TYPE_SHA1;
7553 salt_type = SALT_TYPE_NONE;
7554 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7555 opts_type = OPTS_TYPE_PT_GENERATE_BE
7556 | OPTS_TYPE_PT_ADD80
7557 | OPTS_TYPE_PT_ADDBITS15;
7558 kern_type = KERN_TYPE_MYSQL41;
7559 dgst_size = DGST_SIZE_4_5;
7560 parse_func = sha1_parse_hash;
7561 sort_by_digest = sort_by_digest_4_5;
7562 opti_type = OPTI_TYPE_ZERO_BYTE
7563 | OPTI_TYPE_PRECOMPUTE_INIT
7564 | OPTI_TYPE_PRECOMPUTE_MERKLE
7565 | OPTI_TYPE_EARLY_SKIP
7566 | OPTI_TYPE_NOT_ITERATED
7567 | OPTI_TYPE_NOT_SALTED;
7568 dgst_pos0 = 3;
7569 dgst_pos1 = 4;
7570 dgst_pos2 = 2;
7571 dgst_pos3 = 1;
7572 break;
7573
7574 case 400: hash_type = HASH_TYPE_MD5;
7575 salt_type = SALT_TYPE_EMBEDDED;
7576 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7577 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7578 kern_type = KERN_TYPE_PHPASS;
7579 dgst_size = DGST_SIZE_4_4;
7580 parse_func = phpass_parse_hash;
7581 sort_by_digest = sort_by_digest_4_4;
7582 opti_type = OPTI_TYPE_ZERO_BYTE
7583 | OPTI_TYPE_SLOW_HASH_SIMD;
7584 dgst_pos0 = 0;
7585 dgst_pos1 = 1;
7586 dgst_pos2 = 2;
7587 dgst_pos3 = 3;
7588 break;
7589
7590 case 500: hash_type = HASH_TYPE_MD5;
7591 salt_type = SALT_TYPE_EMBEDDED;
7592 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7593 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7594 kern_type = KERN_TYPE_MD5CRYPT;
7595 dgst_size = DGST_SIZE_4_4;
7596 parse_func = md5crypt_parse_hash;
7597 sort_by_digest = sort_by_digest_4_4;
7598 opti_type = OPTI_TYPE_ZERO_BYTE;
7599 dgst_pos0 = 0;
7600 dgst_pos1 = 1;
7601 dgst_pos2 = 2;
7602 dgst_pos3 = 3;
7603 break;
7604
7605 case 501: hash_type = HASH_TYPE_MD5;
7606 salt_type = SALT_TYPE_EMBEDDED;
7607 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7608 opts_type = OPTS_TYPE_PT_GENERATE_LE
7609 | OPTS_TYPE_HASH_COPY;
7610 kern_type = KERN_TYPE_MD5CRYPT;
7611 dgst_size = DGST_SIZE_4_4;
7612 parse_func = juniper_parse_hash;
7613 sort_by_digest = sort_by_digest_4_4;
7614 opti_type = OPTI_TYPE_ZERO_BYTE;
7615 dgst_pos0 = 0;
7616 dgst_pos1 = 1;
7617 dgst_pos2 = 2;
7618 dgst_pos3 = 3;
7619 break;
7620
7621 case 900: hash_type = HASH_TYPE_MD4;
7622 salt_type = SALT_TYPE_NONE;
7623 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7624 opts_type = OPTS_TYPE_PT_GENERATE_LE
7625 | OPTS_TYPE_PT_ADD80
7626 | OPTS_TYPE_PT_ADDBITS14;
7627 kern_type = KERN_TYPE_MD4;
7628 dgst_size = DGST_SIZE_4_4;
7629 parse_func = md4_parse_hash;
7630 sort_by_digest = sort_by_digest_4_4;
7631 opti_type = OPTI_TYPE_ZERO_BYTE
7632 | OPTI_TYPE_PRECOMPUTE_INIT
7633 | OPTI_TYPE_PRECOMPUTE_MERKLE
7634 | OPTI_TYPE_MEET_IN_MIDDLE
7635 | OPTI_TYPE_EARLY_SKIP
7636 | OPTI_TYPE_NOT_ITERATED
7637 | OPTI_TYPE_NOT_SALTED
7638 | OPTI_TYPE_RAW_HASH;
7639 dgst_pos0 = 0;
7640 dgst_pos1 = 3;
7641 dgst_pos2 = 2;
7642 dgst_pos3 = 1;
7643 break;
7644
7645 case 1000: hash_type = HASH_TYPE_MD4;
7646 salt_type = SALT_TYPE_NONE;
7647 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7648 opts_type = OPTS_TYPE_PT_GENERATE_LE
7649 | OPTS_TYPE_PT_ADD80
7650 | OPTS_TYPE_PT_ADDBITS14
7651 | OPTS_TYPE_PT_UNICODE;
7652 kern_type = KERN_TYPE_MD4_PWU;
7653 dgst_size = DGST_SIZE_4_4;
7654 parse_func = md4_parse_hash;
7655 sort_by_digest = sort_by_digest_4_4;
7656 opti_type = OPTI_TYPE_ZERO_BYTE
7657 | OPTI_TYPE_PRECOMPUTE_INIT
7658 | OPTI_TYPE_PRECOMPUTE_MERKLE
7659 | OPTI_TYPE_MEET_IN_MIDDLE
7660 | OPTI_TYPE_EARLY_SKIP
7661 | OPTI_TYPE_NOT_ITERATED
7662 | OPTI_TYPE_NOT_SALTED
7663 | OPTI_TYPE_RAW_HASH;
7664 dgst_pos0 = 0;
7665 dgst_pos1 = 3;
7666 dgst_pos2 = 2;
7667 dgst_pos3 = 1;
7668 break;
7669
7670 case 1100: hash_type = HASH_TYPE_MD4;
7671 salt_type = SALT_TYPE_INTERN;
7672 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7673 opts_type = OPTS_TYPE_PT_GENERATE_LE
7674 | OPTS_TYPE_PT_ADD80
7675 | OPTS_TYPE_PT_ADDBITS14
7676 | OPTS_TYPE_PT_UNICODE
7677 | OPTS_TYPE_ST_ADD80
7678 | OPTS_TYPE_ST_UNICODE
7679 | OPTS_TYPE_ST_LOWER;
7680 kern_type = KERN_TYPE_MD44_PWUSLT;
7681 dgst_size = DGST_SIZE_4_4;
7682 parse_func = dcc_parse_hash;
7683 sort_by_digest = sort_by_digest_4_4;
7684 opti_type = OPTI_TYPE_ZERO_BYTE
7685 | OPTI_TYPE_PRECOMPUTE_INIT
7686 | OPTI_TYPE_PRECOMPUTE_MERKLE
7687 | OPTI_TYPE_EARLY_SKIP
7688 | OPTI_TYPE_NOT_ITERATED;
7689 dgst_pos0 = 0;
7690 dgst_pos1 = 3;
7691 dgst_pos2 = 2;
7692 dgst_pos3 = 1;
7693 break;
7694
7695 case 1400: hash_type = HASH_TYPE_SHA256;
7696 salt_type = SALT_TYPE_NONE;
7697 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7698 opts_type = OPTS_TYPE_PT_GENERATE_BE
7699 | OPTS_TYPE_PT_ADD80
7700 | OPTS_TYPE_PT_ADDBITS15;
7701 kern_type = KERN_TYPE_SHA256;
7702 dgst_size = DGST_SIZE_4_8;
7703 parse_func = sha256_parse_hash;
7704 sort_by_digest = sort_by_digest_4_8;
7705 opti_type = OPTI_TYPE_ZERO_BYTE
7706 | OPTI_TYPE_PRECOMPUTE_INIT
7707 | OPTI_TYPE_PRECOMPUTE_MERKLE
7708 | OPTI_TYPE_EARLY_SKIP
7709 | OPTI_TYPE_NOT_ITERATED
7710 | OPTI_TYPE_NOT_SALTED
7711 | OPTI_TYPE_RAW_HASH;
7712 dgst_pos0 = 3;
7713 dgst_pos1 = 7;
7714 dgst_pos2 = 2;
7715 dgst_pos3 = 6;
7716 break;
7717
7718 case 1410: hash_type = HASH_TYPE_SHA256;
7719 salt_type = SALT_TYPE_INTERN;
7720 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7721 opts_type = OPTS_TYPE_PT_GENERATE_BE
7722 | OPTS_TYPE_ST_ADD80
7723 | OPTS_TYPE_ST_ADDBITS15;
7724 kern_type = KERN_TYPE_SHA256_PWSLT;
7725 dgst_size = DGST_SIZE_4_8;
7726 parse_func = sha256s_parse_hash;
7727 sort_by_digest = sort_by_digest_4_8;
7728 opti_type = OPTI_TYPE_ZERO_BYTE
7729 | OPTI_TYPE_PRECOMPUTE_INIT
7730 | OPTI_TYPE_PRECOMPUTE_MERKLE
7731 | OPTI_TYPE_EARLY_SKIP
7732 | OPTI_TYPE_NOT_ITERATED
7733 | OPTI_TYPE_APPENDED_SALT
7734 | OPTI_TYPE_RAW_HASH;
7735 dgst_pos0 = 3;
7736 dgst_pos1 = 7;
7737 dgst_pos2 = 2;
7738 dgst_pos3 = 6;
7739 break;
7740
7741 case 1420: hash_type = HASH_TYPE_SHA256;
7742 salt_type = SALT_TYPE_INTERN;
7743 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7744 opts_type = OPTS_TYPE_PT_GENERATE_BE
7745 | OPTS_TYPE_PT_ADD80
7746 | OPTS_TYPE_PT_ADDBITS15;
7747 kern_type = KERN_TYPE_SHA256_SLTPW;
7748 dgst_size = DGST_SIZE_4_8;
7749 parse_func = sha256s_parse_hash;
7750 sort_by_digest = sort_by_digest_4_8;
7751 opti_type = OPTI_TYPE_ZERO_BYTE
7752 | OPTI_TYPE_PRECOMPUTE_INIT
7753 | OPTI_TYPE_PRECOMPUTE_MERKLE
7754 | OPTI_TYPE_EARLY_SKIP
7755 | OPTI_TYPE_NOT_ITERATED
7756 | OPTI_TYPE_PREPENDED_SALT
7757 | OPTI_TYPE_RAW_HASH;
7758 dgst_pos0 = 3;
7759 dgst_pos1 = 7;
7760 dgst_pos2 = 2;
7761 dgst_pos3 = 6;
7762 break;
7763
7764 case 1421: hash_type = HASH_TYPE_SHA256;
7765 salt_type = SALT_TYPE_EMBEDDED;
7766 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7767 opts_type = OPTS_TYPE_PT_GENERATE_BE
7768 | OPTS_TYPE_PT_ADD80
7769 | OPTS_TYPE_PT_ADDBITS15;
7770 kern_type = KERN_TYPE_SHA256_SLTPW;
7771 dgst_size = DGST_SIZE_4_8;
7772 parse_func = hmailserver_parse_hash;
7773 sort_by_digest = sort_by_digest_4_8;
7774 opti_type = OPTI_TYPE_ZERO_BYTE
7775 | OPTI_TYPE_PRECOMPUTE_INIT
7776 | OPTI_TYPE_PRECOMPUTE_MERKLE
7777 | OPTI_TYPE_EARLY_SKIP
7778 | OPTI_TYPE_NOT_ITERATED
7779 | OPTI_TYPE_PREPENDED_SALT
7780 | OPTI_TYPE_RAW_HASH;
7781 dgst_pos0 = 3;
7782 dgst_pos1 = 7;
7783 dgst_pos2 = 2;
7784 dgst_pos3 = 6;
7785 break;
7786
7787 case 1430: hash_type = HASH_TYPE_SHA256;
7788 salt_type = SALT_TYPE_INTERN;
7789 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7790 opts_type = OPTS_TYPE_PT_GENERATE_BE
7791 | OPTS_TYPE_PT_UNICODE
7792 | OPTS_TYPE_ST_ADD80
7793 | OPTS_TYPE_ST_ADDBITS15;
7794 kern_type = KERN_TYPE_SHA256_PWUSLT;
7795 dgst_size = DGST_SIZE_4_8;
7796 parse_func = sha256s_parse_hash;
7797 sort_by_digest = sort_by_digest_4_8;
7798 opti_type = OPTI_TYPE_ZERO_BYTE
7799 | OPTI_TYPE_PRECOMPUTE_INIT
7800 | OPTI_TYPE_PRECOMPUTE_MERKLE
7801 | OPTI_TYPE_EARLY_SKIP
7802 | OPTI_TYPE_NOT_ITERATED
7803 | OPTI_TYPE_APPENDED_SALT
7804 | OPTI_TYPE_RAW_HASH;
7805 dgst_pos0 = 3;
7806 dgst_pos1 = 7;
7807 dgst_pos2 = 2;
7808 dgst_pos3 = 6;
7809 break;
7810
7811 case 1440: hash_type = HASH_TYPE_SHA256;
7812 salt_type = SALT_TYPE_INTERN;
7813 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7814 opts_type = OPTS_TYPE_PT_GENERATE_BE
7815 | OPTS_TYPE_PT_ADD80
7816 | OPTS_TYPE_PT_ADDBITS15
7817 | OPTS_TYPE_PT_UNICODE;
7818 kern_type = KERN_TYPE_SHA256_SLTPWU;
7819 dgst_size = DGST_SIZE_4_8;
7820 parse_func = sha256s_parse_hash;
7821 sort_by_digest = sort_by_digest_4_8;
7822 opti_type = OPTI_TYPE_ZERO_BYTE
7823 | OPTI_TYPE_PRECOMPUTE_INIT
7824 | OPTI_TYPE_PRECOMPUTE_MERKLE
7825 | OPTI_TYPE_EARLY_SKIP
7826 | OPTI_TYPE_NOT_ITERATED
7827 | OPTI_TYPE_PREPENDED_SALT
7828 | OPTI_TYPE_RAW_HASH;
7829 dgst_pos0 = 3;
7830 dgst_pos1 = 7;
7831 dgst_pos2 = 2;
7832 dgst_pos3 = 6;
7833 break;
7834
7835 case 1441: hash_type = HASH_TYPE_SHA256;
7836 salt_type = SALT_TYPE_EMBEDDED;
7837 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7838 opts_type = OPTS_TYPE_PT_GENERATE_BE
7839 | OPTS_TYPE_PT_ADD80
7840 | OPTS_TYPE_PT_ADDBITS15
7841 | OPTS_TYPE_PT_UNICODE
7842 | OPTS_TYPE_ST_BASE64;
7843 kern_type = KERN_TYPE_SHA256_SLTPWU;
7844 dgst_size = DGST_SIZE_4_8;
7845 parse_func = episerver4_parse_hash;
7846 sort_by_digest = sort_by_digest_4_8;
7847 opti_type = OPTI_TYPE_ZERO_BYTE
7848 | OPTI_TYPE_PRECOMPUTE_INIT
7849 | OPTI_TYPE_PRECOMPUTE_MERKLE
7850 | OPTI_TYPE_EARLY_SKIP
7851 | OPTI_TYPE_NOT_ITERATED
7852 | OPTI_TYPE_PREPENDED_SALT
7853 | OPTI_TYPE_RAW_HASH;
7854 dgst_pos0 = 3;
7855 dgst_pos1 = 7;
7856 dgst_pos2 = 2;
7857 dgst_pos3 = 6;
7858 break;
7859
7860 case 1450: hash_type = HASH_TYPE_SHA256;
7861 salt_type = SALT_TYPE_INTERN;
7862 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7863 opts_type = OPTS_TYPE_PT_GENERATE_BE
7864 | OPTS_TYPE_ST_ADD80;
7865 kern_type = KERN_TYPE_HMACSHA256_PW;
7866 dgst_size = DGST_SIZE_4_8;
7867 parse_func = hmacsha256_parse_hash;
7868 sort_by_digest = sort_by_digest_4_8;
7869 opti_type = OPTI_TYPE_ZERO_BYTE
7870 | OPTI_TYPE_NOT_ITERATED;
7871 dgst_pos0 = 3;
7872 dgst_pos1 = 7;
7873 dgst_pos2 = 2;
7874 dgst_pos3 = 6;
7875 break;
7876
7877 case 1460: hash_type = HASH_TYPE_SHA256;
7878 salt_type = SALT_TYPE_INTERN;
7879 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7880 opts_type = OPTS_TYPE_PT_GENERATE_BE
7881 | OPTS_TYPE_PT_ADD80
7882 | OPTS_TYPE_PT_ADDBITS15;
7883 kern_type = KERN_TYPE_HMACSHA256_SLT;
7884 dgst_size = DGST_SIZE_4_8;
7885 parse_func = hmacsha256_parse_hash;
7886 sort_by_digest = sort_by_digest_4_8;
7887 opti_type = OPTI_TYPE_ZERO_BYTE
7888 | OPTI_TYPE_NOT_ITERATED;
7889 dgst_pos0 = 3;
7890 dgst_pos1 = 7;
7891 dgst_pos2 = 2;
7892 dgst_pos3 = 6;
7893 break;
7894
7895 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7896 salt_type = SALT_TYPE_EMBEDDED;
7897 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7898 opts_type = OPTS_TYPE_PT_GENERATE_LE
7899 | OPTS_TYPE_PT_BITSLICE;
7900 kern_type = KERN_TYPE_DESCRYPT;
7901 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7902 parse_func = descrypt_parse_hash;
7903 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7904 opti_type = OPTI_TYPE_ZERO_BYTE
7905 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7906 dgst_pos0 = 0;
7907 dgst_pos1 = 1;
7908 dgst_pos2 = 2;
7909 dgst_pos3 = 3;
7910 break;
7911
7912 case 1600: hash_type = HASH_TYPE_MD5;
7913 salt_type = SALT_TYPE_EMBEDDED;
7914 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7915 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7916 kern_type = KERN_TYPE_APR1CRYPT;
7917 dgst_size = DGST_SIZE_4_4;
7918 parse_func = md5apr1_parse_hash;
7919 sort_by_digest = sort_by_digest_4_4;
7920 opti_type = OPTI_TYPE_ZERO_BYTE;
7921 dgst_pos0 = 0;
7922 dgst_pos1 = 1;
7923 dgst_pos2 = 2;
7924 dgst_pos3 = 3;
7925 break;
7926
7927 case 1700: hash_type = HASH_TYPE_SHA512;
7928 salt_type = SALT_TYPE_NONE;
7929 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7930 opts_type = OPTS_TYPE_PT_GENERATE_BE
7931 | OPTS_TYPE_PT_ADD80
7932 | OPTS_TYPE_PT_ADDBITS15;
7933 kern_type = KERN_TYPE_SHA512;
7934 dgst_size = DGST_SIZE_8_8;
7935 parse_func = sha512_parse_hash;
7936 sort_by_digest = sort_by_digest_8_8;
7937 opti_type = OPTI_TYPE_ZERO_BYTE
7938 | OPTI_TYPE_PRECOMPUTE_INIT
7939 | OPTI_TYPE_PRECOMPUTE_MERKLE
7940 | OPTI_TYPE_EARLY_SKIP
7941 | OPTI_TYPE_NOT_ITERATED
7942 | OPTI_TYPE_NOT_SALTED
7943 | OPTI_TYPE_USES_BITS_64
7944 | OPTI_TYPE_RAW_HASH;
7945 dgst_pos0 = 14;
7946 dgst_pos1 = 15;
7947 dgst_pos2 = 6;
7948 dgst_pos3 = 7;
7949 break;
7950
7951 case 1710: hash_type = HASH_TYPE_SHA512;
7952 salt_type = SALT_TYPE_INTERN;
7953 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7954 opts_type = OPTS_TYPE_PT_GENERATE_BE
7955 | OPTS_TYPE_ST_ADD80
7956 | OPTS_TYPE_ST_ADDBITS15;
7957 kern_type = KERN_TYPE_SHA512_PWSLT;
7958 dgst_size = DGST_SIZE_8_8;
7959 parse_func = sha512s_parse_hash;
7960 sort_by_digest = sort_by_digest_8_8;
7961 opti_type = OPTI_TYPE_ZERO_BYTE
7962 | OPTI_TYPE_PRECOMPUTE_INIT
7963 | OPTI_TYPE_PRECOMPUTE_MERKLE
7964 | OPTI_TYPE_EARLY_SKIP
7965 | OPTI_TYPE_NOT_ITERATED
7966 | OPTI_TYPE_APPENDED_SALT
7967 | OPTI_TYPE_USES_BITS_64
7968 | OPTI_TYPE_RAW_HASH;
7969 dgst_pos0 = 14;
7970 dgst_pos1 = 15;
7971 dgst_pos2 = 6;
7972 dgst_pos3 = 7;
7973 break;
7974
7975 case 1711: hash_type = HASH_TYPE_SHA512;
7976 salt_type = SALT_TYPE_EMBEDDED;
7977 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7978 opts_type = OPTS_TYPE_PT_GENERATE_BE
7979 | OPTS_TYPE_ST_ADD80
7980 | OPTS_TYPE_ST_ADDBITS15;
7981 kern_type = KERN_TYPE_SHA512_PWSLT;
7982 dgst_size = DGST_SIZE_8_8;
7983 parse_func = sha512b64s_parse_hash;
7984 sort_by_digest = sort_by_digest_8_8;
7985 opti_type = OPTI_TYPE_ZERO_BYTE
7986 | OPTI_TYPE_PRECOMPUTE_INIT
7987 | OPTI_TYPE_PRECOMPUTE_MERKLE
7988 | OPTI_TYPE_EARLY_SKIP
7989 | OPTI_TYPE_NOT_ITERATED
7990 | OPTI_TYPE_APPENDED_SALT
7991 | OPTI_TYPE_USES_BITS_64
7992 | OPTI_TYPE_RAW_HASH;
7993 dgst_pos0 = 14;
7994 dgst_pos1 = 15;
7995 dgst_pos2 = 6;
7996 dgst_pos3 = 7;
7997 break;
7998
7999 case 1720: hash_type = HASH_TYPE_SHA512;
8000 salt_type = SALT_TYPE_INTERN;
8001 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8002 opts_type = OPTS_TYPE_PT_GENERATE_BE
8003 | OPTS_TYPE_PT_ADD80
8004 | OPTS_TYPE_PT_ADDBITS15;
8005 kern_type = KERN_TYPE_SHA512_SLTPW;
8006 dgst_size = DGST_SIZE_8_8;
8007 parse_func = sha512s_parse_hash;
8008 sort_by_digest = sort_by_digest_8_8;
8009 opti_type = OPTI_TYPE_ZERO_BYTE
8010 | OPTI_TYPE_PRECOMPUTE_INIT
8011 | OPTI_TYPE_PRECOMPUTE_MERKLE
8012 | OPTI_TYPE_EARLY_SKIP
8013 | OPTI_TYPE_NOT_ITERATED
8014 | OPTI_TYPE_PREPENDED_SALT
8015 | OPTI_TYPE_USES_BITS_64
8016 | OPTI_TYPE_RAW_HASH;
8017 dgst_pos0 = 14;
8018 dgst_pos1 = 15;
8019 dgst_pos2 = 6;
8020 dgst_pos3 = 7;
8021 break;
8022
8023 case 1722: hash_type = HASH_TYPE_SHA512;
8024 salt_type = SALT_TYPE_EMBEDDED;
8025 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8026 opts_type = OPTS_TYPE_PT_GENERATE_BE
8027 | OPTS_TYPE_PT_ADD80
8028 | OPTS_TYPE_PT_ADDBITS15
8029 | OPTS_TYPE_ST_HEX;
8030 kern_type = KERN_TYPE_SHA512_SLTPW;
8031 dgst_size = DGST_SIZE_8_8;
8032 parse_func = osx512_parse_hash;
8033 sort_by_digest = sort_by_digest_8_8;
8034 opti_type = OPTI_TYPE_ZERO_BYTE
8035 | OPTI_TYPE_PRECOMPUTE_INIT
8036 | OPTI_TYPE_PRECOMPUTE_MERKLE
8037 | OPTI_TYPE_EARLY_SKIP
8038 | OPTI_TYPE_NOT_ITERATED
8039 | OPTI_TYPE_PREPENDED_SALT
8040 | OPTI_TYPE_USES_BITS_64
8041 | OPTI_TYPE_RAW_HASH;
8042 dgst_pos0 = 14;
8043 dgst_pos1 = 15;
8044 dgst_pos2 = 6;
8045 dgst_pos3 = 7;
8046 break;
8047
8048 case 1730: hash_type = HASH_TYPE_SHA512;
8049 salt_type = SALT_TYPE_INTERN;
8050 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8051 opts_type = OPTS_TYPE_PT_GENERATE_BE
8052 | OPTS_TYPE_PT_UNICODE
8053 | OPTS_TYPE_ST_ADD80
8054 | OPTS_TYPE_ST_ADDBITS15;
8055 kern_type = KERN_TYPE_SHA512_PWSLTU;
8056 dgst_size = DGST_SIZE_8_8;
8057 parse_func = sha512s_parse_hash;
8058 sort_by_digest = sort_by_digest_8_8;
8059 opti_type = OPTI_TYPE_ZERO_BYTE
8060 | OPTI_TYPE_PRECOMPUTE_INIT
8061 | OPTI_TYPE_PRECOMPUTE_MERKLE
8062 | OPTI_TYPE_EARLY_SKIP
8063 | OPTI_TYPE_NOT_ITERATED
8064 | OPTI_TYPE_APPENDED_SALT
8065 | OPTI_TYPE_USES_BITS_64
8066 | OPTI_TYPE_RAW_HASH;
8067 dgst_pos0 = 14;
8068 dgst_pos1 = 15;
8069 dgst_pos2 = 6;
8070 dgst_pos3 = 7;
8071 break;
8072
8073 case 1731: hash_type = HASH_TYPE_SHA512;
8074 salt_type = SALT_TYPE_EMBEDDED;
8075 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8076 opts_type = OPTS_TYPE_PT_GENERATE_BE
8077 | OPTS_TYPE_PT_UNICODE
8078 | OPTS_TYPE_ST_ADD80
8079 | OPTS_TYPE_ST_ADDBITS15
8080 | OPTS_TYPE_ST_HEX;
8081 kern_type = KERN_TYPE_SHA512_PWSLTU;
8082 dgst_size = DGST_SIZE_8_8;
8083 parse_func = mssql2012_parse_hash;
8084 sort_by_digest = sort_by_digest_8_8;
8085 opti_type = OPTI_TYPE_ZERO_BYTE
8086 | OPTI_TYPE_PRECOMPUTE_INIT
8087 | OPTI_TYPE_PRECOMPUTE_MERKLE
8088 | OPTI_TYPE_EARLY_SKIP
8089 | OPTI_TYPE_NOT_ITERATED
8090 | OPTI_TYPE_APPENDED_SALT
8091 | OPTI_TYPE_USES_BITS_64
8092 | OPTI_TYPE_RAW_HASH;
8093 dgst_pos0 = 14;
8094 dgst_pos1 = 15;
8095 dgst_pos2 = 6;
8096 dgst_pos3 = 7;
8097 break;
8098
8099 case 1740: hash_type = HASH_TYPE_SHA512;
8100 salt_type = SALT_TYPE_INTERN;
8101 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8102 opts_type = OPTS_TYPE_PT_GENERATE_BE
8103 | OPTS_TYPE_PT_ADD80
8104 | OPTS_TYPE_PT_ADDBITS15
8105 | OPTS_TYPE_PT_UNICODE;
8106 kern_type = KERN_TYPE_SHA512_SLTPWU;
8107 dgst_size = DGST_SIZE_8_8;
8108 parse_func = sha512s_parse_hash;
8109 sort_by_digest = sort_by_digest_8_8;
8110 opti_type = OPTI_TYPE_ZERO_BYTE
8111 | OPTI_TYPE_PRECOMPUTE_INIT
8112 | OPTI_TYPE_PRECOMPUTE_MERKLE
8113 | OPTI_TYPE_EARLY_SKIP
8114 | OPTI_TYPE_NOT_ITERATED
8115 | OPTI_TYPE_PREPENDED_SALT
8116 | OPTI_TYPE_USES_BITS_64
8117 | OPTI_TYPE_RAW_HASH;
8118 dgst_pos0 = 14;
8119 dgst_pos1 = 15;
8120 dgst_pos2 = 6;
8121 dgst_pos3 = 7;
8122 break;
8123
8124 case 1750: hash_type = HASH_TYPE_SHA512;
8125 salt_type = SALT_TYPE_INTERN;
8126 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8127 opts_type = OPTS_TYPE_PT_GENERATE_BE
8128 | OPTS_TYPE_ST_ADD80;
8129 kern_type = KERN_TYPE_HMACSHA512_PW;
8130 dgst_size = DGST_SIZE_8_8;
8131 parse_func = hmacsha512_parse_hash;
8132 sort_by_digest = sort_by_digest_8_8;
8133 opti_type = OPTI_TYPE_ZERO_BYTE
8134 | OPTI_TYPE_USES_BITS_64
8135 | OPTI_TYPE_NOT_ITERATED;
8136 dgst_pos0 = 14;
8137 dgst_pos1 = 15;
8138 dgst_pos2 = 6;
8139 dgst_pos3 = 7;
8140 break;
8141
8142 case 1760: hash_type = HASH_TYPE_SHA512;
8143 salt_type = SALT_TYPE_INTERN;
8144 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8145 opts_type = OPTS_TYPE_PT_GENERATE_BE
8146 | OPTS_TYPE_PT_ADD80
8147 | OPTS_TYPE_PT_ADDBITS15;
8148 kern_type = KERN_TYPE_HMACSHA512_SLT;
8149 dgst_size = DGST_SIZE_8_8;
8150 parse_func = hmacsha512_parse_hash;
8151 sort_by_digest = sort_by_digest_8_8;
8152 opti_type = OPTI_TYPE_ZERO_BYTE
8153 | OPTI_TYPE_USES_BITS_64
8154 | OPTI_TYPE_NOT_ITERATED;
8155 dgst_pos0 = 14;
8156 dgst_pos1 = 15;
8157 dgst_pos2 = 6;
8158 dgst_pos3 = 7;
8159 break;
8160
8161 case 1800: hash_type = HASH_TYPE_SHA512;
8162 salt_type = SALT_TYPE_EMBEDDED;
8163 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8164 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8165 kern_type = KERN_TYPE_SHA512CRYPT;
8166 dgst_size = DGST_SIZE_8_8;
8167 parse_func = sha512crypt_parse_hash;
8168 sort_by_digest = sort_by_digest_8_8;
8169 opti_type = OPTI_TYPE_ZERO_BYTE
8170 | OPTI_TYPE_USES_BITS_64;
8171 dgst_pos0 = 0;
8172 dgst_pos1 = 1;
8173 dgst_pos2 = 2;
8174 dgst_pos3 = 3;
8175 break;
8176
8177 case 2100: hash_type = HASH_TYPE_DCC2;
8178 salt_type = SALT_TYPE_EMBEDDED;
8179 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8180 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8181 | OPTS_TYPE_ST_LOWER
8182 | OPTS_TYPE_ST_UNICODE;
8183 kern_type = KERN_TYPE_DCC2;
8184 dgst_size = DGST_SIZE_4_4;
8185 parse_func = dcc2_parse_hash;
8186 sort_by_digest = sort_by_digest_4_4;
8187 opti_type = OPTI_TYPE_ZERO_BYTE
8188 | OPTI_TYPE_SLOW_HASH_SIMD;
8189 dgst_pos0 = 0;
8190 dgst_pos1 = 1;
8191 dgst_pos2 = 2;
8192 dgst_pos3 = 3;
8193 break;
8194
8195 case 2400: hash_type = HASH_TYPE_MD5;
8196 salt_type = SALT_TYPE_NONE;
8197 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8198 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8199 kern_type = KERN_TYPE_MD5PIX;
8200 dgst_size = DGST_SIZE_4_4;
8201 parse_func = md5pix_parse_hash;
8202 sort_by_digest = sort_by_digest_4_4;
8203 opti_type = OPTI_TYPE_ZERO_BYTE
8204 | OPTI_TYPE_PRECOMPUTE_INIT
8205 | OPTI_TYPE_PRECOMPUTE_MERKLE
8206 | OPTI_TYPE_EARLY_SKIP
8207 | OPTI_TYPE_NOT_ITERATED
8208 | OPTI_TYPE_NOT_SALTED;
8209 dgst_pos0 = 0;
8210 dgst_pos1 = 3;
8211 dgst_pos2 = 2;
8212 dgst_pos3 = 1;
8213 break;
8214
8215 case 2410: hash_type = HASH_TYPE_MD5;
8216 salt_type = SALT_TYPE_INTERN;
8217 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8218 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8219 kern_type = KERN_TYPE_MD5ASA;
8220 dgst_size = DGST_SIZE_4_4;
8221 parse_func = md5asa_parse_hash;
8222 sort_by_digest = sort_by_digest_4_4;
8223 opti_type = OPTI_TYPE_ZERO_BYTE
8224 | OPTI_TYPE_PRECOMPUTE_INIT
8225 | OPTI_TYPE_PRECOMPUTE_MERKLE
8226 | OPTI_TYPE_EARLY_SKIP
8227 | OPTI_TYPE_NOT_ITERATED;
8228 dgst_pos0 = 0;
8229 dgst_pos1 = 3;
8230 dgst_pos2 = 2;
8231 dgst_pos3 = 1;
8232 break;
8233
8234 case 2500: hash_type = HASH_TYPE_WPA;
8235 salt_type = SALT_TYPE_EMBEDDED;
8236 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8237 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8238 kern_type = KERN_TYPE_WPA;
8239 dgst_size = DGST_SIZE_4_4;
8240 parse_func = wpa_parse_hash;
8241 sort_by_digest = sort_by_digest_4_4;
8242 opti_type = OPTI_TYPE_ZERO_BYTE
8243 | OPTI_TYPE_SLOW_HASH_SIMD;
8244 dgst_pos0 = 0;
8245 dgst_pos1 = 1;
8246 dgst_pos2 = 2;
8247 dgst_pos3 = 3;
8248 break;
8249
8250 case 2600: hash_type = HASH_TYPE_MD5;
8251 salt_type = SALT_TYPE_VIRTUAL;
8252 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8253 opts_type = OPTS_TYPE_PT_GENERATE_LE
8254 | OPTS_TYPE_PT_ADD80
8255 | OPTS_TYPE_PT_ADDBITS14
8256 | OPTS_TYPE_ST_ADD80;
8257 kern_type = KERN_TYPE_MD55_PWSLT1;
8258 dgst_size = DGST_SIZE_4_4;
8259 parse_func = md5md5_parse_hash;
8260 sort_by_digest = sort_by_digest_4_4;
8261 opti_type = OPTI_TYPE_ZERO_BYTE
8262 | OPTI_TYPE_PRECOMPUTE_INIT
8263 | OPTI_TYPE_PRECOMPUTE_MERKLE
8264 | OPTI_TYPE_EARLY_SKIP;
8265 dgst_pos0 = 0;
8266 dgst_pos1 = 3;
8267 dgst_pos2 = 2;
8268 dgst_pos3 = 1;
8269 break;
8270
8271 case 2611: hash_type = HASH_TYPE_MD5;
8272 salt_type = SALT_TYPE_INTERN;
8273 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8274 opts_type = OPTS_TYPE_PT_GENERATE_LE
8275 | OPTS_TYPE_PT_ADD80
8276 | OPTS_TYPE_PT_ADDBITS14
8277 | OPTS_TYPE_ST_ADD80;
8278 kern_type = KERN_TYPE_MD55_PWSLT1;
8279 dgst_size = DGST_SIZE_4_4;
8280 parse_func = vb3_parse_hash;
8281 sort_by_digest = sort_by_digest_4_4;
8282 opti_type = OPTI_TYPE_ZERO_BYTE
8283 | OPTI_TYPE_PRECOMPUTE_INIT
8284 | OPTI_TYPE_PRECOMPUTE_MERKLE
8285 | OPTI_TYPE_EARLY_SKIP;
8286 dgst_pos0 = 0;
8287 dgst_pos1 = 3;
8288 dgst_pos2 = 2;
8289 dgst_pos3 = 1;
8290 break;
8291
8292 case 2612: hash_type = HASH_TYPE_MD5;
8293 salt_type = SALT_TYPE_EMBEDDED;
8294 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8295 opts_type = OPTS_TYPE_PT_GENERATE_LE
8296 | OPTS_TYPE_PT_ADD80
8297 | OPTS_TYPE_PT_ADDBITS14
8298 | OPTS_TYPE_ST_ADD80
8299 | OPTS_TYPE_ST_HEX;
8300 kern_type = KERN_TYPE_MD55_PWSLT1;
8301 dgst_size = DGST_SIZE_4_4;
8302 parse_func = phps_parse_hash;
8303 sort_by_digest = sort_by_digest_4_4;
8304 opti_type = OPTI_TYPE_ZERO_BYTE
8305 | OPTI_TYPE_PRECOMPUTE_INIT
8306 | OPTI_TYPE_PRECOMPUTE_MERKLE
8307 | OPTI_TYPE_EARLY_SKIP;
8308 dgst_pos0 = 0;
8309 dgst_pos1 = 3;
8310 dgst_pos2 = 2;
8311 dgst_pos3 = 1;
8312 break;
8313
8314 case 2711: hash_type = HASH_TYPE_MD5;
8315 salt_type = SALT_TYPE_INTERN;
8316 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8317 opts_type = OPTS_TYPE_PT_GENERATE_LE
8318 | OPTS_TYPE_PT_ADD80
8319 | OPTS_TYPE_PT_ADDBITS14
8320 | OPTS_TYPE_ST_ADD80;
8321 kern_type = KERN_TYPE_MD55_PWSLT2;
8322 dgst_size = DGST_SIZE_4_4;
8323 parse_func = vb30_parse_hash;
8324 sort_by_digest = sort_by_digest_4_4;
8325 opti_type = OPTI_TYPE_ZERO_BYTE
8326 | OPTI_TYPE_PRECOMPUTE_INIT
8327 | OPTI_TYPE_EARLY_SKIP;
8328 dgst_pos0 = 0;
8329 dgst_pos1 = 3;
8330 dgst_pos2 = 2;
8331 dgst_pos3 = 1;
8332 break;
8333
8334 case 2811: hash_type = HASH_TYPE_MD5;
8335 salt_type = SALT_TYPE_INTERN;
8336 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8337 opts_type = OPTS_TYPE_PT_GENERATE_LE
8338 | OPTS_TYPE_PT_ADD80
8339 | OPTS_TYPE_PT_ADDBITS14;
8340 kern_type = KERN_TYPE_MD55_SLTPW;
8341 dgst_size = DGST_SIZE_4_4;
8342 parse_func = ipb2_parse_hash;
8343 sort_by_digest = sort_by_digest_4_4;
8344 opti_type = OPTI_TYPE_ZERO_BYTE
8345 | OPTI_TYPE_PRECOMPUTE_INIT
8346 | OPTI_TYPE_EARLY_SKIP;
8347 dgst_pos0 = 0;
8348 dgst_pos1 = 3;
8349 dgst_pos2 = 2;
8350 dgst_pos3 = 1;
8351 break;
8352
8353 case 3000: hash_type = HASH_TYPE_LM;
8354 salt_type = SALT_TYPE_NONE;
8355 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8356 opts_type = OPTS_TYPE_PT_GENERATE_LE
8357 | OPTS_TYPE_PT_UPPER
8358 | OPTS_TYPE_PT_BITSLICE;
8359 kern_type = KERN_TYPE_LM;
8360 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8361 parse_func = lm_parse_hash;
8362 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8363 opti_type = OPTI_TYPE_ZERO_BYTE
8364 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8365 dgst_pos0 = 0;
8366 dgst_pos1 = 1;
8367 dgst_pos2 = 2;
8368 dgst_pos3 = 3;
8369 break;
8370
8371 case 3100: hash_type = HASH_TYPE_ORACLEH;
8372 salt_type = SALT_TYPE_INTERN;
8373 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8374 opts_type = OPTS_TYPE_PT_GENERATE_LE
8375 | OPTS_TYPE_PT_UPPER
8376 | OPTS_TYPE_ST_UPPER;
8377 kern_type = KERN_TYPE_ORACLEH;
8378 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8379 parse_func = oracleh_parse_hash;
8380 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8381 opti_type = OPTI_TYPE_ZERO_BYTE;
8382 dgst_pos0 = 0;
8383 dgst_pos1 = 1;
8384 dgst_pos2 = 2;
8385 dgst_pos3 = 3;
8386 break;
8387
8388 case 3200: hash_type = HASH_TYPE_BCRYPT;
8389 salt_type = SALT_TYPE_EMBEDDED;
8390 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8391 opts_type = OPTS_TYPE_PT_GENERATE_LE
8392 | OPTS_TYPE_ST_GENERATE_LE;
8393 kern_type = KERN_TYPE_BCRYPT;
8394 dgst_size = DGST_SIZE_4_6;
8395 parse_func = bcrypt_parse_hash;
8396 sort_by_digest = sort_by_digest_4_6;
8397 opti_type = OPTI_TYPE_ZERO_BYTE;
8398 dgst_pos0 = 0;
8399 dgst_pos1 = 1;
8400 dgst_pos2 = 2;
8401 dgst_pos3 = 3;
8402 break;
8403
8404 case 3710: hash_type = HASH_TYPE_MD5;
8405 salt_type = SALT_TYPE_INTERN;
8406 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8407 opts_type = OPTS_TYPE_PT_GENERATE_LE
8408 | OPTS_TYPE_PT_ADD80
8409 | OPTS_TYPE_PT_ADDBITS14;
8410 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8411 dgst_size = DGST_SIZE_4_4;
8412 parse_func = md5s_parse_hash;
8413 sort_by_digest = sort_by_digest_4_4;
8414 opti_type = OPTI_TYPE_ZERO_BYTE
8415 | OPTI_TYPE_PRECOMPUTE_INIT
8416 | OPTI_TYPE_PRECOMPUTE_MERKLE
8417 | OPTI_TYPE_EARLY_SKIP;
8418 dgst_pos0 = 0;
8419 dgst_pos1 = 3;
8420 dgst_pos2 = 2;
8421 dgst_pos3 = 1;
8422 break;
8423
8424 case 3711: hash_type = HASH_TYPE_MD5;
8425 salt_type = SALT_TYPE_EMBEDDED;
8426 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8427 opts_type = OPTS_TYPE_PT_GENERATE_LE
8428 | OPTS_TYPE_PT_ADD80
8429 | OPTS_TYPE_PT_ADDBITS14;
8430 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8431 dgst_size = DGST_SIZE_4_4;
8432 parse_func = mediawiki_b_parse_hash;
8433 sort_by_digest = sort_by_digest_4_4;
8434 opti_type = OPTI_TYPE_ZERO_BYTE
8435 | OPTI_TYPE_PRECOMPUTE_INIT
8436 | OPTI_TYPE_PRECOMPUTE_MERKLE
8437 | OPTI_TYPE_EARLY_SKIP;
8438 dgst_pos0 = 0;
8439 dgst_pos1 = 3;
8440 dgst_pos2 = 2;
8441 dgst_pos3 = 1;
8442 break;
8443
8444 case 3800: hash_type = HASH_TYPE_MD5;
8445 salt_type = SALT_TYPE_INTERN;
8446 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8447 opts_type = OPTS_TYPE_PT_GENERATE_LE
8448 | OPTS_TYPE_ST_ADDBITS14;
8449 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8450 dgst_size = DGST_SIZE_4_4;
8451 parse_func = md5s_parse_hash;
8452 sort_by_digest = sort_by_digest_4_4;
8453 opti_type = OPTI_TYPE_ZERO_BYTE
8454 | OPTI_TYPE_PRECOMPUTE_INIT
8455 | OPTI_TYPE_PRECOMPUTE_MERKLE
8456 | OPTI_TYPE_EARLY_SKIP
8457 | OPTI_TYPE_NOT_ITERATED
8458 | OPTI_TYPE_RAW_HASH;
8459 dgst_pos0 = 0;
8460 dgst_pos1 = 3;
8461 dgst_pos2 = 2;
8462 dgst_pos3 = 1;
8463 break;
8464
8465 case 4300: hash_type = HASH_TYPE_MD5;
8466 salt_type = SALT_TYPE_VIRTUAL;
8467 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8468 opts_type = OPTS_TYPE_PT_GENERATE_LE
8469 | OPTS_TYPE_PT_ADD80
8470 | OPTS_TYPE_PT_ADDBITS14
8471 | OPTS_TYPE_ST_ADD80;
8472 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8473 dgst_size = DGST_SIZE_4_4;
8474 parse_func = md5md5_parse_hash;
8475 sort_by_digest = sort_by_digest_4_4;
8476 opti_type = OPTI_TYPE_ZERO_BYTE
8477 | OPTI_TYPE_PRECOMPUTE_INIT
8478 | OPTI_TYPE_PRECOMPUTE_MERKLE
8479 | OPTI_TYPE_EARLY_SKIP;
8480 dgst_pos0 = 0;
8481 dgst_pos1 = 3;
8482 dgst_pos2 = 2;
8483 dgst_pos3 = 1;
8484 break;
8485
8486
8487 case 4400: hash_type = HASH_TYPE_MD5;
8488 salt_type = SALT_TYPE_NONE;
8489 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8490 opts_type = OPTS_TYPE_PT_GENERATE_BE
8491 | OPTS_TYPE_PT_ADD80
8492 | OPTS_TYPE_PT_ADDBITS15;
8493 kern_type = KERN_TYPE_MD5_SHA1;
8494 dgst_size = DGST_SIZE_4_4;
8495 parse_func = md5_parse_hash;
8496 sort_by_digest = sort_by_digest_4_4;
8497 opti_type = OPTI_TYPE_ZERO_BYTE
8498 | OPTI_TYPE_PRECOMPUTE_INIT
8499 | OPTI_TYPE_PRECOMPUTE_MERKLE
8500 | OPTI_TYPE_EARLY_SKIP
8501 | OPTI_TYPE_NOT_ITERATED
8502 | OPTI_TYPE_NOT_SALTED
8503 | OPTI_TYPE_RAW_HASH;
8504 dgst_pos0 = 0;
8505 dgst_pos1 = 3;
8506 dgst_pos2 = 2;
8507 dgst_pos3 = 1;
8508 break;
8509
8510 case 4500: hash_type = HASH_TYPE_SHA1;
8511 salt_type = SALT_TYPE_NONE;
8512 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8513 opts_type = OPTS_TYPE_PT_GENERATE_BE
8514 | OPTS_TYPE_PT_ADD80
8515 | OPTS_TYPE_PT_ADDBITS15;
8516 kern_type = KERN_TYPE_SHA11;
8517 dgst_size = DGST_SIZE_4_5;
8518 parse_func = sha1_parse_hash;
8519 sort_by_digest = sort_by_digest_4_5;
8520 opti_type = OPTI_TYPE_ZERO_BYTE
8521 | OPTI_TYPE_PRECOMPUTE_INIT
8522 | OPTI_TYPE_PRECOMPUTE_MERKLE
8523 | OPTI_TYPE_EARLY_SKIP
8524 | OPTI_TYPE_NOT_SALTED;
8525 dgst_pos0 = 3;
8526 dgst_pos1 = 4;
8527 dgst_pos2 = 2;
8528 dgst_pos3 = 1;
8529 break;
8530
8531 case 4700: hash_type = HASH_TYPE_SHA1;
8532 salt_type = SALT_TYPE_NONE;
8533 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8534 opts_type = OPTS_TYPE_PT_GENERATE_LE
8535 | OPTS_TYPE_PT_ADD80
8536 | OPTS_TYPE_PT_ADDBITS14;
8537 kern_type = KERN_TYPE_SHA1_MD5;
8538 dgst_size = DGST_SIZE_4_5;
8539 parse_func = sha1_parse_hash;
8540 sort_by_digest = sort_by_digest_4_5;
8541 opti_type = OPTI_TYPE_ZERO_BYTE
8542 | OPTI_TYPE_PRECOMPUTE_INIT
8543 | OPTI_TYPE_PRECOMPUTE_MERKLE
8544 | OPTI_TYPE_EARLY_SKIP
8545 | OPTI_TYPE_NOT_ITERATED
8546 | OPTI_TYPE_NOT_SALTED
8547 | OPTI_TYPE_RAW_HASH;
8548 dgst_pos0 = 3;
8549 dgst_pos1 = 4;
8550 dgst_pos2 = 2;
8551 dgst_pos3 = 1;
8552 break;
8553
8554 case 4800: hash_type = HASH_TYPE_MD5;
8555 salt_type = SALT_TYPE_EMBEDDED;
8556 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8557 opts_type = OPTS_TYPE_PT_GENERATE_LE
8558 | OPTS_TYPE_PT_ADDBITS14;
8559 kern_type = KERN_TYPE_MD5_CHAP;
8560 dgst_size = DGST_SIZE_4_4;
8561 parse_func = chap_parse_hash;
8562 sort_by_digest = sort_by_digest_4_4;
8563 opti_type = OPTI_TYPE_ZERO_BYTE
8564 | OPTI_TYPE_PRECOMPUTE_INIT
8565 | OPTI_TYPE_PRECOMPUTE_MERKLE
8566 | OPTI_TYPE_MEET_IN_MIDDLE
8567 | OPTI_TYPE_EARLY_SKIP
8568 | OPTI_TYPE_NOT_ITERATED
8569 | OPTI_TYPE_RAW_HASH;
8570 dgst_pos0 = 0;
8571 dgst_pos1 = 3;
8572 dgst_pos2 = 2;
8573 dgst_pos3 = 1;
8574 break;
8575
8576 case 4900: hash_type = HASH_TYPE_SHA1;
8577 salt_type = SALT_TYPE_INTERN;
8578 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8579 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8580 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8581 dgst_size = DGST_SIZE_4_5;
8582 parse_func = sha1s_parse_hash;
8583 sort_by_digest = sort_by_digest_4_5;
8584 opti_type = OPTI_TYPE_ZERO_BYTE
8585 | OPTI_TYPE_PRECOMPUTE_INIT
8586 | OPTI_TYPE_PRECOMPUTE_MERKLE
8587 | OPTI_TYPE_EARLY_SKIP;
8588 dgst_pos0 = 3;
8589 dgst_pos1 = 4;
8590 dgst_pos2 = 2;
8591 dgst_pos3 = 1;
8592 break;
8593
8594 case 5000: hash_type = HASH_TYPE_KECCAK;
8595 salt_type = SALT_TYPE_EMBEDDED;
8596 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8597 opts_type = OPTS_TYPE_PT_GENERATE_LE
8598 | OPTS_TYPE_PT_ADD01;
8599 kern_type = KERN_TYPE_KECCAK;
8600 dgst_size = DGST_SIZE_8_25;
8601 parse_func = keccak_parse_hash;
8602 sort_by_digest = sort_by_digest_8_25;
8603 opti_type = OPTI_TYPE_ZERO_BYTE
8604 | OPTI_TYPE_USES_BITS_64
8605 | OPTI_TYPE_RAW_HASH;
8606 dgst_pos0 = 2;
8607 dgst_pos1 = 3;
8608 dgst_pos2 = 4;
8609 dgst_pos3 = 5;
8610 break;
8611
8612 case 5100: hash_type = HASH_TYPE_MD5H;
8613 salt_type = SALT_TYPE_NONE;
8614 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8615 opts_type = OPTS_TYPE_PT_GENERATE_LE
8616 | OPTS_TYPE_PT_ADD80
8617 | OPTS_TYPE_PT_ADDBITS14;
8618 kern_type = KERN_TYPE_MD5H;
8619 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8620 parse_func = md5half_parse_hash;
8621 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8622 opti_type = OPTI_TYPE_ZERO_BYTE
8623 | OPTI_TYPE_RAW_HASH;
8624 dgst_pos0 = 0;
8625 dgst_pos1 = 1;
8626 dgst_pos2 = 2;
8627 dgst_pos3 = 3;
8628 break;
8629
8630 case 5200: hash_type = HASH_TYPE_SHA256;
8631 salt_type = SALT_TYPE_EMBEDDED;
8632 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8633 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8634 kern_type = KERN_TYPE_PSAFE3;
8635 dgst_size = DGST_SIZE_4_8;
8636 parse_func = psafe3_parse_hash;
8637 sort_by_digest = sort_by_digest_4_8;
8638 opti_type = OPTI_TYPE_ZERO_BYTE;
8639 dgst_pos0 = 0;
8640 dgst_pos1 = 1;
8641 dgst_pos2 = 2;
8642 dgst_pos3 = 3;
8643 break;
8644
8645 case 5300: hash_type = HASH_TYPE_MD5;
8646 salt_type = SALT_TYPE_EMBEDDED;
8647 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8648 opts_type = OPTS_TYPE_PT_GENERATE_LE
8649 | OPTS_TYPE_ST_ADD80;
8650 kern_type = KERN_TYPE_IKEPSK_MD5;
8651 dgst_size = DGST_SIZE_4_4;
8652 parse_func = ikepsk_md5_parse_hash;
8653 sort_by_digest = sort_by_digest_4_4;
8654 opti_type = OPTI_TYPE_ZERO_BYTE;
8655 dgst_pos0 = 0;
8656 dgst_pos1 = 3;
8657 dgst_pos2 = 2;
8658 dgst_pos3 = 1;
8659 break;
8660
8661 case 5400: hash_type = HASH_TYPE_SHA1;
8662 salt_type = SALT_TYPE_EMBEDDED;
8663 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8664 opts_type = OPTS_TYPE_PT_GENERATE_BE
8665 | OPTS_TYPE_ST_ADD80;
8666 kern_type = KERN_TYPE_IKEPSK_SHA1;
8667 dgst_size = DGST_SIZE_4_5;
8668 parse_func = ikepsk_sha1_parse_hash;
8669 sort_by_digest = sort_by_digest_4_5;
8670 opti_type = OPTI_TYPE_ZERO_BYTE;
8671 dgst_pos0 = 3;
8672 dgst_pos1 = 4;
8673 dgst_pos2 = 2;
8674 dgst_pos3 = 1;
8675 break;
8676
8677 case 5500: hash_type = HASH_TYPE_NETNTLM;
8678 salt_type = SALT_TYPE_EMBEDDED;
8679 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8680 opts_type = OPTS_TYPE_PT_GENERATE_LE
8681 | OPTS_TYPE_PT_ADD80
8682 | OPTS_TYPE_PT_ADDBITS14
8683 | OPTS_TYPE_PT_UNICODE
8684 | OPTS_TYPE_ST_HEX;
8685 kern_type = KERN_TYPE_NETNTLMv1;
8686 dgst_size = DGST_SIZE_4_4;
8687 parse_func = netntlmv1_parse_hash;
8688 sort_by_digest = sort_by_digest_4_4;
8689 opti_type = OPTI_TYPE_ZERO_BYTE
8690 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8691 dgst_pos0 = 0;
8692 dgst_pos1 = 1;
8693 dgst_pos2 = 2;
8694 dgst_pos3 = 3;
8695 break;
8696
8697 case 5600: hash_type = HASH_TYPE_MD5;
8698 salt_type = SALT_TYPE_EMBEDDED;
8699 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8700 opts_type = OPTS_TYPE_PT_GENERATE_LE
8701 | OPTS_TYPE_PT_ADD80
8702 | OPTS_TYPE_PT_ADDBITS14
8703 | OPTS_TYPE_PT_UNICODE;
8704 kern_type = KERN_TYPE_NETNTLMv2;
8705 dgst_size = DGST_SIZE_4_4;
8706 parse_func = netntlmv2_parse_hash;
8707 sort_by_digest = sort_by_digest_4_4;
8708 opti_type = OPTI_TYPE_ZERO_BYTE;
8709 dgst_pos0 = 0;
8710 dgst_pos1 = 3;
8711 dgst_pos2 = 2;
8712 dgst_pos3 = 1;
8713 break;
8714
8715 case 5700: hash_type = HASH_TYPE_SHA256;
8716 salt_type = SALT_TYPE_NONE;
8717 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8718 opts_type = OPTS_TYPE_PT_GENERATE_BE
8719 | OPTS_TYPE_PT_ADD80
8720 | OPTS_TYPE_PT_ADDBITS15;
8721 kern_type = KERN_TYPE_SHA256;
8722 dgst_size = DGST_SIZE_4_8;
8723 parse_func = cisco4_parse_hash;
8724 sort_by_digest = sort_by_digest_4_8;
8725 opti_type = OPTI_TYPE_ZERO_BYTE
8726 | OPTI_TYPE_PRECOMPUTE_INIT
8727 | OPTI_TYPE_PRECOMPUTE_MERKLE
8728 | OPTI_TYPE_EARLY_SKIP
8729 | OPTI_TYPE_NOT_ITERATED
8730 | OPTI_TYPE_NOT_SALTED
8731 | OPTI_TYPE_RAW_HASH;
8732 dgst_pos0 = 3;
8733 dgst_pos1 = 7;
8734 dgst_pos2 = 2;
8735 dgst_pos3 = 6;
8736 break;
8737
8738 case 5800: hash_type = HASH_TYPE_SHA1;
8739 salt_type = SALT_TYPE_INTERN;
8740 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8741 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8742 | OPTS_TYPE_ST_ADD80;
8743 kern_type = KERN_TYPE_ANDROIDPIN;
8744 dgst_size = DGST_SIZE_4_5;
8745 parse_func = androidpin_parse_hash;
8746 sort_by_digest = sort_by_digest_4_5;
8747 opti_type = OPTI_TYPE_ZERO_BYTE;
8748 dgst_pos0 = 0;
8749 dgst_pos1 = 1;
8750 dgst_pos2 = 2;
8751 dgst_pos3 = 3;
8752 break;
8753
8754 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8755 salt_type = SALT_TYPE_NONE;
8756 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8757 opts_type = OPTS_TYPE_PT_GENERATE_LE
8758 | OPTS_TYPE_PT_ADD80;
8759 kern_type = KERN_TYPE_RIPEMD160;
8760 dgst_size = DGST_SIZE_4_5;
8761 parse_func = ripemd160_parse_hash;
8762 sort_by_digest = sort_by_digest_4_5;
8763 opti_type = OPTI_TYPE_ZERO_BYTE;
8764 dgst_pos0 = 0;
8765 dgst_pos1 = 1;
8766 dgst_pos2 = 2;
8767 dgst_pos3 = 3;
8768 break;
8769
8770 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8771 salt_type = SALT_TYPE_NONE;
8772 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8773 opts_type = OPTS_TYPE_PT_GENERATE_BE
8774 | OPTS_TYPE_PT_ADD80;
8775 kern_type = KERN_TYPE_WHIRLPOOL;
8776 dgst_size = DGST_SIZE_4_16;
8777 parse_func = whirlpool_parse_hash;
8778 sort_by_digest = sort_by_digest_4_16;
8779 opti_type = OPTI_TYPE_ZERO_BYTE;
8780 dgst_pos0 = 0;
8781 dgst_pos1 = 1;
8782 dgst_pos2 = 2;
8783 dgst_pos3 = 3;
8784 break;
8785
8786 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8787 salt_type = SALT_TYPE_EMBEDDED;
8788 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8789 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8790 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8791 dgst_size = DGST_SIZE_4_5;
8792 parse_func = truecrypt_parse_hash_2k;
8793 sort_by_digest = sort_by_digest_4_5;
8794 opti_type = OPTI_TYPE_ZERO_BYTE;
8795 dgst_pos0 = 0;
8796 dgst_pos1 = 1;
8797 dgst_pos2 = 2;
8798 dgst_pos3 = 3;
8799 break;
8800
8801 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8802 salt_type = SALT_TYPE_EMBEDDED;
8803 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8804 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8805 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8806 dgst_size = DGST_SIZE_4_5;
8807 parse_func = truecrypt_parse_hash_2k;
8808 sort_by_digest = sort_by_digest_4_5;
8809 opti_type = OPTI_TYPE_ZERO_BYTE;
8810 dgst_pos0 = 0;
8811 dgst_pos1 = 1;
8812 dgst_pos2 = 2;
8813 dgst_pos3 = 3;
8814 break;
8815
8816 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8817 salt_type = SALT_TYPE_EMBEDDED;
8818 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8819 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8820 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8821 dgst_size = DGST_SIZE_4_5;
8822 parse_func = truecrypt_parse_hash_2k;
8823 sort_by_digest = sort_by_digest_4_5;
8824 opti_type = OPTI_TYPE_ZERO_BYTE;
8825 dgst_pos0 = 0;
8826 dgst_pos1 = 1;
8827 dgst_pos2 = 2;
8828 dgst_pos3 = 3;
8829 break;
8830
8831 case 6221: hash_type = HASH_TYPE_SHA512;
8832 salt_type = SALT_TYPE_EMBEDDED;
8833 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8834 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8835 kern_type = KERN_TYPE_TCSHA512_XTS512;
8836 dgst_size = DGST_SIZE_8_8;
8837 parse_func = truecrypt_parse_hash_1k;
8838 sort_by_digest = sort_by_digest_8_8;
8839 opti_type = OPTI_TYPE_ZERO_BYTE
8840 | OPTI_TYPE_USES_BITS_64;
8841 dgst_pos0 = 0;
8842 dgst_pos1 = 1;
8843 dgst_pos2 = 2;
8844 dgst_pos3 = 3;
8845 break;
8846
8847 case 6222: hash_type = HASH_TYPE_SHA512;
8848 salt_type = SALT_TYPE_EMBEDDED;
8849 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8850 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8851 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8852 dgst_size = DGST_SIZE_8_8;
8853 parse_func = truecrypt_parse_hash_1k;
8854 sort_by_digest = sort_by_digest_8_8;
8855 opti_type = OPTI_TYPE_ZERO_BYTE
8856 | OPTI_TYPE_USES_BITS_64;
8857 dgst_pos0 = 0;
8858 dgst_pos1 = 1;
8859 dgst_pos2 = 2;
8860 dgst_pos3 = 3;
8861 break;
8862
8863 case 6223: hash_type = HASH_TYPE_SHA512;
8864 salt_type = SALT_TYPE_EMBEDDED;
8865 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8866 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8867 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8868 dgst_size = DGST_SIZE_8_8;
8869 parse_func = truecrypt_parse_hash_1k;
8870 sort_by_digest = sort_by_digest_8_8;
8871 opti_type = OPTI_TYPE_ZERO_BYTE
8872 | OPTI_TYPE_USES_BITS_64;
8873 dgst_pos0 = 0;
8874 dgst_pos1 = 1;
8875 dgst_pos2 = 2;
8876 dgst_pos3 = 3;
8877 break;
8878
8879 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8880 salt_type = SALT_TYPE_EMBEDDED;
8881 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8882 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8883 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8884 dgst_size = DGST_SIZE_4_8;
8885 parse_func = truecrypt_parse_hash_1k;
8886 sort_by_digest = sort_by_digest_4_8;
8887 opti_type = OPTI_TYPE_ZERO_BYTE;
8888 dgst_pos0 = 0;
8889 dgst_pos1 = 1;
8890 dgst_pos2 = 2;
8891 dgst_pos3 = 3;
8892 break;
8893
8894 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8895 salt_type = SALT_TYPE_EMBEDDED;
8896 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8897 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8898 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8899 dgst_size = DGST_SIZE_4_8;
8900 parse_func = truecrypt_parse_hash_1k;
8901 sort_by_digest = sort_by_digest_4_8;
8902 opti_type = OPTI_TYPE_ZERO_BYTE;
8903 dgst_pos0 = 0;
8904 dgst_pos1 = 1;
8905 dgst_pos2 = 2;
8906 dgst_pos3 = 3;
8907 break;
8908
8909 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8910 salt_type = SALT_TYPE_EMBEDDED;
8911 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8912 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8913 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8914 dgst_size = DGST_SIZE_4_8;
8915 parse_func = truecrypt_parse_hash_1k;
8916 sort_by_digest = sort_by_digest_4_8;
8917 opti_type = OPTI_TYPE_ZERO_BYTE;
8918 dgst_pos0 = 0;
8919 dgst_pos1 = 1;
8920 dgst_pos2 = 2;
8921 dgst_pos3 = 3;
8922 break;
8923
8924 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8925 salt_type = SALT_TYPE_EMBEDDED;
8926 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8927 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8928 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8929 dgst_size = DGST_SIZE_4_5;
8930 parse_func = truecrypt_parse_hash_1k;
8931 sort_by_digest = sort_by_digest_4_5;
8932 opti_type = OPTI_TYPE_ZERO_BYTE;
8933 dgst_pos0 = 0;
8934 dgst_pos1 = 1;
8935 dgst_pos2 = 2;
8936 dgst_pos3 = 3;
8937 break;
8938
8939 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8940 salt_type = SALT_TYPE_EMBEDDED;
8941 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8942 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8943 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8944 dgst_size = DGST_SIZE_4_5;
8945 parse_func = truecrypt_parse_hash_1k;
8946 sort_by_digest = sort_by_digest_4_5;
8947 opti_type = OPTI_TYPE_ZERO_BYTE;
8948 dgst_pos0 = 0;
8949 dgst_pos1 = 1;
8950 dgst_pos2 = 2;
8951 dgst_pos3 = 3;
8952 break;
8953
8954 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8955 salt_type = SALT_TYPE_EMBEDDED;
8956 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8957 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8958 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8959 dgst_size = DGST_SIZE_4_5;
8960 parse_func = truecrypt_parse_hash_1k;
8961 sort_by_digest = sort_by_digest_4_5;
8962 opti_type = OPTI_TYPE_ZERO_BYTE;
8963 dgst_pos0 = 0;
8964 dgst_pos1 = 1;
8965 dgst_pos2 = 2;
8966 dgst_pos3 = 3;
8967 break;
8968
8969 case 6300: hash_type = HASH_TYPE_MD5;
8970 salt_type = SALT_TYPE_EMBEDDED;
8971 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8972 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8973 kern_type = KERN_TYPE_MD5AIX;
8974 dgst_size = DGST_SIZE_4_4;
8975 parse_func = md5aix_parse_hash;
8976 sort_by_digest = sort_by_digest_4_4;
8977 opti_type = OPTI_TYPE_ZERO_BYTE;
8978 dgst_pos0 = 0;
8979 dgst_pos1 = 1;
8980 dgst_pos2 = 2;
8981 dgst_pos3 = 3;
8982 break;
8983
8984 case 6400: hash_type = HASH_TYPE_SHA256;
8985 salt_type = SALT_TYPE_EMBEDDED;
8986 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8987 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8988 kern_type = KERN_TYPE_SHA256AIX;
8989 dgst_size = DGST_SIZE_4_8;
8990 parse_func = sha256aix_parse_hash;
8991 sort_by_digest = sort_by_digest_4_8;
8992 opti_type = OPTI_TYPE_ZERO_BYTE;
8993 dgst_pos0 = 0;
8994 dgst_pos1 = 1;
8995 dgst_pos2 = 2;
8996 dgst_pos3 = 3;
8997 break;
8998
8999 case 6500: hash_type = HASH_TYPE_SHA512;
9000 salt_type = SALT_TYPE_EMBEDDED;
9001 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9002 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9003 kern_type = KERN_TYPE_SHA512AIX;
9004 dgst_size = DGST_SIZE_8_8;
9005 parse_func = sha512aix_parse_hash;
9006 sort_by_digest = sort_by_digest_8_8;
9007 opti_type = OPTI_TYPE_ZERO_BYTE
9008 | OPTI_TYPE_USES_BITS_64;
9009 dgst_pos0 = 0;
9010 dgst_pos1 = 1;
9011 dgst_pos2 = 2;
9012 dgst_pos3 = 3;
9013 break;
9014
9015 case 6600: hash_type = HASH_TYPE_AES;
9016 salt_type = SALT_TYPE_EMBEDDED;
9017 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9018 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9019 kern_type = KERN_TYPE_AGILEKEY;
9020 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9021 parse_func = agilekey_parse_hash;
9022 sort_by_digest = sort_by_digest_4_5;
9023 opti_type = OPTI_TYPE_ZERO_BYTE;
9024 dgst_pos0 = 0;
9025 dgst_pos1 = 1;
9026 dgst_pos2 = 2;
9027 dgst_pos3 = 3;
9028 break;
9029
9030 case 6700: hash_type = HASH_TYPE_SHA1;
9031 salt_type = SALT_TYPE_EMBEDDED;
9032 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9033 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9034 kern_type = KERN_TYPE_SHA1AIX;
9035 dgst_size = DGST_SIZE_4_5;
9036 parse_func = sha1aix_parse_hash;
9037 sort_by_digest = sort_by_digest_4_5;
9038 opti_type = OPTI_TYPE_ZERO_BYTE;
9039 dgst_pos0 = 0;
9040 dgst_pos1 = 1;
9041 dgst_pos2 = 2;
9042 dgst_pos3 = 3;
9043 break;
9044
9045 case 6800: hash_type = HASH_TYPE_AES;
9046 salt_type = SALT_TYPE_EMBEDDED;
9047 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9048 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9049 kern_type = KERN_TYPE_LASTPASS;
9050 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9051 parse_func = lastpass_parse_hash;
9052 sort_by_digest = sort_by_digest_4_8;
9053 opti_type = OPTI_TYPE_ZERO_BYTE;
9054 dgst_pos0 = 0;
9055 dgst_pos1 = 1;
9056 dgst_pos2 = 2;
9057 dgst_pos3 = 3;
9058 break;
9059
9060 case 6900: hash_type = HASH_TYPE_GOST;
9061 salt_type = SALT_TYPE_NONE;
9062 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9063 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9064 kern_type = KERN_TYPE_GOST;
9065 dgst_size = DGST_SIZE_4_8;
9066 parse_func = gost_parse_hash;
9067 sort_by_digest = sort_by_digest_4_8;
9068 opti_type = OPTI_TYPE_ZERO_BYTE;
9069 dgst_pos0 = 0;
9070 dgst_pos1 = 1;
9071 dgst_pos2 = 2;
9072 dgst_pos3 = 3;
9073 break;
9074
9075 case 7100: hash_type = HASH_TYPE_SHA512;
9076 salt_type = SALT_TYPE_EMBEDDED;
9077 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9078 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9079 kern_type = KERN_TYPE_PBKDF2_SHA512;
9080 dgst_size = DGST_SIZE_8_16;
9081 parse_func = sha512osx_parse_hash;
9082 sort_by_digest = sort_by_digest_8_16;
9083 opti_type = OPTI_TYPE_ZERO_BYTE
9084 | OPTI_TYPE_USES_BITS_64
9085 | OPTI_TYPE_SLOW_HASH_SIMD;
9086 dgst_pos0 = 0;
9087 dgst_pos1 = 1;
9088 dgst_pos2 = 2;
9089 dgst_pos3 = 3;
9090 break;
9091
9092 case 7200: hash_type = HASH_TYPE_SHA512;
9093 salt_type = SALT_TYPE_EMBEDDED;
9094 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9095 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9096 kern_type = KERN_TYPE_PBKDF2_SHA512;
9097 dgst_size = DGST_SIZE_8_16;
9098 parse_func = sha512grub_parse_hash;
9099 sort_by_digest = sort_by_digest_8_16;
9100 opti_type = OPTI_TYPE_ZERO_BYTE
9101 | OPTI_TYPE_USES_BITS_64
9102 | OPTI_TYPE_SLOW_HASH_SIMD;
9103 dgst_pos0 = 0;
9104 dgst_pos1 = 1;
9105 dgst_pos2 = 2;
9106 dgst_pos3 = 3;
9107 break;
9108
9109 case 7300: hash_type = HASH_TYPE_SHA1;
9110 salt_type = SALT_TYPE_EMBEDDED;
9111 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9112 opts_type = OPTS_TYPE_PT_GENERATE_BE
9113 | OPTS_TYPE_ST_ADD80
9114 | OPTS_TYPE_ST_ADDBITS15;
9115 kern_type = KERN_TYPE_RAKP;
9116 dgst_size = DGST_SIZE_4_5;
9117 parse_func = rakp_parse_hash;
9118 sort_by_digest = sort_by_digest_4_5;
9119 opti_type = OPTI_TYPE_ZERO_BYTE
9120 | OPTI_TYPE_NOT_ITERATED;
9121 dgst_pos0 = 3;
9122 dgst_pos1 = 4;
9123 dgst_pos2 = 2;
9124 dgst_pos3 = 1;
9125 break;
9126
9127 case 7400: hash_type = HASH_TYPE_SHA256;
9128 salt_type = SALT_TYPE_EMBEDDED;
9129 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9130 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9131 kern_type = KERN_TYPE_SHA256CRYPT;
9132 dgst_size = DGST_SIZE_4_8;
9133 parse_func = sha256crypt_parse_hash;
9134 sort_by_digest = sort_by_digest_4_8;
9135 opti_type = OPTI_TYPE_ZERO_BYTE;
9136 dgst_pos0 = 0;
9137 dgst_pos1 = 1;
9138 dgst_pos2 = 2;
9139 dgst_pos3 = 3;
9140 break;
9141
9142 case 7500: hash_type = HASH_TYPE_KRB5PA;
9143 salt_type = SALT_TYPE_EMBEDDED;
9144 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9145 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9146 kern_type = KERN_TYPE_KRB5PA;
9147 dgst_size = DGST_SIZE_4_4;
9148 parse_func = krb5pa_parse_hash;
9149 sort_by_digest = sort_by_digest_4_4;
9150 opti_type = OPTI_TYPE_ZERO_BYTE
9151 | OPTI_TYPE_NOT_ITERATED;
9152 dgst_pos0 = 0;
9153 dgst_pos1 = 1;
9154 dgst_pos2 = 2;
9155 dgst_pos3 = 3;
9156 break;
9157
9158 case 7600: hash_type = HASH_TYPE_SHA1;
9159 salt_type = SALT_TYPE_INTERN;
9160 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9161 opts_type = OPTS_TYPE_PT_GENERATE_BE
9162 | OPTS_TYPE_PT_ADD80
9163 | OPTS_TYPE_PT_ADDBITS15;
9164 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9165 dgst_size = DGST_SIZE_4_5;
9166 parse_func = redmine_parse_hash;
9167 sort_by_digest = sort_by_digest_4_5;
9168 opti_type = OPTI_TYPE_ZERO_BYTE
9169 | OPTI_TYPE_PRECOMPUTE_INIT
9170 | OPTI_TYPE_EARLY_SKIP
9171 | OPTI_TYPE_NOT_ITERATED
9172 | OPTI_TYPE_PREPENDED_SALT;
9173 dgst_pos0 = 3;
9174 dgst_pos1 = 4;
9175 dgst_pos2 = 2;
9176 dgst_pos3 = 1;
9177 break;
9178
9179 case 7700: hash_type = HASH_TYPE_SAPB;
9180 salt_type = SALT_TYPE_EMBEDDED;
9181 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9182 opts_type = OPTS_TYPE_PT_GENERATE_LE
9183 | OPTS_TYPE_PT_UPPER
9184 | OPTS_TYPE_ST_UPPER;
9185 kern_type = KERN_TYPE_SAPB;
9186 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9187 parse_func = sapb_parse_hash;
9188 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9189 opti_type = OPTI_TYPE_ZERO_BYTE
9190 | OPTI_TYPE_PRECOMPUTE_INIT
9191 | OPTI_TYPE_NOT_ITERATED;
9192 dgst_pos0 = 0;
9193 dgst_pos1 = 1;
9194 dgst_pos2 = 2;
9195 dgst_pos3 = 3;
9196 break;
9197
9198 case 7800: hash_type = HASH_TYPE_SAPG;
9199 salt_type = SALT_TYPE_EMBEDDED;
9200 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9201 opts_type = OPTS_TYPE_PT_GENERATE_BE
9202 | OPTS_TYPE_ST_ADD80
9203 | OPTS_TYPE_ST_UPPER;
9204 kern_type = KERN_TYPE_SAPG;
9205 dgst_size = DGST_SIZE_4_5;
9206 parse_func = sapg_parse_hash;
9207 sort_by_digest = sort_by_digest_4_5;
9208 opti_type = OPTI_TYPE_ZERO_BYTE
9209 | OPTI_TYPE_PRECOMPUTE_INIT
9210 | OPTI_TYPE_NOT_ITERATED;
9211 dgst_pos0 = 3;
9212 dgst_pos1 = 4;
9213 dgst_pos2 = 2;
9214 dgst_pos3 = 1;
9215 break;
9216
9217 case 7900: hash_type = HASH_TYPE_SHA512;
9218 salt_type = SALT_TYPE_EMBEDDED;
9219 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9220 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9221 kern_type = KERN_TYPE_DRUPAL7;
9222 dgst_size = DGST_SIZE_8_8;
9223 parse_func = drupal7_parse_hash;
9224 sort_by_digest = sort_by_digest_8_8;
9225 opti_type = OPTI_TYPE_ZERO_BYTE
9226 | OPTI_TYPE_USES_BITS_64;
9227 dgst_pos0 = 0;
9228 dgst_pos1 = 1;
9229 dgst_pos2 = 2;
9230 dgst_pos3 = 3;
9231 break;
9232
9233 case 8000: hash_type = HASH_TYPE_SHA256;
9234 salt_type = SALT_TYPE_EMBEDDED;
9235 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9236 opts_type = OPTS_TYPE_PT_GENERATE_BE
9237 | OPTS_TYPE_PT_UNICODE
9238 | OPTS_TYPE_ST_ADD80
9239 | OPTS_TYPE_ST_HEX;
9240 kern_type = KERN_TYPE_SYBASEASE;
9241 dgst_size = DGST_SIZE_4_8;
9242 parse_func = sybasease_parse_hash;
9243 sort_by_digest = sort_by_digest_4_8;
9244 opti_type = OPTI_TYPE_ZERO_BYTE
9245 | OPTI_TYPE_PRECOMPUTE_INIT
9246 | OPTI_TYPE_EARLY_SKIP
9247 | OPTI_TYPE_NOT_ITERATED
9248 | OPTI_TYPE_RAW_HASH;
9249 dgst_pos0 = 3;
9250 dgst_pos1 = 7;
9251 dgst_pos2 = 2;
9252 dgst_pos3 = 6;
9253 break;
9254
9255 case 8100: hash_type = HASH_TYPE_SHA1;
9256 salt_type = SALT_TYPE_EMBEDDED;
9257 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9258 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9259 kern_type = KERN_TYPE_NETSCALER;
9260 dgst_size = DGST_SIZE_4_5;
9261 parse_func = netscaler_parse_hash;
9262 sort_by_digest = sort_by_digest_4_5;
9263 opti_type = OPTI_TYPE_ZERO_BYTE
9264 | OPTI_TYPE_PRECOMPUTE_INIT
9265 | OPTI_TYPE_PRECOMPUTE_MERKLE
9266 | OPTI_TYPE_EARLY_SKIP
9267 | OPTI_TYPE_NOT_ITERATED
9268 | OPTI_TYPE_PREPENDED_SALT
9269 | OPTI_TYPE_RAW_HASH;
9270 dgst_pos0 = 3;
9271 dgst_pos1 = 4;
9272 dgst_pos2 = 2;
9273 dgst_pos3 = 1;
9274 break;
9275
9276 case 8200: hash_type = HASH_TYPE_SHA256;
9277 salt_type = SALT_TYPE_EMBEDDED;
9278 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9279 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9280 kern_type = KERN_TYPE_CLOUDKEY;
9281 dgst_size = DGST_SIZE_4_8;
9282 parse_func = cloudkey_parse_hash;
9283 sort_by_digest = sort_by_digest_4_8;
9284 opti_type = OPTI_TYPE_ZERO_BYTE;
9285 dgst_pos0 = 0;
9286 dgst_pos1 = 1;
9287 dgst_pos2 = 2;
9288 dgst_pos3 = 3;
9289 break;
9290
9291 case 8300: hash_type = HASH_TYPE_SHA1;
9292 salt_type = SALT_TYPE_EMBEDDED;
9293 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9294 opts_type = OPTS_TYPE_PT_GENERATE_BE
9295 | OPTS_TYPE_ST_HEX
9296 | OPTS_TYPE_ST_ADD80;
9297 kern_type = KERN_TYPE_NSEC3;
9298 dgst_size = DGST_SIZE_4_5;
9299 parse_func = nsec3_parse_hash;
9300 sort_by_digest = sort_by_digest_4_5;
9301 opti_type = OPTI_TYPE_ZERO_BYTE;
9302 dgst_pos0 = 3;
9303 dgst_pos1 = 4;
9304 dgst_pos2 = 2;
9305 dgst_pos3 = 1;
9306 break;
9307
9308 case 8400: hash_type = HASH_TYPE_SHA1;
9309 salt_type = SALT_TYPE_INTERN;
9310 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9311 opts_type = OPTS_TYPE_PT_GENERATE_BE
9312 | OPTS_TYPE_PT_ADD80
9313 | OPTS_TYPE_PT_ADDBITS15;
9314 kern_type = KERN_TYPE_WBB3;
9315 dgst_size = DGST_SIZE_4_5;
9316 parse_func = wbb3_parse_hash;
9317 sort_by_digest = sort_by_digest_4_5;
9318 opti_type = OPTI_TYPE_ZERO_BYTE
9319 | OPTI_TYPE_PRECOMPUTE_INIT
9320 | OPTI_TYPE_NOT_ITERATED;
9321 dgst_pos0 = 3;
9322 dgst_pos1 = 4;
9323 dgst_pos2 = 2;
9324 dgst_pos3 = 1;
9325 break;
9326
9327 case 8500: hash_type = HASH_TYPE_DESRACF;
9328 salt_type = SALT_TYPE_EMBEDDED;
9329 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9330 opts_type = OPTS_TYPE_PT_GENERATE_LE
9331 | OPTS_TYPE_ST_UPPER;
9332 kern_type = KERN_TYPE_RACF;
9333 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9334 parse_func = racf_parse_hash;
9335 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9336 opti_type = OPTI_TYPE_ZERO_BYTE
9337 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9338 dgst_pos0 = 0;
9339 dgst_pos1 = 1;
9340 dgst_pos2 = 2;
9341 dgst_pos3 = 3;
9342 break;
9343
9344 case 8600: hash_type = HASH_TYPE_LOTUS5;
9345 salt_type = SALT_TYPE_NONE;
9346 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9347 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9348 kern_type = KERN_TYPE_LOTUS5;
9349 dgst_size = DGST_SIZE_4_4;
9350 parse_func = lotus5_parse_hash;
9351 sort_by_digest = sort_by_digest_4_4;
9352 opti_type = OPTI_TYPE_EARLY_SKIP
9353 | OPTI_TYPE_NOT_ITERATED
9354 | OPTI_TYPE_NOT_SALTED
9355 | OPTI_TYPE_RAW_HASH;
9356 dgst_pos0 = 0;
9357 dgst_pos1 = 1;
9358 dgst_pos2 = 2;
9359 dgst_pos3 = 3;
9360 break;
9361
9362 case 8700: hash_type = HASH_TYPE_LOTUS6;
9363 salt_type = SALT_TYPE_EMBEDDED;
9364 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9365 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9366 kern_type = KERN_TYPE_LOTUS6;
9367 dgst_size = DGST_SIZE_4_4;
9368 parse_func = lotus6_parse_hash;
9369 sort_by_digest = sort_by_digest_4_4;
9370 opti_type = OPTI_TYPE_EARLY_SKIP
9371 | OPTI_TYPE_NOT_ITERATED
9372 | OPTI_TYPE_RAW_HASH;
9373 dgst_pos0 = 0;
9374 dgst_pos1 = 1;
9375 dgst_pos2 = 2;
9376 dgst_pos3 = 3;
9377 break;
9378
9379 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9380 salt_type = SALT_TYPE_EMBEDDED;
9381 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9382 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9383 kern_type = KERN_TYPE_ANDROIDFDE;
9384 dgst_size = DGST_SIZE_4_4;
9385 parse_func = androidfde_parse_hash;
9386 sort_by_digest = sort_by_digest_4_4;
9387 opti_type = OPTI_TYPE_ZERO_BYTE;
9388 dgst_pos0 = 0;
9389 dgst_pos1 = 1;
9390 dgst_pos2 = 2;
9391 dgst_pos3 = 3;
9392 break;
9393
9394 case 8900: hash_type = HASH_TYPE_SCRYPT;
9395 salt_type = SALT_TYPE_EMBEDDED;
9396 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9397 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9398 kern_type = KERN_TYPE_SCRYPT;
9399 dgst_size = DGST_SIZE_4_8;
9400 parse_func = scrypt_parse_hash;
9401 sort_by_digest = sort_by_digest_4_8;
9402 opti_type = OPTI_TYPE_ZERO_BYTE;
9403 dgst_pos0 = 0;
9404 dgst_pos1 = 1;
9405 dgst_pos2 = 2;
9406 dgst_pos3 = 3;
9407 break;
9408
9409 case 9000: hash_type = HASH_TYPE_SHA1;
9410 salt_type = SALT_TYPE_EMBEDDED;
9411 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9412 opts_type = OPTS_TYPE_PT_GENERATE_LE
9413 | OPTS_TYPE_ST_GENERATE_LE;
9414 kern_type = KERN_TYPE_PSAFE2;
9415 dgst_size = DGST_SIZE_4_5;
9416 parse_func = psafe2_parse_hash;
9417 sort_by_digest = sort_by_digest_4_5;
9418 opti_type = OPTI_TYPE_ZERO_BYTE;
9419 dgst_pos0 = 0;
9420 dgst_pos1 = 1;
9421 dgst_pos2 = 2;
9422 dgst_pos3 = 3;
9423 break;
9424
9425 case 9100: hash_type = HASH_TYPE_LOTUS8;
9426 salt_type = SALT_TYPE_EMBEDDED;
9427 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9428 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9429 kern_type = KERN_TYPE_LOTUS8;
9430 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9431 parse_func = lotus8_parse_hash;
9432 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9433 opti_type = OPTI_TYPE_ZERO_BYTE;
9434 dgst_pos0 = 0;
9435 dgst_pos1 = 1;
9436 dgst_pos2 = 2;
9437 dgst_pos3 = 3;
9438 break;
9439
9440 case 9200: hash_type = HASH_TYPE_SHA256;
9441 salt_type = SALT_TYPE_EMBEDDED;
9442 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9443 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9444 kern_type = KERN_TYPE_PBKDF2_SHA256;
9445 dgst_size = DGST_SIZE_4_32;
9446 parse_func = cisco8_parse_hash;
9447 sort_by_digest = sort_by_digest_4_32;
9448 opti_type = OPTI_TYPE_ZERO_BYTE
9449 | OPTI_TYPE_SLOW_HASH_SIMD;
9450 dgst_pos0 = 0;
9451 dgst_pos1 = 1;
9452 dgst_pos2 = 2;
9453 dgst_pos3 = 3;
9454 break;
9455
9456 case 9300: hash_type = HASH_TYPE_SCRYPT;
9457 salt_type = SALT_TYPE_EMBEDDED;
9458 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9459 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9460 kern_type = KERN_TYPE_SCRYPT;
9461 dgst_size = DGST_SIZE_4_8;
9462 parse_func = cisco9_parse_hash;
9463 sort_by_digest = sort_by_digest_4_8;
9464 opti_type = OPTI_TYPE_ZERO_BYTE;
9465 dgst_pos0 = 0;
9466 dgst_pos1 = 1;
9467 dgst_pos2 = 2;
9468 dgst_pos3 = 3;
9469 break;
9470
9471 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9472 salt_type = SALT_TYPE_EMBEDDED;
9473 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9474 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9475 kern_type = KERN_TYPE_OFFICE2007;
9476 dgst_size = DGST_SIZE_4_4;
9477 parse_func = office2007_parse_hash;
9478 sort_by_digest = sort_by_digest_4_4;
9479 opti_type = OPTI_TYPE_ZERO_BYTE;
9480 dgst_pos0 = 0;
9481 dgst_pos1 = 1;
9482 dgst_pos2 = 2;
9483 dgst_pos3 = 3;
9484 break;
9485
9486 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9487 salt_type = SALT_TYPE_EMBEDDED;
9488 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9489 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9490 kern_type = KERN_TYPE_OFFICE2010;
9491 dgst_size = DGST_SIZE_4_4;
9492 parse_func = office2010_parse_hash;
9493 sort_by_digest = sort_by_digest_4_4;
9494 opti_type = OPTI_TYPE_ZERO_BYTE;
9495 dgst_pos0 = 0;
9496 dgst_pos1 = 1;
9497 dgst_pos2 = 2;
9498 dgst_pos3 = 3;
9499 break;
9500
9501 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9502 salt_type = SALT_TYPE_EMBEDDED;
9503 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9504 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9505 kern_type = KERN_TYPE_OFFICE2013;
9506 dgst_size = DGST_SIZE_4_4;
9507 parse_func = office2013_parse_hash;
9508 sort_by_digest = sort_by_digest_4_4;
9509 opti_type = OPTI_TYPE_ZERO_BYTE;
9510 dgst_pos0 = 0;
9511 dgst_pos1 = 1;
9512 dgst_pos2 = 2;
9513 dgst_pos3 = 3;
9514 break;
9515
9516 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9517 salt_type = SALT_TYPE_EMBEDDED;
9518 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9519 opts_type = OPTS_TYPE_PT_GENERATE_LE
9520 | OPTS_TYPE_PT_ADD80
9521 | OPTS_TYPE_PT_UNICODE;
9522 kern_type = KERN_TYPE_OLDOFFICE01;
9523 dgst_size = DGST_SIZE_4_4;
9524 parse_func = oldoffice01_parse_hash;
9525 sort_by_digest = sort_by_digest_4_4;
9526 opti_type = OPTI_TYPE_ZERO_BYTE
9527 | OPTI_TYPE_PRECOMPUTE_INIT
9528 | OPTI_TYPE_NOT_ITERATED;
9529 dgst_pos0 = 0;
9530 dgst_pos1 = 1;
9531 dgst_pos2 = 2;
9532 dgst_pos3 = 3;
9533 break;
9534
9535 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9536 salt_type = SALT_TYPE_EMBEDDED;
9537 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9538 opts_type = OPTS_TYPE_PT_GENERATE_LE
9539 | OPTS_TYPE_PT_ADD80;
9540 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9541 dgst_size = DGST_SIZE_4_4;
9542 parse_func = oldoffice01cm1_parse_hash;
9543 sort_by_digest = sort_by_digest_4_4;
9544 opti_type = OPTI_TYPE_ZERO_BYTE
9545 | OPTI_TYPE_PRECOMPUTE_INIT
9546 | OPTI_TYPE_NOT_ITERATED;
9547 dgst_pos0 = 0;
9548 dgst_pos1 = 1;
9549 dgst_pos2 = 2;
9550 dgst_pos3 = 3;
9551 break;
9552
9553 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9554 salt_type = SALT_TYPE_EMBEDDED;
9555 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9556 opts_type = OPTS_TYPE_PT_GENERATE_LE
9557 | OPTS_TYPE_PT_ADD80
9558 | OPTS_TYPE_PT_UNICODE
9559 | OPTS_TYPE_PT_NEVERCRACK;
9560 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9561 dgst_size = DGST_SIZE_4_4;
9562 parse_func = oldoffice01cm2_parse_hash;
9563 sort_by_digest = sort_by_digest_4_4;
9564 opti_type = OPTI_TYPE_ZERO_BYTE
9565 | OPTI_TYPE_PRECOMPUTE_INIT
9566 | OPTI_TYPE_NOT_ITERATED;
9567 dgst_pos0 = 0;
9568 dgst_pos1 = 1;
9569 dgst_pos2 = 2;
9570 dgst_pos3 = 3;
9571 break;
9572
9573 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9574 salt_type = SALT_TYPE_EMBEDDED;
9575 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9576 opts_type = OPTS_TYPE_PT_GENERATE_BE
9577 | OPTS_TYPE_PT_ADD80
9578 | OPTS_TYPE_PT_UNICODE;
9579 kern_type = KERN_TYPE_OLDOFFICE34;
9580 dgst_size = DGST_SIZE_4_4;
9581 parse_func = oldoffice34_parse_hash;
9582 sort_by_digest = sort_by_digest_4_4;
9583 opti_type = OPTI_TYPE_ZERO_BYTE
9584 | OPTI_TYPE_PRECOMPUTE_INIT
9585 | OPTI_TYPE_NOT_ITERATED;
9586 dgst_pos0 = 0;
9587 dgst_pos1 = 1;
9588 dgst_pos2 = 2;
9589 dgst_pos3 = 3;
9590 break;
9591
9592 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9593 salt_type = SALT_TYPE_EMBEDDED;
9594 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9595 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9596 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9597 dgst_size = DGST_SIZE_4_4;
9598 parse_func = oldoffice34cm1_parse_hash;
9599 sort_by_digest = sort_by_digest_4_4;
9600 opti_type = OPTI_TYPE_ZERO_BYTE
9601 | OPTI_TYPE_PRECOMPUTE_INIT
9602 | OPTI_TYPE_NOT_ITERATED;
9603 dgst_pos0 = 0;
9604 dgst_pos1 = 1;
9605 dgst_pos2 = 2;
9606 dgst_pos3 = 3;
9607 break;
9608
9609 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9610 salt_type = SALT_TYPE_EMBEDDED;
9611 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9612 opts_type = OPTS_TYPE_PT_GENERATE_BE
9613 | OPTS_TYPE_PT_ADD80
9614 | OPTS_TYPE_PT_UNICODE
9615 | OPTS_TYPE_PT_NEVERCRACK;
9616 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9617 dgst_size = DGST_SIZE_4_4;
9618 parse_func = oldoffice34cm2_parse_hash;
9619 sort_by_digest = sort_by_digest_4_4;
9620 opti_type = OPTI_TYPE_ZERO_BYTE
9621 | OPTI_TYPE_PRECOMPUTE_INIT
9622 | OPTI_TYPE_NOT_ITERATED;
9623 dgst_pos0 = 0;
9624 dgst_pos1 = 1;
9625 dgst_pos2 = 2;
9626 dgst_pos3 = 3;
9627 break;
9628
9629 case 9900: hash_type = HASH_TYPE_MD5;
9630 salt_type = SALT_TYPE_NONE;
9631 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9632 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9633 kern_type = KERN_TYPE_RADMIN2;
9634 dgst_size = DGST_SIZE_4_4;
9635 parse_func = radmin2_parse_hash;
9636 sort_by_digest = sort_by_digest_4_4;
9637 opti_type = OPTI_TYPE_ZERO_BYTE
9638 | OPTI_TYPE_PRECOMPUTE_INIT
9639 | OPTI_TYPE_EARLY_SKIP
9640 | OPTI_TYPE_NOT_ITERATED
9641 | OPTI_TYPE_NOT_SALTED;
9642 dgst_pos0 = 0;
9643 dgst_pos1 = 3;
9644 dgst_pos2 = 2;
9645 dgst_pos3 = 1;
9646 break;
9647
9648 case 10000: hash_type = HASH_TYPE_SHA256;
9649 salt_type = SALT_TYPE_EMBEDDED;
9650 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9651 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9652 kern_type = KERN_TYPE_PBKDF2_SHA256;
9653 dgst_size = DGST_SIZE_4_32;
9654 parse_func = djangopbkdf2_parse_hash;
9655 sort_by_digest = sort_by_digest_4_32;
9656 opti_type = OPTI_TYPE_ZERO_BYTE
9657 | OPTI_TYPE_SLOW_HASH_SIMD;
9658 dgst_pos0 = 0;
9659 dgst_pos1 = 1;
9660 dgst_pos2 = 2;
9661 dgst_pos3 = 3;
9662 break;
9663
9664 case 10100: hash_type = HASH_TYPE_SIPHASH;
9665 salt_type = SALT_TYPE_EMBEDDED;
9666 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9667 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9668 kern_type = KERN_TYPE_SIPHASH;
9669 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9670 parse_func = siphash_parse_hash;
9671 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9672 opti_type = OPTI_TYPE_ZERO_BYTE
9673 | OPTI_TYPE_NOT_ITERATED
9674 | OPTI_TYPE_RAW_HASH;
9675 dgst_pos0 = 0;
9676 dgst_pos1 = 1;
9677 dgst_pos2 = 2;
9678 dgst_pos3 = 3;
9679 break;
9680
9681 case 10200: hash_type = HASH_TYPE_MD5;
9682 salt_type = SALT_TYPE_EMBEDDED;
9683 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9684 opts_type = OPTS_TYPE_PT_GENERATE_LE
9685 | OPTS_TYPE_ST_ADD80
9686 | OPTS_TYPE_ST_ADDBITS14;
9687 kern_type = KERN_TYPE_HMACMD5_PW;
9688 dgst_size = DGST_SIZE_4_4;
9689 parse_func = crammd5_parse_hash;
9690 sort_by_digest = sort_by_digest_4_4;
9691 opti_type = OPTI_TYPE_ZERO_BYTE
9692 | OPTI_TYPE_NOT_ITERATED;
9693 dgst_pos0 = 0;
9694 dgst_pos1 = 3;
9695 dgst_pos2 = 2;
9696 dgst_pos3 = 1;
9697 break;
9698
9699 case 10300: hash_type = HASH_TYPE_SHA1;
9700 salt_type = SALT_TYPE_EMBEDDED;
9701 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9702 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9703 kern_type = KERN_TYPE_SAPH_SHA1;
9704 dgst_size = DGST_SIZE_4_5;
9705 parse_func = saph_sha1_parse_hash;
9706 sort_by_digest = sort_by_digest_4_5;
9707 opti_type = OPTI_TYPE_ZERO_BYTE;
9708 dgst_pos0 = 0;
9709 dgst_pos1 = 1;
9710 dgst_pos2 = 2;
9711 dgst_pos3 = 3;
9712 break;
9713
9714 case 10400: hash_type = HASH_TYPE_PDFU16;
9715 salt_type = SALT_TYPE_EMBEDDED;
9716 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9717 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9718 kern_type = KERN_TYPE_PDF11;
9719 dgst_size = DGST_SIZE_4_4;
9720 parse_func = pdf11_parse_hash;
9721 sort_by_digest = sort_by_digest_4_4;
9722 opti_type = OPTI_TYPE_ZERO_BYTE
9723 | OPTI_TYPE_NOT_ITERATED;
9724 dgst_pos0 = 0;
9725 dgst_pos1 = 1;
9726 dgst_pos2 = 2;
9727 dgst_pos3 = 3;
9728 break;
9729
9730 case 10410: hash_type = HASH_TYPE_PDFU16;
9731 salt_type = SALT_TYPE_EMBEDDED;
9732 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9733 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9734 kern_type = KERN_TYPE_PDF11CM1;
9735 dgst_size = DGST_SIZE_4_4;
9736 parse_func = pdf11cm1_parse_hash;
9737 sort_by_digest = sort_by_digest_4_4;
9738 opti_type = OPTI_TYPE_ZERO_BYTE
9739 | OPTI_TYPE_NOT_ITERATED;
9740 dgst_pos0 = 0;
9741 dgst_pos1 = 1;
9742 dgst_pos2 = 2;
9743 dgst_pos3 = 3;
9744 break;
9745
9746 case 10420: hash_type = HASH_TYPE_PDFU16;
9747 salt_type = SALT_TYPE_EMBEDDED;
9748 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9749 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9750 kern_type = KERN_TYPE_PDF11CM2;
9751 dgst_size = DGST_SIZE_4_4;
9752 parse_func = pdf11cm2_parse_hash;
9753 sort_by_digest = sort_by_digest_4_4;
9754 opti_type = OPTI_TYPE_ZERO_BYTE
9755 | OPTI_TYPE_NOT_ITERATED;
9756 dgst_pos0 = 0;
9757 dgst_pos1 = 1;
9758 dgst_pos2 = 2;
9759 dgst_pos3 = 3;
9760 break;
9761
9762 case 10500: hash_type = HASH_TYPE_PDFU16;
9763 salt_type = SALT_TYPE_EMBEDDED;
9764 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9765 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9766 kern_type = KERN_TYPE_PDF14;
9767 dgst_size = DGST_SIZE_4_4;
9768 parse_func = pdf14_parse_hash;
9769 sort_by_digest = sort_by_digest_4_4;
9770 opti_type = OPTI_TYPE_ZERO_BYTE
9771 | OPTI_TYPE_NOT_ITERATED;
9772 dgst_pos0 = 0;
9773 dgst_pos1 = 1;
9774 dgst_pos2 = 2;
9775 dgst_pos3 = 3;
9776 break;
9777
9778 case 10600: hash_type = HASH_TYPE_SHA256;
9779 salt_type = SALT_TYPE_EMBEDDED;
9780 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9781 opts_type = OPTS_TYPE_PT_GENERATE_BE
9782 | OPTS_TYPE_ST_ADD80
9783 | OPTS_TYPE_ST_ADDBITS15
9784 | OPTS_TYPE_HASH_COPY;
9785 kern_type = KERN_TYPE_SHA256_PWSLT;
9786 dgst_size = DGST_SIZE_4_8;
9787 parse_func = pdf17l3_parse_hash;
9788 sort_by_digest = sort_by_digest_4_8;
9789 opti_type = OPTI_TYPE_ZERO_BYTE
9790 | OPTI_TYPE_PRECOMPUTE_INIT
9791 | OPTI_TYPE_PRECOMPUTE_MERKLE
9792 | OPTI_TYPE_EARLY_SKIP
9793 | OPTI_TYPE_NOT_ITERATED
9794 | OPTI_TYPE_APPENDED_SALT
9795 | OPTI_TYPE_RAW_HASH;
9796 dgst_pos0 = 3;
9797 dgst_pos1 = 7;
9798 dgst_pos2 = 2;
9799 dgst_pos3 = 6;
9800 break;
9801
9802 case 10700: hash_type = HASH_TYPE_PDFU32;
9803 salt_type = SALT_TYPE_EMBEDDED;
9804 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9805 opts_type = OPTS_TYPE_PT_GENERATE_LE
9806 | OPTS_TYPE_HASH_COPY;
9807 kern_type = KERN_TYPE_PDF17L8;
9808 dgst_size = DGST_SIZE_4_8;
9809 parse_func = pdf17l8_parse_hash;
9810 sort_by_digest = sort_by_digest_4_8;
9811 opti_type = OPTI_TYPE_ZERO_BYTE
9812 | OPTI_TYPE_NOT_ITERATED;
9813 dgst_pos0 = 0;
9814 dgst_pos1 = 1;
9815 dgst_pos2 = 2;
9816 dgst_pos3 = 3;
9817 break;
9818
9819 case 10800: hash_type = HASH_TYPE_SHA384;
9820 salt_type = SALT_TYPE_NONE;
9821 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9822 opts_type = OPTS_TYPE_PT_GENERATE_BE
9823 | OPTS_TYPE_PT_ADD80
9824 | OPTS_TYPE_PT_ADDBITS15;
9825 kern_type = KERN_TYPE_SHA384;
9826 dgst_size = DGST_SIZE_8_8;
9827 parse_func = sha384_parse_hash;
9828 sort_by_digest = sort_by_digest_8_8;
9829 opti_type = OPTI_TYPE_ZERO_BYTE
9830 | OPTI_TYPE_PRECOMPUTE_INIT
9831 | OPTI_TYPE_PRECOMPUTE_MERKLE
9832 | OPTI_TYPE_EARLY_SKIP
9833 | OPTI_TYPE_NOT_ITERATED
9834 | OPTI_TYPE_NOT_SALTED
9835 | OPTI_TYPE_USES_BITS_64
9836 | OPTI_TYPE_RAW_HASH;
9837 dgst_pos0 = 6;
9838 dgst_pos1 = 7;
9839 dgst_pos2 = 4;
9840 dgst_pos3 = 5;
9841 break;
9842
9843 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9844 salt_type = SALT_TYPE_EMBEDDED;
9845 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9846 opts_type = OPTS_TYPE_PT_GENERATE_LE
9847 | OPTS_TYPE_ST_BASE64
9848 | OPTS_TYPE_HASH_COPY;
9849 kern_type = KERN_TYPE_PBKDF2_SHA256;
9850 dgst_size = DGST_SIZE_4_32;
9851 parse_func = pbkdf2_sha256_parse_hash;
9852 sort_by_digest = sort_by_digest_4_32;
9853 opti_type = OPTI_TYPE_ZERO_BYTE
9854 | OPTI_TYPE_SLOW_HASH_SIMD;
9855 dgst_pos0 = 0;
9856 dgst_pos1 = 1;
9857 dgst_pos2 = 2;
9858 dgst_pos3 = 3;
9859 break;
9860
9861 case 11000: hash_type = HASH_TYPE_MD5;
9862 salt_type = SALT_TYPE_INTERN;
9863 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9864 opts_type = OPTS_TYPE_PT_GENERATE_LE
9865 | OPTS_TYPE_PT_ADD80;
9866 kern_type = KERN_TYPE_PRESTASHOP;
9867 dgst_size = DGST_SIZE_4_4;
9868 parse_func = prestashop_parse_hash;
9869 sort_by_digest = sort_by_digest_4_4;
9870 opti_type = OPTI_TYPE_ZERO_BYTE
9871 | OPTI_TYPE_PRECOMPUTE_INIT
9872 | OPTI_TYPE_NOT_ITERATED
9873 | OPTI_TYPE_PREPENDED_SALT;
9874 dgst_pos0 = 0;
9875 dgst_pos1 = 3;
9876 dgst_pos2 = 2;
9877 dgst_pos3 = 1;
9878 break;
9879
9880 case 11100: hash_type = HASH_TYPE_MD5;
9881 salt_type = SALT_TYPE_EMBEDDED;
9882 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9883 opts_type = OPTS_TYPE_PT_GENERATE_LE
9884 | OPTS_TYPE_ST_ADD80;
9885 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9886 dgst_size = DGST_SIZE_4_4;
9887 parse_func = postgresql_auth_parse_hash;
9888 sort_by_digest = sort_by_digest_4_4;
9889 opti_type = OPTI_TYPE_ZERO_BYTE
9890 | OPTI_TYPE_PRECOMPUTE_INIT
9891 | OPTI_TYPE_PRECOMPUTE_MERKLE
9892 | OPTI_TYPE_EARLY_SKIP;
9893 dgst_pos0 = 0;
9894 dgst_pos1 = 3;
9895 dgst_pos2 = 2;
9896 dgst_pos3 = 1;
9897 break;
9898
9899 case 11200: hash_type = HASH_TYPE_SHA1;
9900 salt_type = SALT_TYPE_EMBEDDED;
9901 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9902 opts_type = OPTS_TYPE_PT_GENERATE_BE
9903 | OPTS_TYPE_PT_ADD80
9904 | OPTS_TYPE_ST_HEX;
9905 kern_type = KERN_TYPE_MYSQL_AUTH;
9906 dgst_size = DGST_SIZE_4_5;
9907 parse_func = mysql_auth_parse_hash;
9908 sort_by_digest = sort_by_digest_4_5;
9909 opti_type = OPTI_TYPE_ZERO_BYTE
9910 | OPTI_TYPE_EARLY_SKIP;
9911 dgst_pos0 = 3;
9912 dgst_pos1 = 4;
9913 dgst_pos2 = 2;
9914 dgst_pos3 = 1;
9915 break;
9916
9917 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9918 salt_type = SALT_TYPE_EMBEDDED;
9919 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9920 opts_type = OPTS_TYPE_PT_GENERATE_LE
9921 | OPTS_TYPE_ST_HEX
9922 | OPTS_TYPE_ST_ADD80;
9923 kern_type = KERN_TYPE_BITCOIN_WALLET;
9924 dgst_size = DGST_SIZE_4_4;
9925 parse_func = bitcoin_wallet_parse_hash;
9926 sort_by_digest = sort_by_digest_4_4;
9927 opti_type = OPTI_TYPE_ZERO_BYTE;
9928 dgst_pos0 = 0;
9929 dgst_pos1 = 1;
9930 dgst_pos2 = 2;
9931 dgst_pos3 = 3;
9932 break;
9933
9934 case 11400: hash_type = HASH_TYPE_MD5;
9935 salt_type = SALT_TYPE_EMBEDDED;
9936 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9937 opts_type = OPTS_TYPE_PT_GENERATE_LE
9938 | OPTS_TYPE_PT_ADD80
9939 | OPTS_TYPE_HASH_COPY;
9940 kern_type = KERN_TYPE_SIP_AUTH;
9941 dgst_size = DGST_SIZE_4_4;
9942 parse_func = sip_auth_parse_hash;
9943 sort_by_digest = sort_by_digest_4_4;
9944 opti_type = OPTI_TYPE_ZERO_BYTE;
9945 dgst_pos0 = 0;
9946 dgst_pos1 = 3;
9947 dgst_pos2 = 2;
9948 dgst_pos3 = 1;
9949 break;
9950
9951 case 11500: hash_type = HASH_TYPE_CRC32;
9952 salt_type = SALT_TYPE_INTERN;
9953 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9954 opts_type = OPTS_TYPE_PT_GENERATE_LE
9955 | OPTS_TYPE_ST_GENERATE_LE
9956 | OPTS_TYPE_ST_HEX;
9957 kern_type = KERN_TYPE_CRC32;
9958 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9959 parse_func = crc32_parse_hash;
9960 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9961 opti_type = OPTI_TYPE_ZERO_BYTE;
9962 dgst_pos0 = 0;
9963 dgst_pos1 = 1;
9964 dgst_pos2 = 2;
9965 dgst_pos3 = 3;
9966 break;
9967
9968 case 11600: hash_type = HASH_TYPE_AES;
9969 salt_type = SALT_TYPE_EMBEDDED;
9970 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9971 opts_type = OPTS_TYPE_PT_GENERATE_LE
9972 | OPTS_TYPE_PT_NEVERCRACK;
9973 kern_type = KERN_TYPE_SEVEN_ZIP;
9974 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9975 parse_func = seven_zip_parse_hash;
9976 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9977 opti_type = OPTI_TYPE_ZERO_BYTE;
9978 dgst_pos0 = 0;
9979 dgst_pos1 = 1;
9980 dgst_pos2 = 2;
9981 dgst_pos3 = 3;
9982 break;
9983
9984 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9985 salt_type = SALT_TYPE_NONE;
9986 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9987 opts_type = OPTS_TYPE_PT_GENERATE_LE
9988 | OPTS_TYPE_PT_ADD01;
9989 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9990 dgst_size = DGST_SIZE_4_8;
9991 parse_func = gost2012sbog_256_parse_hash;
9992 sort_by_digest = sort_by_digest_4_8;
9993 opti_type = OPTI_TYPE_ZERO_BYTE;
9994 dgst_pos0 = 0;
9995 dgst_pos1 = 1;
9996 dgst_pos2 = 2;
9997 dgst_pos3 = 3;
9998 break;
9999
10000 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10001 salt_type = SALT_TYPE_NONE;
10002 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10003 opts_type = OPTS_TYPE_PT_GENERATE_LE
10004 | OPTS_TYPE_PT_ADD01;
10005 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10006 dgst_size = DGST_SIZE_4_16;
10007 parse_func = gost2012sbog_512_parse_hash;
10008 sort_by_digest = sort_by_digest_4_16;
10009 opti_type = OPTI_TYPE_ZERO_BYTE;
10010 dgst_pos0 = 0;
10011 dgst_pos1 = 1;
10012 dgst_pos2 = 2;
10013 dgst_pos3 = 3;
10014 break;
10015
10016 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10017 salt_type = SALT_TYPE_EMBEDDED;
10018 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10019 opts_type = OPTS_TYPE_PT_GENERATE_LE
10020 | OPTS_TYPE_ST_BASE64
10021 | OPTS_TYPE_HASH_COPY;
10022 kern_type = KERN_TYPE_PBKDF2_MD5;
10023 dgst_size = DGST_SIZE_4_32;
10024 parse_func = pbkdf2_md5_parse_hash;
10025 sort_by_digest = sort_by_digest_4_32;
10026 opti_type = OPTI_TYPE_ZERO_BYTE
10027 | OPTI_TYPE_SLOW_HASH_SIMD;
10028 dgst_pos0 = 0;
10029 dgst_pos1 = 1;
10030 dgst_pos2 = 2;
10031 dgst_pos3 = 3;
10032 break;
10033
10034 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10035 salt_type = SALT_TYPE_EMBEDDED;
10036 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10037 opts_type = OPTS_TYPE_PT_GENERATE_LE
10038 | OPTS_TYPE_ST_BASE64
10039 | OPTS_TYPE_HASH_COPY;
10040 kern_type = KERN_TYPE_PBKDF2_SHA1;
10041 dgst_size = DGST_SIZE_4_32;
10042 parse_func = pbkdf2_sha1_parse_hash;
10043 sort_by_digest = sort_by_digest_4_32;
10044 opti_type = OPTI_TYPE_ZERO_BYTE
10045 | OPTI_TYPE_SLOW_HASH_SIMD;
10046 dgst_pos0 = 0;
10047 dgst_pos1 = 1;
10048 dgst_pos2 = 2;
10049 dgst_pos3 = 3;
10050 break;
10051
10052 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10053 salt_type = SALT_TYPE_EMBEDDED;
10054 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10055 opts_type = OPTS_TYPE_PT_GENERATE_LE
10056 | OPTS_TYPE_ST_BASE64
10057 | OPTS_TYPE_HASH_COPY;
10058 kern_type = KERN_TYPE_PBKDF2_SHA512;
10059 dgst_size = DGST_SIZE_8_16;
10060 parse_func = pbkdf2_sha512_parse_hash;
10061 sort_by_digest = sort_by_digest_8_16;
10062 opti_type = OPTI_TYPE_ZERO_BYTE
10063 | OPTI_TYPE_USES_BITS_64
10064 | OPTI_TYPE_SLOW_HASH_SIMD;
10065 dgst_pos0 = 0;
10066 dgst_pos1 = 1;
10067 dgst_pos2 = 2;
10068 dgst_pos3 = 3;
10069 break;
10070
10071 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10072 salt_type = SALT_TYPE_EMBEDDED;
10073 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10074 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10075 kern_type = KERN_TYPE_ECRYPTFS;
10076 dgst_size = DGST_SIZE_8_8;
10077 parse_func = ecryptfs_parse_hash;
10078 sort_by_digest = sort_by_digest_8_8;
10079 opti_type = OPTI_TYPE_ZERO_BYTE
10080 | OPTI_TYPE_USES_BITS_64;
10081 dgst_pos0 = 0;
10082 dgst_pos1 = 1;
10083 dgst_pos2 = 2;
10084 dgst_pos3 = 3;
10085 break;
10086
10087 case 12300: hash_type = HASH_TYPE_ORACLET;
10088 salt_type = SALT_TYPE_EMBEDDED;
10089 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10090 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10091 kern_type = KERN_TYPE_ORACLET;
10092 dgst_size = DGST_SIZE_8_16;
10093 parse_func = oraclet_parse_hash;
10094 sort_by_digest = sort_by_digest_8_16;
10095 opti_type = OPTI_TYPE_ZERO_BYTE
10096 | OPTI_TYPE_USES_BITS_64;
10097 dgst_pos0 = 0;
10098 dgst_pos1 = 1;
10099 dgst_pos2 = 2;
10100 dgst_pos3 = 3;
10101 break;
10102
10103 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10104 salt_type = SALT_TYPE_EMBEDDED;
10105 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10106 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10107 kern_type = KERN_TYPE_BSDICRYPT;
10108 dgst_size = DGST_SIZE_4_4;
10109 parse_func = bsdicrypt_parse_hash;
10110 sort_by_digest = sort_by_digest_4_4;
10111 opti_type = OPTI_TYPE_ZERO_BYTE
10112 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10113 dgst_pos0 = 0;
10114 dgst_pos1 = 1;
10115 dgst_pos2 = 2;
10116 dgst_pos3 = 3;
10117 break;
10118
10119 case 12500: hash_type = HASH_TYPE_RAR3HP;
10120 salt_type = SALT_TYPE_EMBEDDED;
10121 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10122 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10123 kern_type = KERN_TYPE_RAR3;
10124 dgst_size = DGST_SIZE_4_4;
10125 parse_func = rar3hp_parse_hash;
10126 sort_by_digest = sort_by_digest_4_4;
10127 opti_type = OPTI_TYPE_ZERO_BYTE;
10128 dgst_pos0 = 0;
10129 dgst_pos1 = 1;
10130 dgst_pos2 = 2;
10131 dgst_pos3 = 3;
10132 break;
10133
10134 case 12600: hash_type = HASH_TYPE_SHA256;
10135 salt_type = SALT_TYPE_INTERN;
10136 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10137 opts_type = OPTS_TYPE_PT_GENERATE_BE
10138 | OPTS_TYPE_PT_ADD80;
10139 kern_type = KERN_TYPE_CF10;
10140 dgst_size = DGST_SIZE_4_8;
10141 parse_func = cf10_parse_hash;
10142 sort_by_digest = sort_by_digest_4_8;
10143 opti_type = OPTI_TYPE_ZERO_BYTE
10144 | OPTI_TYPE_PRECOMPUTE_INIT
10145 | OPTI_TYPE_EARLY_SKIP
10146 | OPTI_TYPE_NOT_ITERATED;
10147 dgst_pos0 = 3;
10148 dgst_pos1 = 7;
10149 dgst_pos2 = 2;
10150 dgst_pos3 = 6;
10151 break;
10152
10153 case 12700: hash_type = HASH_TYPE_AES;
10154 salt_type = SALT_TYPE_EMBEDDED;
10155 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10156 opts_type = OPTS_TYPE_PT_GENERATE_LE
10157 | OPTS_TYPE_HASH_COPY;
10158 kern_type = KERN_TYPE_MYWALLET;
10159 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10160 parse_func = mywallet_parse_hash;
10161 sort_by_digest = sort_by_digest_4_5;
10162 opti_type = OPTI_TYPE_ZERO_BYTE;
10163 dgst_pos0 = 0;
10164 dgst_pos1 = 1;
10165 dgst_pos2 = 2;
10166 dgst_pos3 = 3;
10167 break;
10168
10169 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10170 salt_type = SALT_TYPE_EMBEDDED;
10171 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10172 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10173 kern_type = KERN_TYPE_MS_DRSR;
10174 dgst_size = DGST_SIZE_4_8;
10175 parse_func = ms_drsr_parse_hash;
10176 sort_by_digest = sort_by_digest_4_8;
10177 opti_type = OPTI_TYPE_ZERO_BYTE;
10178 dgst_pos0 = 0;
10179 dgst_pos1 = 1;
10180 dgst_pos2 = 2;
10181 dgst_pos3 = 3;
10182 break;
10183
10184 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10185 salt_type = SALT_TYPE_EMBEDDED;
10186 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10187 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10188 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10189 dgst_size = DGST_SIZE_4_8;
10190 parse_func = androidfde_samsung_parse_hash;
10191 sort_by_digest = sort_by_digest_4_8;
10192 opti_type = OPTI_TYPE_ZERO_BYTE;
10193 dgst_pos0 = 0;
10194 dgst_pos1 = 1;
10195 dgst_pos2 = 2;
10196 dgst_pos3 = 3;
10197 break;
10198
10199 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10200 salt_type = SALT_TYPE_EMBEDDED;
10201 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10202 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10203 kern_type = KERN_TYPE_RAR5;
10204 dgst_size = DGST_SIZE_4_4;
10205 parse_func = rar5_parse_hash;
10206 sort_by_digest = sort_by_digest_4_4;
10207 opti_type = OPTI_TYPE_ZERO_BYTE;
10208 dgst_pos0 = 0;
10209 dgst_pos1 = 1;
10210 dgst_pos2 = 2;
10211 dgst_pos3 = 3;
10212 break;
10213
10214 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10215 salt_type = SALT_TYPE_EMBEDDED;
10216 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10217 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10218 kern_type = KERN_TYPE_KRB5TGS;
10219 dgst_size = DGST_SIZE_4_4;
10220 parse_func = krb5tgs_parse_hash;
10221 sort_by_digest = sort_by_digest_4_4;
10222 opti_type = OPTI_TYPE_ZERO_BYTE
10223 | OPTI_TYPE_NOT_ITERATED;
10224 dgst_pos0 = 0;
10225 dgst_pos1 = 1;
10226 dgst_pos2 = 2;
10227 dgst_pos3 = 3;
10228 break;
10229
10230 case 13200: hash_type = HASH_TYPE_AES;
10231 salt_type = SALT_TYPE_EMBEDDED;
10232 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10233 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10234 kern_type = KERN_TYPE_AXCRYPT;
10235 dgst_size = DGST_SIZE_4_4;
10236 parse_func = axcrypt_parse_hash;
10237 sort_by_digest = sort_by_digest_4_4;
10238 opti_type = OPTI_TYPE_ZERO_BYTE;
10239 dgst_pos0 = 0;
10240 dgst_pos1 = 1;
10241 dgst_pos2 = 2;
10242 dgst_pos3 = 3;
10243 break;
10244
10245 case 13300: hash_type = HASH_TYPE_SHA1;
10246 salt_type = SALT_TYPE_NONE;
10247 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10248 opts_type = OPTS_TYPE_PT_GENERATE_BE
10249 | OPTS_TYPE_PT_ADD80
10250 | OPTS_TYPE_PT_ADDBITS15;
10251 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10252 dgst_size = DGST_SIZE_4_5;
10253 parse_func = sha1axcrypt_parse_hash;
10254 sort_by_digest = sort_by_digest_4_5;
10255 opti_type = OPTI_TYPE_ZERO_BYTE
10256 | OPTI_TYPE_PRECOMPUTE_INIT
10257 | OPTI_TYPE_EARLY_SKIP
10258 | OPTI_TYPE_NOT_ITERATED
10259 | OPTI_TYPE_NOT_SALTED;
10260 dgst_pos0 = 0;
10261 dgst_pos1 = 4;
10262 dgst_pos2 = 3;
10263 dgst_pos3 = 2;
10264 break;
10265
10266 case 13400: hash_type = HASH_TYPE_AES;
10267 salt_type = SALT_TYPE_EMBEDDED;
10268 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10269 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10270 kern_type = KERN_TYPE_KEEPASS;
10271 dgst_size = DGST_SIZE_4_4;
10272 parse_func = keepass_parse_hash;
10273 sort_by_digest = sort_by_digest_4_4;
10274 opti_type = OPTI_TYPE_ZERO_BYTE;
10275 dgst_pos0 = 0;
10276 dgst_pos1 = 1;
10277 dgst_pos2 = 2;
10278 dgst_pos3 = 3;
10279 break;
10280
10281 case 13500: hash_type = HASH_TYPE_SHA1;
10282 salt_type = SALT_TYPE_EMBEDDED;
10283 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10284 opts_type = OPTS_TYPE_PT_GENERATE_BE
10285 | OPTS_TYPE_PT_UNICODE
10286 | OPTS_TYPE_PT_ADD80;
10287 kern_type = KERN_TYPE_PSTOKEN;
10288 dgst_size = DGST_SIZE_4_5;
10289 parse_func = pstoken_parse_hash;
10290 sort_by_digest = sort_by_digest_4_5;
10291 opti_type = OPTI_TYPE_ZERO_BYTE
10292 | OPTI_TYPE_PRECOMPUTE_INIT
10293 | OPTI_TYPE_EARLY_SKIP
10294 | OPTI_TYPE_NOT_ITERATED
10295 | OPTI_TYPE_PREPENDED_SALT
10296 | OPTI_TYPE_RAW_HASH;
10297 dgst_pos0 = 3;
10298 dgst_pos1 = 4;
10299 dgst_pos2 = 2;
10300 dgst_pos3 = 1;
10301 break;
10302
10303 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10304 salt_type = SALT_TYPE_EMBEDDED;
10305 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10306 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10307 kern_type = KERN_TYPE_ZIP2;
10308 dgst_size = DGST_SIZE_4_4;
10309 parse_func = zip2_parse_hash;
10310 sort_by_digest = sort_by_digest_4_4;
10311 opti_type = OPTI_TYPE_ZERO_BYTE;
10312 dgst_pos0 = 0;
10313 dgst_pos1 = 1;
10314 dgst_pos2 = 2;
10315 dgst_pos3 = 3;
10316 break;
10317
10318 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10319 salt_type = SALT_TYPE_EMBEDDED;
10320 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10321 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10322 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10323 dgst_size = DGST_SIZE_4_5;
10324 parse_func = veracrypt_parse_hash_655331;
10325 sort_by_digest = sort_by_digest_4_5;
10326 opti_type = OPTI_TYPE_ZERO_BYTE;
10327 dgst_pos0 = 0;
10328 dgst_pos1 = 1;
10329 dgst_pos2 = 2;
10330 dgst_pos3 = 3;
10331 break;
10332
10333 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10334 salt_type = SALT_TYPE_EMBEDDED;
10335 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10336 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10337 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10338 dgst_size = DGST_SIZE_4_5;
10339 parse_func = veracrypt_parse_hash_655331;
10340 sort_by_digest = sort_by_digest_4_5;
10341 opti_type = OPTI_TYPE_ZERO_BYTE;
10342 dgst_pos0 = 0;
10343 dgst_pos1 = 1;
10344 dgst_pos2 = 2;
10345 dgst_pos3 = 3;
10346 break;
10347
10348 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10349 salt_type = SALT_TYPE_EMBEDDED;
10350 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10351 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10352 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10353 dgst_size = DGST_SIZE_4_5;
10354 parse_func = veracrypt_parse_hash_655331;
10355 sort_by_digest = sort_by_digest_4_5;
10356 opti_type = OPTI_TYPE_ZERO_BYTE;
10357 dgst_pos0 = 0;
10358 dgst_pos1 = 1;
10359 dgst_pos2 = 2;
10360 dgst_pos3 = 3;
10361 break;
10362
10363 case 13721: hash_type = HASH_TYPE_SHA512;
10364 salt_type = SALT_TYPE_EMBEDDED;
10365 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10366 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10367 kern_type = KERN_TYPE_TCSHA512_XTS512;
10368 dgst_size = DGST_SIZE_8_8;
10369 parse_func = veracrypt_parse_hash_500000;
10370 sort_by_digest = sort_by_digest_8_8;
10371 opti_type = OPTI_TYPE_ZERO_BYTE
10372 | OPTI_TYPE_USES_BITS_64;
10373 dgst_pos0 = 0;
10374 dgst_pos1 = 1;
10375 dgst_pos2 = 2;
10376 dgst_pos3 = 3;
10377 break;
10378
10379 case 13722: hash_type = HASH_TYPE_SHA512;
10380 salt_type = SALT_TYPE_EMBEDDED;
10381 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10382 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10383 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10384 dgst_size = DGST_SIZE_8_8;
10385 parse_func = veracrypt_parse_hash_500000;
10386 sort_by_digest = sort_by_digest_8_8;
10387 opti_type = OPTI_TYPE_ZERO_BYTE
10388 | OPTI_TYPE_USES_BITS_64;
10389 dgst_pos0 = 0;
10390 dgst_pos1 = 1;
10391 dgst_pos2 = 2;
10392 dgst_pos3 = 3;
10393 break;
10394
10395 case 13723: hash_type = HASH_TYPE_SHA512;
10396 salt_type = SALT_TYPE_EMBEDDED;
10397 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10398 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10399 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10400 dgst_size = DGST_SIZE_8_8;
10401 parse_func = veracrypt_parse_hash_500000;
10402 sort_by_digest = sort_by_digest_8_8;
10403 opti_type = OPTI_TYPE_ZERO_BYTE
10404 | OPTI_TYPE_USES_BITS_64;
10405 dgst_pos0 = 0;
10406 dgst_pos1 = 1;
10407 dgst_pos2 = 2;
10408 dgst_pos3 = 3;
10409 break;
10410
10411 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10412 salt_type = SALT_TYPE_EMBEDDED;
10413 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10414 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10415 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10416 dgst_size = DGST_SIZE_4_8;
10417 parse_func = veracrypt_parse_hash_500000;
10418 sort_by_digest = sort_by_digest_4_8;
10419 opti_type = OPTI_TYPE_ZERO_BYTE;
10420 dgst_pos0 = 0;
10421 dgst_pos1 = 1;
10422 dgst_pos2 = 2;
10423 dgst_pos3 = 3;
10424 break;
10425
10426 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10427 salt_type = SALT_TYPE_EMBEDDED;
10428 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10429 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10430 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10431 dgst_size = DGST_SIZE_4_8;
10432 parse_func = veracrypt_parse_hash_500000;
10433 sort_by_digest = sort_by_digest_4_8;
10434 opti_type = OPTI_TYPE_ZERO_BYTE;
10435 dgst_pos0 = 0;
10436 dgst_pos1 = 1;
10437 dgst_pos2 = 2;
10438 dgst_pos3 = 3;
10439 break;
10440
10441 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10442 salt_type = SALT_TYPE_EMBEDDED;
10443 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10444 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10445 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10446 dgst_size = DGST_SIZE_4_8;
10447 parse_func = veracrypt_parse_hash_500000;
10448 sort_by_digest = sort_by_digest_4_8;
10449 opti_type = OPTI_TYPE_ZERO_BYTE;
10450 dgst_pos0 = 0;
10451 dgst_pos1 = 1;
10452 dgst_pos2 = 2;
10453 dgst_pos3 = 3;
10454 break;
10455
10456 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10457 salt_type = SALT_TYPE_EMBEDDED;
10458 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10459 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10460 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10461 dgst_size = DGST_SIZE_4_5;
10462 parse_func = veracrypt_parse_hash_327661;
10463 sort_by_digest = sort_by_digest_4_5;
10464 opti_type = OPTI_TYPE_ZERO_BYTE;
10465 dgst_pos0 = 0;
10466 dgst_pos1 = 1;
10467 dgst_pos2 = 2;
10468 dgst_pos3 = 3;
10469 break;
10470
10471 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10472 salt_type = SALT_TYPE_EMBEDDED;
10473 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10474 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10475 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10476 dgst_size = DGST_SIZE_4_5;
10477 parse_func = veracrypt_parse_hash_327661;
10478 sort_by_digest = sort_by_digest_4_5;
10479 opti_type = OPTI_TYPE_ZERO_BYTE;
10480 dgst_pos0 = 0;
10481 dgst_pos1 = 1;
10482 dgst_pos2 = 2;
10483 dgst_pos3 = 3;
10484 break;
10485
10486 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10487 salt_type = SALT_TYPE_EMBEDDED;
10488 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10489 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10490 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10491 dgst_size = DGST_SIZE_4_5;
10492 parse_func = veracrypt_parse_hash_327661;
10493 sort_by_digest = sort_by_digest_4_5;
10494 opti_type = OPTI_TYPE_ZERO_BYTE;
10495 dgst_pos0 = 0;
10496 dgst_pos1 = 1;
10497 dgst_pos2 = 2;
10498 dgst_pos3 = 3;
10499 break;
10500
10501 case 13751: hash_type = HASH_TYPE_SHA256;
10502 salt_type = SALT_TYPE_EMBEDDED;
10503 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10504 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10505 kern_type = KERN_TYPE_VCSHA256_XTS512;
10506 dgst_size = DGST_SIZE_4_8;
10507 parse_func = veracrypt_parse_hash_500000;
10508 sort_by_digest = sort_by_digest_4_8;
10509 opti_type = OPTI_TYPE_ZERO_BYTE;
10510 dgst_pos0 = 0;
10511 dgst_pos1 = 1;
10512 dgst_pos2 = 2;
10513 dgst_pos3 = 3;
10514 break;
10515
10516 case 13752: hash_type = HASH_TYPE_SHA256;
10517 salt_type = SALT_TYPE_EMBEDDED;
10518 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10519 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10520 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10521 dgst_size = DGST_SIZE_4_8;
10522 parse_func = veracrypt_parse_hash_500000;
10523 sort_by_digest = sort_by_digest_4_8;
10524 opti_type = OPTI_TYPE_ZERO_BYTE;
10525 dgst_pos0 = 0;
10526 dgst_pos1 = 1;
10527 dgst_pos2 = 2;
10528 dgst_pos3 = 3;
10529 break;
10530
10531 case 13753: hash_type = HASH_TYPE_SHA256;
10532 salt_type = SALT_TYPE_EMBEDDED;
10533 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10534 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10535 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10536 dgst_size = DGST_SIZE_4_8;
10537 parse_func = veracrypt_parse_hash_500000;
10538 sort_by_digest = sort_by_digest_4_8;
10539 opti_type = OPTI_TYPE_ZERO_BYTE;
10540 dgst_pos0 = 0;
10541 dgst_pos1 = 1;
10542 dgst_pos2 = 2;
10543 dgst_pos3 = 3;
10544 break;
10545
10546 case 13761: hash_type = HASH_TYPE_SHA256;
10547 salt_type = SALT_TYPE_EMBEDDED;
10548 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10549 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10550 kern_type = KERN_TYPE_VCSHA256_XTS512;
10551 dgst_size = DGST_SIZE_4_8;
10552 parse_func = veracrypt_parse_hash_200000;
10553 sort_by_digest = sort_by_digest_4_8;
10554 opti_type = OPTI_TYPE_ZERO_BYTE;
10555 dgst_pos0 = 0;
10556 dgst_pos1 = 1;
10557 dgst_pos2 = 2;
10558 dgst_pos3 = 3;
10559 break;
10560
10561 case 13762: hash_type = HASH_TYPE_SHA256;
10562 salt_type = SALT_TYPE_EMBEDDED;
10563 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10564 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10565 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10566 dgst_size = DGST_SIZE_4_8;
10567 parse_func = veracrypt_parse_hash_200000;
10568 sort_by_digest = sort_by_digest_4_8;
10569 opti_type = OPTI_TYPE_ZERO_BYTE;
10570 dgst_pos0 = 0;
10571 dgst_pos1 = 1;
10572 dgst_pos2 = 2;
10573 dgst_pos3 = 3;
10574 break;
10575
10576 case 13763: hash_type = HASH_TYPE_SHA256;
10577 salt_type = SALT_TYPE_EMBEDDED;
10578 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10579 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10580 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10581 dgst_size = DGST_SIZE_4_8;
10582 parse_func = veracrypt_parse_hash_200000;
10583 sort_by_digest = sort_by_digest_4_8;
10584 opti_type = OPTI_TYPE_ZERO_BYTE;
10585 dgst_pos0 = 0;
10586 dgst_pos1 = 1;
10587 dgst_pos2 = 2;
10588 dgst_pos3 = 3;
10589 break;
10590
10591 default: usage_mini_print (PROGNAME); return (-1);
10592 }
10593
10594 /**
10595 * parser
10596 */
10597
10598 data.parse_func = parse_func;
10599
10600 /**
10601 * misc stuff
10602 */
10603
10604 if (hex_salt)
10605 {
10606 if (salt_type == SALT_TYPE_INTERN)
10607 {
10608 opts_type |= OPTS_TYPE_ST_HEX;
10609 }
10610 else
10611 {
10612 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10613
10614 return (-1);
10615 }
10616 }
10617
10618 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10619 | (salt_type == SALT_TYPE_EXTERN)
10620 | (salt_type == SALT_TYPE_EMBEDDED)
10621 | (salt_type == SALT_TYPE_VIRTUAL));
10622
10623 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10624
10625 data.hash_type = hash_type;
10626 data.attack_mode = attack_mode;
10627 data.attack_kern = attack_kern;
10628 data.attack_exec = attack_exec;
10629 data.kern_type = kern_type;
10630 data.opts_type = opts_type;
10631 data.dgst_size = dgst_size;
10632 data.salt_type = salt_type;
10633 data.isSalted = isSalted;
10634 data.sort_by_digest = sort_by_digest;
10635 data.dgst_pos0 = dgst_pos0;
10636 data.dgst_pos1 = dgst_pos1;
10637 data.dgst_pos2 = dgst_pos2;
10638 data.dgst_pos3 = dgst_pos3;
10639
10640 esalt_size = 0;
10641
10642 switch (hash_mode)
10643 {
10644 case 2500: esalt_size = sizeof (wpa_t); break;
10645 case 5300: esalt_size = sizeof (ikepsk_t); break;
10646 case 5400: esalt_size = sizeof (ikepsk_t); break;
10647 case 5500: esalt_size = sizeof (netntlm_t); break;
10648 case 5600: esalt_size = sizeof (netntlm_t); break;
10649 case 6211: esalt_size = sizeof (tc_t); break;
10650 case 6212: esalt_size = sizeof (tc_t); break;
10651 case 6213: esalt_size = sizeof (tc_t); break;
10652 case 6221: esalt_size = sizeof (tc_t); break;
10653 case 6222: esalt_size = sizeof (tc_t); break;
10654 case 6223: esalt_size = sizeof (tc_t); break;
10655 case 6231: esalt_size = sizeof (tc_t); break;
10656 case 6232: esalt_size = sizeof (tc_t); break;
10657 case 6233: esalt_size = sizeof (tc_t); break;
10658 case 6241: esalt_size = sizeof (tc_t); break;
10659 case 6242: esalt_size = sizeof (tc_t); break;
10660 case 6243: esalt_size = sizeof (tc_t); break;
10661 case 6600: esalt_size = sizeof (agilekey_t); break;
10662 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10663 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10664 case 7300: esalt_size = sizeof (rakp_t); break;
10665 case 7500: esalt_size = sizeof (krb5pa_t); break;
10666 case 8200: esalt_size = sizeof (cloudkey_t); break;
10667 case 8800: esalt_size = sizeof (androidfde_t); break;
10668 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10669 case 9400: esalt_size = sizeof (office2007_t); break;
10670 case 9500: esalt_size = sizeof (office2010_t); break;
10671 case 9600: esalt_size = sizeof (office2013_t); break;
10672 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10673 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10674 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10675 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10676 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10677 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10678 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10679 case 10200: esalt_size = sizeof (cram_md5_t); break;
10680 case 10400: esalt_size = sizeof (pdf_t); break;
10681 case 10410: esalt_size = sizeof (pdf_t); break;
10682 case 10420: esalt_size = sizeof (pdf_t); break;
10683 case 10500: esalt_size = sizeof (pdf_t); break;
10684 case 10600: esalt_size = sizeof (pdf_t); break;
10685 case 10700: esalt_size = sizeof (pdf_t); break;
10686 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10687 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10688 case 11400: esalt_size = sizeof (sip_t); break;
10689 case 11600: esalt_size = sizeof (seven_zip_t); break;
10690 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10691 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10692 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10693 case 13000: esalt_size = sizeof (rar5_t); break;
10694 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10695 case 13400: esalt_size = sizeof (keepass_t); break;
10696 case 13500: esalt_size = sizeof (pstoken_t); break;
10697 case 13600: esalt_size = sizeof (zip2_t); break;
10698 case 13711: esalt_size = sizeof (tc_t); break;
10699 case 13712: esalt_size = sizeof (tc_t); break;
10700 case 13713: esalt_size = sizeof (tc_t); break;
10701 case 13721: esalt_size = sizeof (tc_t); break;
10702 case 13722: esalt_size = sizeof (tc_t); break;
10703 case 13723: esalt_size = sizeof (tc_t); break;
10704 case 13731: esalt_size = sizeof (tc_t); break;
10705 case 13732: esalt_size = sizeof (tc_t); break;
10706 case 13733: esalt_size = sizeof (tc_t); break;
10707 case 13741: esalt_size = sizeof (tc_t); break;
10708 case 13742: esalt_size = sizeof (tc_t); break;
10709 case 13743: esalt_size = sizeof (tc_t); break;
10710 case 13751: esalt_size = sizeof (tc_t); break;
10711 case 13752: esalt_size = sizeof (tc_t); break;
10712 case 13753: esalt_size = sizeof (tc_t); break;
10713 case 13761: esalt_size = sizeof (tc_t); break;
10714 case 13762: esalt_size = sizeof (tc_t); break;
10715 case 13763: esalt_size = sizeof (tc_t); break;
10716 }
10717
10718 data.esalt_size = esalt_size;
10719
10720 /**
10721 * choose dictionary parser
10722 */
10723
10724 if (hash_type == HASH_TYPE_LM)
10725 {
10726 get_next_word_func = get_next_word_lm;
10727 }
10728 else if (opts_type & OPTS_TYPE_PT_UPPER)
10729 {
10730 get_next_word_func = get_next_word_uc;
10731 }
10732 else
10733 {
10734 get_next_word_func = get_next_word_std;
10735 }
10736
10737 /**
10738 * dictstat
10739 */
10740
10741 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10742
10743 #ifdef _POSIX
10744 size_t dictstat_nmemb = 0;
10745 #endif
10746
10747 #ifdef _WIN
10748 uint dictstat_nmemb = 0;
10749 #endif
10750
10751 char dictstat[256] = { 0 };
10752
10753 FILE *dictstat_fp = NULL;
10754
10755 if (keyspace == 0)
10756 {
10757 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10758
10759 dictstat_fp = fopen (dictstat, "rb");
10760
10761 if (dictstat_fp)
10762 {
10763 #ifdef _POSIX
10764 struct stat tmpstat;
10765
10766 fstat (fileno (dictstat_fp), &tmpstat);
10767 #endif
10768
10769 #ifdef _WIN
10770 struct stat64 tmpstat;
10771
10772 _fstat64 (fileno (dictstat_fp), &tmpstat);
10773 #endif
10774
10775 if (tmpstat.st_mtime < COMPTIME)
10776 {
10777 /* with v0.15 the format changed so we have to ensure user is using a good version
10778 since there is no version-header in the dictstat file */
10779
10780 fclose (dictstat_fp);
10781
10782 unlink (dictstat);
10783 }
10784 else
10785 {
10786 while (!feof (dictstat_fp))
10787 {
10788 dictstat_t d;
10789
10790 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10791
10792 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10793
10794 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10795 {
10796 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10797
10798 return -1;
10799 }
10800 }
10801
10802 fclose (dictstat_fp);
10803 }
10804 }
10805 }
10806
10807 /**
10808 * potfile
10809 */
10810
10811 char potfile[256] = { 0 };
10812
10813 if (potfile_path == NULL)
10814 {
10815 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10816 }
10817 else
10818 {
10819 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10820 }
10821
10822 data.pot_fp = NULL;
10823
10824 FILE *out_fp = NULL;
10825 FILE *pot_fp = NULL;
10826
10827 if (show == 1 || left == 1)
10828 {
10829 pot_fp = fopen (potfile, "rb");
10830
10831 if (pot_fp == NULL)
10832 {
10833 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10834
10835 return (-1);
10836 }
10837
10838 if (outfile != NULL)
10839 {
10840 if ((out_fp = fopen (outfile, "ab")) == NULL)
10841 {
10842 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10843
10844 fclose (pot_fp);
10845
10846 return (-1);
10847 }
10848 }
10849 else
10850 {
10851 out_fp = stdout;
10852 }
10853 }
10854 else
10855 {
10856 if (potfile_disable == 0)
10857 {
10858 pot_fp = fopen (potfile, "ab");
10859
10860 if (pot_fp == NULL)
10861 {
10862 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10863
10864 return (-1);
10865 }
10866
10867 data.pot_fp = pot_fp;
10868 }
10869 }
10870
10871 pot_t *pot = NULL;
10872
10873 uint pot_cnt = 0;
10874 uint pot_avail = 0;
10875
10876 if (show == 1 || left == 1)
10877 {
10878 SUPPRESS_OUTPUT = 1;
10879
10880 pot_avail = count_lines (pot_fp);
10881
10882 rewind (pot_fp);
10883
10884 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10885
10886 uint pot_hashes_avail = 0;
10887
10888 uint line_num = 0;
10889
10890 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10891
10892 while (!feof (pot_fp))
10893 {
10894 line_num++;
10895
10896 int line_len = fgetl (pot_fp, line_buf);
10897
10898 if (line_len == 0) continue;
10899
10900 char *plain_buf = line_buf + line_len;
10901
10902 pot_t *pot_ptr = &pot[pot_cnt];
10903
10904 hash_t *hashes_buf = &pot_ptr->hash;
10905
10906 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10907 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10908
10909 if (pot_cnt == pot_hashes_avail)
10910 {
10911 uint pos = 0;
10912
10913 for (pos = 0; pos < INCR_POT; pos++)
10914 {
10915 if ((pot_cnt + pos) >= pot_avail) break;
10916
10917 pot_t *tmp_pot = &pot[pot_cnt + pos];
10918
10919 hash_t *tmp_hash = &tmp_pot->hash;
10920
10921 tmp_hash->digest = mymalloc (dgst_size);
10922
10923 if (isSalted)
10924 {
10925 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10926 }
10927
10928 if (esalt_size)
10929 {
10930 tmp_hash->esalt = mymalloc (esalt_size);
10931 }
10932
10933 pot_hashes_avail++;
10934 }
10935 }
10936
10937 int plain_len = 0;
10938
10939 int parser_status;
10940
10941 int iter = MAX_CUT_TRIES;
10942
10943 do
10944 {
10945 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10946 {
10947 if (line_buf[i] == ':')
10948 {
10949 line_len--;
10950
10951 break;
10952 }
10953 }
10954
10955 if (data.hash_mode != 2500)
10956 {
10957 parser_status = parse_func (line_buf, line_len, hashes_buf);
10958 }
10959 else
10960 {
10961 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10962
10963 if (line_len > max_salt_size)
10964 {
10965 parser_status = PARSER_GLOBAL_LENGTH;
10966 }
10967 else
10968 {
10969 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10970
10971 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10972
10973 hashes_buf->salt->salt_len = line_len;
10974
10975 parser_status = PARSER_OK;
10976 }
10977 }
10978
10979 // if NOT parsed without error, we add the ":" to the plain
10980
10981 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10982 {
10983 plain_len++;
10984 plain_buf--;
10985 }
10986
10987 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10988
10989 if (parser_status < PARSER_GLOBAL_ZERO)
10990 {
10991 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10992
10993 continue;
10994 }
10995
10996 if (plain_len >= 255) continue;
10997
10998 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10999
11000 pot_ptr->plain_len = plain_len;
11001
11002 pot_cnt++;
11003 }
11004
11005 myfree (line_buf);
11006
11007 fclose (pot_fp);
11008
11009 SUPPRESS_OUTPUT = 0;
11010
11011 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11012 }
11013
11014 /**
11015 * word len
11016 */
11017
11018 uint pw_min = PW_MIN;
11019 uint pw_max = PW_MAX;
11020
11021 switch (hash_mode)
11022 {
11023 case 125: if (pw_max > 32) pw_max = 32;
11024 break;
11025 case 400: if (pw_max > 40) pw_max = 40;
11026 break;
11027 case 500: if (pw_max > 16) pw_max = 16;
11028 break;
11029 case 1500: if (pw_max > 8) pw_max = 8;
11030 break;
11031 case 1600: if (pw_max > 16) pw_max = 16;
11032 break;
11033 case 1800: if (pw_max > 16) pw_max = 16;
11034 break;
11035 case 2100: if (pw_max > 16) pw_max = 16;
11036 break;
11037 case 2500: if (pw_min < 8) pw_min = 8;
11038 break;
11039 case 3000: if (pw_max > 7) pw_max = 7;
11040 break;
11041 case 5200: if (pw_max > 24) pw_max = 24;
11042 break;
11043 case 5800: if (pw_max > 16) pw_max = 16;
11044 break;
11045 case 6300: if (pw_max > 16) pw_max = 16;
11046 break;
11047 case 7400: if (pw_max > 16) pw_max = 16;
11048 break;
11049 case 7900: if (pw_max > 48) pw_max = 48;
11050 break;
11051 case 8500: if (pw_max > 8) pw_max = 8;
11052 break;
11053 case 8600: if (pw_max > 16) pw_max = 16;
11054 break;
11055 case 9710: pw_min = 5;
11056 pw_max = 5;
11057 break;
11058 case 9810: pw_min = 5;
11059 pw_max = 5;
11060 break;
11061 case 10410: pw_min = 5;
11062 pw_max = 5;
11063 break;
11064 case 10300: if (pw_max < 3) pw_min = 3;
11065 if (pw_max > 40) pw_max = 40;
11066 break;
11067 case 10500: if (pw_max < 3) pw_min = 3;
11068 if (pw_max > 40) pw_max = 40;
11069 break;
11070 case 10700: if (pw_max > 16) pw_max = 16;
11071 break;
11072 case 11300: if (pw_max > 40) pw_max = 40;
11073 break;
11074 case 11600: if (pw_max > 32) pw_max = 32;
11075 break;
11076 case 12500: if (pw_max > 20) pw_max = 20;
11077 break;
11078 case 12800: if (pw_max > 24) pw_max = 24;
11079 break;
11080 }
11081
11082 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11083 {
11084 switch (attack_kern)
11085 {
11086 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11087 break;
11088 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11089 break;
11090 }
11091 }
11092
11093 /**
11094 * charsets : keep them together for more easy maintainnce
11095 */
11096
11097 cs_t mp_sys[6] = { { { 0 }, 0 } };
11098 cs_t mp_usr[4] = { { { 0 }, 0 } };
11099
11100 mp_setup_sys (mp_sys);
11101
11102 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11103 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11104 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11105 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11106
11107 /**
11108 * load hashes, part I: find input mode, count hashes
11109 */
11110
11111 uint hashlist_mode = 0;
11112 uint hashlist_format = HLFMT_HASHCAT;
11113
11114 uint hashes_avail = 0;
11115
11116 if (benchmark == 0)
11117 {
11118 struct stat f;
11119
11120 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11121
11122 if ((hash_mode == 2500) ||
11123 (hash_mode == 5200) ||
11124 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11125 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11126 (hash_mode == 9000))
11127 {
11128 hashlist_mode = HL_MODE_ARG;
11129
11130 char *hashfile = myargv[optind];
11131
11132 data.hashfile = hashfile;
11133
11134 logfile_top_var_string ("target", hashfile);
11135 }
11136
11137 if (hashlist_mode == HL_MODE_ARG)
11138 {
11139 if (hash_mode == 2500)
11140 {
11141 struct stat st;
11142
11143 if (stat (data.hashfile, &st) == -1)
11144 {
11145 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11146
11147 return (-1);
11148 }
11149
11150 hashes_avail = st.st_size / sizeof (hccap_t);
11151 }
11152 else
11153 {
11154 hashes_avail = 1;
11155 }
11156 }
11157 else if (hashlist_mode == HL_MODE_FILE)
11158 {
11159 char *hashfile = myargv[optind];
11160
11161 data.hashfile = hashfile;
11162
11163 logfile_top_var_string ("target", hashfile);
11164
11165 FILE *fp = NULL;
11166
11167 if ((fp = fopen (hashfile, "rb")) == NULL)
11168 {
11169 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11170
11171 return (-1);
11172 }
11173
11174 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11175
11176 hashes_avail = count_lines (fp);
11177
11178 rewind (fp);
11179
11180 if (hashes_avail == 0)
11181 {
11182 log_error ("ERROR: hashfile is empty or corrupt");
11183
11184 fclose (fp);
11185
11186 return (-1);
11187 }
11188
11189 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11190
11191 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11192 {
11193 log_error ("ERROR: remove not supported in native hashfile-format mode");
11194
11195 fclose (fp);
11196
11197 return (-1);
11198 }
11199
11200 fclose (fp);
11201 }
11202 }
11203 else
11204 {
11205 hashlist_mode = HL_MODE_ARG;
11206
11207 hashes_avail = 1;
11208 }
11209
11210 if (hash_mode == 3000) hashes_avail *= 2;
11211
11212 data.hashlist_mode = hashlist_mode;
11213 data.hashlist_format = hashlist_format;
11214
11215 logfile_top_uint (hashlist_mode);
11216 logfile_top_uint (hashlist_format);
11217
11218 /**
11219 * load hashes, part II: allocate required memory, set pointers
11220 */
11221
11222 hash_t *hashes_buf = NULL;
11223 void *digests_buf = NULL;
11224 salt_t *salts_buf = NULL;
11225 void *esalts_buf = NULL;
11226
11227 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11228
11229 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11230
11231 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11232 {
11233 u32 hash_pos;
11234
11235 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11236 {
11237 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11238
11239 hashes_buf[hash_pos].hash_info = hash_info;
11240
11241 if (username && (remove || show || left))
11242 {
11243 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11244 }
11245
11246 if (benchmark)
11247 {
11248 hash_info->orighash = (char *) mymalloc (256);
11249 }
11250 }
11251 }
11252
11253 if (isSalted)
11254 {
11255 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11256
11257 if (esalt_size)
11258 {
11259 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11260 }
11261 }
11262 else
11263 {
11264 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11265 }
11266
11267 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11268 {
11269 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11270
11271 if (isSalted)
11272 {
11273 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11274
11275 if (esalt_size)
11276 {
11277 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11278 }
11279 }
11280 else
11281 {
11282 hashes_buf[hash_pos].salt = &salts_buf[0];
11283 }
11284 }
11285
11286 /**
11287 * load hashes, part III: parse hashes or generate them if benchmark
11288 */
11289
11290 uint hashes_cnt = 0;
11291
11292 if (benchmark == 0)
11293 {
11294 if (keyspace == 1)
11295 {
11296 // useless to read hash file for keyspace, cheat a little bit w/ optind
11297 }
11298 else if (hashes_avail == 0)
11299 {
11300 }
11301 else if (hashlist_mode == HL_MODE_ARG)
11302 {
11303 char *input_buf = myargv[optind];
11304
11305 uint input_len = strlen (input_buf);
11306
11307 logfile_top_var_string ("target", input_buf);
11308
11309 char *hash_buf = NULL;
11310 int hash_len = 0;
11311
11312 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11313
11314 bool hash_fmt_error = 0;
11315
11316 if (hash_len < 1) hash_fmt_error = 1;
11317 if (hash_buf == NULL) hash_fmt_error = 1;
11318
11319 if (hash_fmt_error)
11320 {
11321 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11322 }
11323 else
11324 {
11325 if (opts_type & OPTS_TYPE_HASH_COPY)
11326 {
11327 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11328
11329 hash_info_tmp->orighash = mystrdup (hash_buf);
11330 }
11331
11332 if (isSalted)
11333 {
11334 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11335 }
11336
11337 int parser_status = PARSER_OK;
11338
11339 if (hash_mode == 2500)
11340 {
11341 if (hash_len == 0)
11342 {
11343 log_error ("ERROR: hccap file not specified");
11344
11345 return (-1);
11346 }
11347
11348 hashlist_mode = HL_MODE_FILE;
11349
11350 data.hashlist_mode = hashlist_mode;
11351
11352 FILE *fp = fopen (hash_buf, "rb");
11353
11354 if (fp == NULL)
11355 {
11356 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11357
11358 return (-1);
11359 }
11360
11361 if (hashes_avail < 1)
11362 {
11363 log_error ("ERROR: hccap file is empty or corrupt");
11364
11365 fclose (fp);
11366
11367 return (-1);
11368 }
11369
11370 uint hccap_size = sizeof (hccap_t);
11371
11372 char *in = (char *) mymalloc (hccap_size);
11373
11374 while (!feof (fp))
11375 {
11376 int n = fread (in, hccap_size, 1, fp);
11377
11378 if (n != 1)
11379 {
11380 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11381
11382 break;
11383 }
11384
11385 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11386
11387 if (parser_status != PARSER_OK)
11388 {
11389 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11390
11391 continue;
11392 }
11393
11394 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11395
11396 if ((show == 1) || (left == 1))
11397 {
11398 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11399
11400 char *salt_ptr = (char *) tmp_salt->salt_buf;
11401
11402 int cur_pos = tmp_salt->salt_len;
11403 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11404
11405 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11406
11407 // do the appending task
11408
11409 snprintf (salt_ptr + cur_pos,
11410 rem_len,
11411 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11412 wpa->orig_mac1[0],
11413 wpa->orig_mac1[1],
11414 wpa->orig_mac1[2],
11415 wpa->orig_mac1[3],
11416 wpa->orig_mac1[4],
11417 wpa->orig_mac1[5],
11418 wpa->orig_mac2[0],
11419 wpa->orig_mac2[1],
11420 wpa->orig_mac2[2],
11421 wpa->orig_mac2[3],
11422 wpa->orig_mac2[4],
11423 wpa->orig_mac2[5]);
11424
11425 // memset () the remaining part of the salt
11426
11427 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11428 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11429
11430 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11431
11432 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11433 }
11434
11435 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);
11436 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);
11437
11438 hashes_cnt++;
11439 }
11440
11441 fclose (fp);
11442
11443 myfree (in);
11444 }
11445 else if (hash_mode == 3000)
11446 {
11447 if (hash_len == 32)
11448 {
11449 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11450
11451 hash_t *lm_hash_left = NULL;
11452
11453 if (parser_status == PARSER_OK)
11454 {
11455 lm_hash_left = &hashes_buf[hashes_cnt];
11456
11457 hashes_cnt++;
11458 }
11459 else
11460 {
11461 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11462 }
11463
11464 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11465
11466 hash_t *lm_hash_right = NULL;
11467
11468 if (parser_status == PARSER_OK)
11469 {
11470 lm_hash_right = &hashes_buf[hashes_cnt];
11471
11472 hashes_cnt++;
11473 }
11474 else
11475 {
11476 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11477 }
11478
11479 // show / left
11480
11481 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11482 {
11483 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);
11484 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);
11485 }
11486 }
11487 else
11488 {
11489 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11490
11491 if (parser_status == PARSER_OK)
11492 {
11493 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11494 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11495 }
11496
11497 if (parser_status == PARSER_OK)
11498 {
11499 hashes_cnt++;
11500 }
11501 else
11502 {
11503 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11504 }
11505 }
11506 }
11507 else
11508 {
11509 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11510
11511 if (parser_status == PARSER_OK)
11512 {
11513 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11514 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11515 }
11516
11517 if (parser_status == PARSER_OK)
11518 {
11519 hashes_cnt++;
11520 }
11521 else
11522 {
11523 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11524 }
11525 }
11526 }
11527 }
11528 else if (hashlist_mode == HL_MODE_FILE)
11529 {
11530 char *hashfile = data.hashfile;
11531
11532 FILE *fp;
11533
11534 if ((fp = fopen (hashfile, "rb")) == NULL)
11535 {
11536 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11537
11538 return (-1);
11539 }
11540
11541 uint line_num = 0;
11542
11543 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11544
11545 while (!feof (fp))
11546 {
11547 line_num++;
11548
11549 int line_len = fgetl (fp, line_buf);
11550
11551 if (line_len == 0) continue;
11552
11553 char *hash_buf = NULL;
11554 int hash_len = 0;
11555
11556 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11557
11558 bool hash_fmt_error = 0;
11559
11560 if (hash_len < 1) hash_fmt_error = 1;
11561 if (hash_buf == NULL) hash_fmt_error = 1;
11562
11563 if (hash_fmt_error)
11564 {
11565 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11566
11567 continue;
11568 }
11569
11570 if (username)
11571 {
11572 char *user_buf = NULL;
11573 int user_len = 0;
11574
11575 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11576
11577 if (remove || show)
11578 {
11579 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11580
11581 *user = (user_t *) mymalloc (sizeof (user_t));
11582
11583 user_t *user_ptr = *user;
11584
11585 if (user_buf != NULL)
11586 {
11587 user_ptr->user_name = mystrdup (user_buf);
11588 }
11589 else
11590 {
11591 user_ptr->user_name = mystrdup ("");
11592 }
11593
11594 user_ptr->user_len = user_len;
11595 }
11596 }
11597
11598 if (opts_type & OPTS_TYPE_HASH_COPY)
11599 {
11600 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11601
11602 hash_info_tmp->orighash = mystrdup (hash_buf);
11603 }
11604
11605 if (isSalted)
11606 {
11607 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11608 }
11609
11610 if (hash_mode == 3000)
11611 {
11612 if (hash_len == 32)
11613 {
11614 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11615
11616 if (parser_status < PARSER_GLOBAL_ZERO)
11617 {
11618 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11619
11620 continue;
11621 }
11622
11623 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11624
11625 hashes_cnt++;
11626
11627 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11628
11629 if (parser_status < PARSER_GLOBAL_ZERO)
11630 {
11631 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11632
11633 continue;
11634 }
11635
11636 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11637
11638 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);
11639
11640 hashes_cnt++;
11641
11642 // show / left
11643
11644 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);
11645 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);
11646 }
11647 else
11648 {
11649 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11650
11651 if (parser_status < PARSER_GLOBAL_ZERO)
11652 {
11653 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11654
11655 continue;
11656 }
11657
11658 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);
11659
11660 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11661 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11662
11663 hashes_cnt++;
11664 }
11665 }
11666 else
11667 {
11668 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11669
11670 if (parser_status < PARSER_GLOBAL_ZERO)
11671 {
11672 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11673
11674 continue;
11675 }
11676
11677 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);
11678
11679 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11680 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11681
11682 hashes_cnt++;
11683 }
11684 }
11685
11686 myfree (line_buf);
11687
11688 fclose (fp);
11689
11690 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11691
11692 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11693 }
11694 }
11695 else
11696 {
11697 if (isSalted)
11698 {
11699 hashes_buf[0].salt->salt_len = 8;
11700
11701 // special salt handling
11702
11703 switch (hash_mode)
11704 {
11705 case 1500: hashes_buf[0].salt->salt_len = 2;
11706 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11707 break;
11708 case 1731: hashes_buf[0].salt->salt_len = 4;
11709 break;
11710 case 2410: hashes_buf[0].salt->salt_len = 4;
11711 break;
11712 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11713 break;
11714 case 3100: hashes_buf[0].salt->salt_len = 1;
11715 break;
11716 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11717 break;
11718 case 5800: hashes_buf[0].salt->salt_len = 16;
11719 break;
11720 case 6800: hashes_buf[0].salt->salt_len = 32;
11721 break;
11722 case 8400: hashes_buf[0].salt->salt_len = 40;
11723 break;
11724 case 8800: hashes_buf[0].salt->salt_len = 16;
11725 break;
11726 case 8900: hashes_buf[0].salt->salt_len = 16;
11727 hashes_buf[0].salt->scrypt_N = 1024;
11728 hashes_buf[0].salt->scrypt_r = 1;
11729 hashes_buf[0].salt->scrypt_p = 1;
11730 break;
11731 case 9100: hashes_buf[0].salt->salt_len = 16;
11732 break;
11733 case 9300: hashes_buf[0].salt->salt_len = 14;
11734 hashes_buf[0].salt->scrypt_N = 16384;
11735 hashes_buf[0].salt->scrypt_r = 1;
11736 hashes_buf[0].salt->scrypt_p = 1;
11737 break;
11738 case 9400: hashes_buf[0].salt->salt_len = 16;
11739 break;
11740 case 9500: hashes_buf[0].salt->salt_len = 16;
11741 break;
11742 case 9600: hashes_buf[0].salt->salt_len = 16;
11743 break;
11744 case 9700: hashes_buf[0].salt->salt_len = 16;
11745 break;
11746 case 9710: hashes_buf[0].salt->salt_len = 16;
11747 break;
11748 case 9720: hashes_buf[0].salt->salt_len = 16;
11749 break;
11750 case 9800: hashes_buf[0].salt->salt_len = 16;
11751 break;
11752 case 9810: hashes_buf[0].salt->salt_len = 16;
11753 break;
11754 case 9820: hashes_buf[0].salt->salt_len = 16;
11755 break;
11756 case 10300: hashes_buf[0].salt->salt_len = 12;
11757 break;
11758 case 11500: hashes_buf[0].salt->salt_len = 4;
11759 break;
11760 case 11600: hashes_buf[0].salt->salt_len = 4;
11761 break;
11762 case 12400: hashes_buf[0].salt->salt_len = 4;
11763 break;
11764 case 12500: hashes_buf[0].salt->salt_len = 8;
11765 break;
11766 case 12600: hashes_buf[0].salt->salt_len = 64;
11767 break;
11768 }
11769
11770 // special esalt handling
11771
11772 switch (hash_mode)
11773 {
11774 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11775 break;
11776 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11777 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11778 break;
11779 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11780 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11781 break;
11782 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11783 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11784 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11785 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11786 break;
11787 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11788 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11789 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11790 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11791 break;
11792 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11793 break;
11794 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11795 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11796 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11797 break;
11798 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11799 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11800 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11801 break;
11802 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11803 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11804 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11805 break;
11806 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11807 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11808 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11809 break;
11810 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11811 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11812 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11813 break;
11814 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11815 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11816 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11817 break;
11818 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11819 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11820 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11821 break;
11822 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11823 break;
11824 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
11825 break;
11826 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
11827 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
11828 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
11829 break;
11830 }
11831 }
11832
11833 // set hashfile
11834
11835 switch (hash_mode)
11836 {
11837 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11838 break;
11839 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11840 break;
11841 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11842 break;
11843 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11844 break;
11845 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11846 break;
11847 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11848 break;
11849 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11850 break;
11851 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11852 break;
11853 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11854 break;
11855 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11856 break;
11857 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11858 break;
11859 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11860 break;
11861 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11862 break;
11863 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11864 break;
11865 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11866 break;
11867 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11868 break;
11869 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11870 break;
11871 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11872 break;
11873 case 13711: data.hashfile = mystrdup ("hashcat.vc");
11874 break;
11875 case 13712: data.hashfile = mystrdup ("hashcat.vc");
11876 break;
11877 case 13713: data.hashfile = mystrdup ("hashcat.vc");
11878 break;
11879 case 13721: data.hashfile = mystrdup ("hashcat.vc");
11880 break;
11881 case 13722: data.hashfile = mystrdup ("hashcat.vc");
11882 break;
11883 case 13723: data.hashfile = mystrdup ("hashcat.vc");
11884 break;
11885 case 13731: data.hashfile = mystrdup ("hashcat.vc");
11886 break;
11887 case 13732: data.hashfile = mystrdup ("hashcat.vc");
11888 break;
11889 case 13733: data.hashfile = mystrdup ("hashcat.vc");
11890 break;
11891 case 13741: data.hashfile = mystrdup ("hashcat.vc");
11892 break;
11893 case 13742: data.hashfile = mystrdup ("hashcat.vc");
11894 break;
11895 case 13743: data.hashfile = mystrdup ("hashcat.vc");
11896 break;
11897 case 13751: data.hashfile = mystrdup ("hashcat.vc");
11898 break;
11899 case 13752: data.hashfile = mystrdup ("hashcat.vc");
11900 break;
11901 case 13753: data.hashfile = mystrdup ("hashcat.vc");
11902 break;
11903 case 13761: data.hashfile = mystrdup ("hashcat.vc");
11904 break;
11905 case 13762: data.hashfile = mystrdup ("hashcat.vc");
11906 break;
11907 case 13763: data.hashfile = mystrdup ("hashcat.vc");
11908 break;
11909 }
11910
11911 // set default iterations
11912
11913 switch (hash_mode)
11914 {
11915 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11916 break;
11917 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11918 break;
11919 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11920 break;
11921 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11922 break;
11923 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11924 break;
11925 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11926 break;
11927 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11928 break;
11929 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11930 break;
11931 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11932 break;
11933 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11934 break;
11935 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11936 break;
11937 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11938 break;
11939 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11940 break;
11941 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11942 break;
11943 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11944 break;
11945 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11946 break;
11947 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11948 break;
11949 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11950 break;
11951 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11952 break;
11953 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11954 break;
11955 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11956 break;
11957 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11958 break;
11959 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11960 break;
11961 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11962 break;
11963 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11964 break;
11965 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11966 break;
11967 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11968 break;
11969 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11970 break;
11971 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11972 break;
11973 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11974 break;
11975 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11976 break;
11977 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11978 break;
11979 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11980 break;
11981 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11982 break;
11983 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11984 break;
11985 case 8900: hashes_buf[0].salt->salt_iter = 1;
11986 break;
11987 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11988 break;
11989 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11990 break;
11991 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11992 break;
11993 case 9300: hashes_buf[0].salt->salt_iter = 1;
11994 break;
11995 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11996 break;
11997 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11998 break;
11999 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12000 break;
12001 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12002 break;
12003 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12004 break;
12005 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12006 break;
12007 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12008 break;
12009 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12010 break;
12011 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12012 break;
12013 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12014 break;
12015 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12016 break;
12017 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12018 break;
12019 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12020 break;
12021 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12022 break;
12023 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12024 break;
12025 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12026 break;
12027 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12028 break;
12029 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12030 break;
12031 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12032 break;
12033 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12034 break;
12035 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12036 break;
12037 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12038 break;
12039 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12040 break;
12041 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12042 break;
12043 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12044 break;
12045 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12046 break;
12047 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12048 break;
12049 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12050 break;
12051 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12052 break;
12053 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12054 break;
12055 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12056 break;
12057 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12058 break;
12059 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12060 break;
12061 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12062 break;
12063 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12064 break;
12065 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12066 break;
12067 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12068 break;
12069 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12070 break;
12071 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12072 break;
12073 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12074 break;
12075 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12076 break;
12077 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12078 break;
12079 }
12080
12081 hashes_cnt = 1;
12082 }
12083
12084 if (show == 1 || left == 1)
12085 {
12086 for (uint i = 0; i < pot_cnt; i++)
12087 {
12088 pot_t *pot_ptr = &pot[i];
12089
12090 hash_t *hashes_buf = &pot_ptr->hash;
12091
12092 local_free (hashes_buf->digest);
12093
12094 if (isSalted)
12095 {
12096 local_free (hashes_buf->salt);
12097 }
12098 }
12099
12100 local_free (pot);
12101
12102 if (data.quiet == 0) log_info_nn ("");
12103
12104 return (0);
12105 }
12106
12107 if (keyspace == 0)
12108 {
12109 if (hashes_cnt == 0)
12110 {
12111 log_error ("ERROR: No hashes loaded");
12112
12113 return (-1);
12114 }
12115 }
12116
12117 /**
12118 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12119 */
12120
12121 if (data.outfile != NULL)
12122 {
12123 if (data.hashfile != NULL)
12124 {
12125 #ifdef _POSIX
12126 struct stat tmpstat_outfile;
12127 struct stat tmpstat_hashfile;
12128 #endif
12129
12130 #ifdef _WIN
12131 struct stat64 tmpstat_outfile;
12132 struct stat64 tmpstat_hashfile;
12133 #endif
12134
12135 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12136
12137 if (tmp_outfile_fp)
12138 {
12139 #ifdef _POSIX
12140 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12141 #endif
12142
12143 #ifdef _WIN
12144 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12145 #endif
12146
12147 fclose (tmp_outfile_fp);
12148 }
12149
12150 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12151
12152 if (tmp_hashfile_fp)
12153 {
12154 #ifdef _POSIX
12155 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12156 #endif
12157
12158 #ifdef _WIN
12159 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12160 #endif
12161
12162 fclose (tmp_hashfile_fp);
12163 }
12164
12165 if (tmp_outfile_fp && tmp_outfile_fp)
12166 {
12167 tmpstat_outfile.st_mode = 0;
12168 tmpstat_outfile.st_nlink = 0;
12169 tmpstat_outfile.st_uid = 0;
12170 tmpstat_outfile.st_gid = 0;
12171 tmpstat_outfile.st_rdev = 0;
12172 tmpstat_outfile.st_atime = 0;
12173
12174 tmpstat_hashfile.st_mode = 0;
12175 tmpstat_hashfile.st_nlink = 0;
12176 tmpstat_hashfile.st_uid = 0;
12177 tmpstat_hashfile.st_gid = 0;
12178 tmpstat_hashfile.st_rdev = 0;
12179 tmpstat_hashfile.st_atime = 0;
12180
12181 #ifdef _POSIX
12182 tmpstat_outfile.st_blksize = 0;
12183 tmpstat_outfile.st_blocks = 0;
12184
12185 tmpstat_hashfile.st_blksize = 0;
12186 tmpstat_hashfile.st_blocks = 0;
12187 #endif
12188
12189 #ifdef _POSIX
12190 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12191 {
12192 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12193
12194 return (-1);
12195 }
12196 #endif
12197
12198 #ifdef _WIN
12199 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12200 {
12201 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12202
12203 return (-1);
12204 }
12205 #endif
12206 }
12207 }
12208 }
12209
12210 /**
12211 * Remove duplicates
12212 */
12213
12214 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12215
12216 if (isSalted)
12217 {
12218 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12219 }
12220 else
12221 {
12222 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12223 }
12224
12225 uint hashes_cnt_orig = hashes_cnt;
12226
12227 hashes_cnt = 1;
12228
12229 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12230 {
12231 if (isSalted)
12232 {
12233 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12234 {
12235 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12236 }
12237 }
12238 else
12239 {
12240 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12241 }
12242
12243 if (hashes_pos > hashes_cnt)
12244 {
12245 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12246 }
12247
12248 hashes_cnt++;
12249 }
12250
12251 /**
12252 * Potfile removes
12253 */
12254
12255 uint potfile_remove_cracks = 0;
12256
12257 if (potfile_disable == 0)
12258 {
12259 hash_t hash_buf;
12260
12261 hash_buf.digest = mymalloc (dgst_size);
12262 hash_buf.salt = NULL;
12263 hash_buf.esalt = NULL;
12264 hash_buf.hash_info = NULL;
12265 hash_buf.cracked = 0;
12266
12267 if (isSalted)
12268 {
12269 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12270 }
12271
12272 if (esalt_size)
12273 {
12274 hash_buf.esalt = mymalloc (esalt_size);
12275 }
12276
12277 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12278
12279 // no solution for these special hash types (for instane because they use hashfile in output etc)
12280 if ((hash_mode != 5200) &&
12281 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12282 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12283 (hash_mode != 9000))
12284 {
12285 FILE *fp = fopen (potfile, "rb");
12286
12287 if (fp != NULL)
12288 {
12289 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12290
12291 // to be safe work with a copy (because of line_len loop, i etc)
12292 // moved up here because it's easier to handle continue case
12293 // it's just 64kb
12294
12295 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12296
12297 while (!feof (fp))
12298 {
12299 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12300
12301 if (ptr == NULL) break;
12302
12303 int line_len = strlen (line_buf);
12304
12305 if (line_len == 0) continue;
12306
12307 int iter = MAX_CUT_TRIES;
12308
12309 for (int i = line_len - 1; i && iter; i--, line_len--)
12310 {
12311 if (line_buf[i] != ':') continue;
12312
12313 if (isSalted)
12314 {
12315 memset (hash_buf.salt, 0, sizeof (salt_t));
12316 }
12317
12318 hash_t *found = NULL;
12319
12320 if (hash_mode == 6800)
12321 {
12322 if (i < 64) // 64 = 16 * uint in salt_buf[]
12323 {
12324 // manipulate salt_buf
12325 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12326
12327 hash_buf.salt->salt_len = i;
12328
12329 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12330 }
12331 }
12332 else if (hash_mode == 2500)
12333 {
12334 if (i < 64) // 64 = 16 * uint in salt_buf[]
12335 {
12336 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12337 // manipulate salt_buf
12338
12339 memcpy (line_buf_cpy, line_buf, i);
12340
12341 char *mac2_pos = strrchr (line_buf_cpy, ':');
12342
12343 if (mac2_pos == NULL) continue;
12344
12345 mac2_pos[0] = 0;
12346 mac2_pos++;
12347
12348 if (strlen (mac2_pos) != 12) continue;
12349
12350 char *mac1_pos = strrchr (line_buf_cpy, ':');
12351
12352 if (mac1_pos == NULL) continue;
12353
12354 mac1_pos[0] = 0;
12355 mac1_pos++;
12356
12357 if (strlen (mac1_pos) != 12) continue;
12358
12359 uint essid_length = mac1_pos - line_buf_cpy - 1;
12360
12361 // here we need the ESSID
12362 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12363
12364 hash_buf.salt->salt_len = essid_length;
12365
12366 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12367
12368 if (found)
12369 {
12370 wpa_t *wpa = (wpa_t *) found->esalt;
12371
12372 // compare hex string(s) vs binary MAC address(es)
12373
12374 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12375 {
12376 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12377 {
12378 found = NULL;
12379
12380 break;
12381 }
12382 }
12383
12384 // early skip ;)
12385 if (!found) continue;
12386
12387 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12388 {
12389 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12390 {
12391 found = NULL;
12392
12393 break;
12394 }
12395 }
12396 }
12397 }
12398 }
12399 else
12400 {
12401 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12402
12403 if (parser_status == PARSER_OK)
12404 {
12405 if (isSalted)
12406 {
12407 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12408 }
12409 else
12410 {
12411 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12412 }
12413 }
12414 }
12415
12416 if (found == NULL) continue;
12417
12418 if (!found->cracked) potfile_remove_cracks++;
12419
12420 found->cracked = 1;
12421
12422 if (found) break;
12423
12424 iter--;
12425 }
12426 }
12427
12428 myfree (line_buf_cpy);
12429
12430 myfree (line_buf);
12431
12432 fclose (fp);
12433 }
12434 }
12435
12436 if (esalt_size)
12437 {
12438 local_free (hash_buf.esalt);
12439 }
12440
12441 if (isSalted)
12442 {
12443 local_free (hash_buf.salt);
12444 }
12445
12446 local_free (hash_buf.digest);
12447 }
12448
12449 /**
12450 * Now generate all the buffers required for later
12451 */
12452
12453 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12454
12455 salt_t *salts_buf_new = NULL;
12456 void *esalts_buf_new = NULL;
12457
12458 if (isSalted)
12459 {
12460 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12461
12462 if (esalt_size)
12463 {
12464 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12465 }
12466 }
12467 else
12468 {
12469 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12470 }
12471
12472 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12473
12474 uint digests_cnt = hashes_cnt;
12475 uint digests_done = 0;
12476
12477 size_t size_digests = digests_cnt * dgst_size;
12478 size_t size_shown = digests_cnt * sizeof (uint);
12479
12480 uint *digests_shown = (uint *) mymalloc (size_shown);
12481 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12482
12483 uint salts_cnt = 0;
12484 uint salts_done = 0;
12485
12486 hashinfo_t **hash_info = NULL;
12487
12488 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12489 {
12490 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12491
12492 if (username && (remove || show))
12493 {
12494 uint user_pos;
12495
12496 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12497 {
12498 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12499
12500 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12501 }
12502 }
12503 }
12504
12505 uint *salts_shown = (uint *) mymalloc (size_shown);
12506
12507 salt_t *salt_buf;
12508
12509 {
12510 // copied from inner loop
12511
12512 salt_buf = &salts_buf_new[salts_cnt];
12513
12514 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12515
12516 if (esalt_size)
12517 {
12518 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12519 }
12520
12521 salt_buf->digests_cnt = 0;
12522 salt_buf->digests_done = 0;
12523 salt_buf->digests_offset = 0;
12524
12525 salts_cnt++;
12526 }
12527
12528 if (hashes_buf[0].cracked == 1)
12529 {
12530 digests_shown[0] = 1;
12531
12532 digests_done++;
12533
12534 salt_buf->digests_done++;
12535 }
12536
12537 salt_buf->digests_cnt++;
12538
12539 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12540
12541 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12542 {
12543 hash_info[0] = hashes_buf[0].hash_info;
12544 }
12545
12546 // copy from inner loop
12547
12548 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12549 {
12550 if (isSalted)
12551 {
12552 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12553 {
12554 salt_buf = &salts_buf_new[salts_cnt];
12555
12556 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12557
12558 if (esalt_size)
12559 {
12560 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12561 }
12562
12563 salt_buf->digests_cnt = 0;
12564 salt_buf->digests_done = 0;
12565 salt_buf->digests_offset = hashes_pos;
12566
12567 salts_cnt++;
12568 }
12569 }
12570
12571 if (hashes_buf[hashes_pos].cracked == 1)
12572 {
12573 digests_shown[hashes_pos] = 1;
12574
12575 digests_done++;
12576
12577 salt_buf->digests_done++;
12578 }
12579
12580 salt_buf->digests_cnt++;
12581
12582 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12583
12584 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12585 {
12586 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12587 }
12588 }
12589
12590 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12591 {
12592 salt_t *salt_buf = &salts_buf_new[salt_pos];
12593
12594 if (salt_buf->digests_done == salt_buf->digests_cnt)
12595 {
12596 salts_shown[salt_pos] = 1;
12597
12598 salts_done++;
12599 }
12600
12601 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12602 }
12603
12604 local_free (digests_buf);
12605 local_free (salts_buf);
12606 local_free (esalts_buf);
12607
12608 digests_buf = digests_buf_new;
12609 salts_buf = salts_buf_new;
12610 esalts_buf = esalts_buf_new;
12611
12612 local_free (hashes_buf);
12613
12614 /**
12615 * special modification not set from parser
12616 */
12617
12618 switch (hash_mode)
12619 {
12620 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12621 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12622 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12623 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12624 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12625 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12626 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12627 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12628 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12629 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12630 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12631 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12632 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12633 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12634 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12635 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12636 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12637 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12638 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12639 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12640 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12641 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12642 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12643 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12644 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12645 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12646 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12647 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12648 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12649 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12650 }
12651
12652 if (truecrypt_keyfiles)
12653 {
12654 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12655
12656 char *keyfiles = strdup (truecrypt_keyfiles);
12657
12658 char *keyfile = strtok (keyfiles, ",");
12659
12660 do
12661 {
12662 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12663
12664 } while ((keyfile = strtok (NULL, ",")) != NULL);
12665
12666 free (keyfiles);
12667 }
12668
12669 if (veracrypt_keyfiles)
12670 {
12671 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12672
12673 char *keyfiles = strdup (veracrypt_keyfiles);
12674
12675 char *keyfile = strtok (keyfiles, ",");
12676
12677 do
12678 {
12679 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12680
12681 } while ((keyfile = strtok (NULL, ",")) != NULL);
12682
12683 free (keyfiles);
12684 }
12685
12686 data.digests_cnt = digests_cnt;
12687 data.digests_done = digests_done;
12688 data.digests_buf = digests_buf;
12689 data.digests_shown = digests_shown;
12690 data.digests_shown_tmp = digests_shown_tmp;
12691
12692 data.salts_cnt = salts_cnt;
12693 data.salts_done = salts_done;
12694 data.salts_buf = salts_buf;
12695 data.salts_shown = salts_shown;
12696
12697 data.esalts_buf = esalts_buf;
12698 data.hash_info = hash_info;
12699
12700 /**
12701 * Automatic Optimizers
12702 */
12703
12704 if (salts_cnt == 1)
12705 opti_type |= OPTI_TYPE_SINGLE_SALT;
12706
12707 if (digests_cnt == 1)
12708 opti_type |= OPTI_TYPE_SINGLE_HASH;
12709
12710 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12711 opti_type |= OPTI_TYPE_NOT_ITERATED;
12712
12713 if (attack_mode == ATTACK_MODE_BF)
12714 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12715
12716 data.opti_type = opti_type;
12717
12718 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12719 {
12720 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12721 {
12722 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12723 {
12724 if (opts_type & OPTS_TYPE_ST_ADD80)
12725 {
12726 opts_type &= ~OPTS_TYPE_ST_ADD80;
12727 opts_type |= OPTS_TYPE_PT_ADD80;
12728 }
12729
12730 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12731 {
12732 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12733 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12734 }
12735
12736 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12737 {
12738 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12739 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12740 }
12741 }
12742 }
12743 }
12744
12745 /**
12746 * Some algorithm, like descrypt, can benefit from JIT compilation
12747 */
12748
12749 int force_jit_compilation = -1;
12750
12751 if (hash_mode == 8900)
12752 {
12753 force_jit_compilation = 8900;
12754 }
12755 else if (hash_mode == 9300)
12756 {
12757 force_jit_compilation = 8900;
12758 }
12759 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12760 {
12761 force_jit_compilation = 1500;
12762 }
12763
12764 /**
12765 * generate bitmap tables
12766 */
12767
12768 const uint bitmap_shift1 = 5;
12769 const uint bitmap_shift2 = 13;
12770
12771 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12772
12773 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12774 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12775 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12776 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12777 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12778 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12779 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12780 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12781
12782 uint bitmap_bits;
12783 uint bitmap_nums;
12784 uint bitmap_mask;
12785 uint bitmap_size;
12786
12787 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12788 {
12789 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12790
12791 bitmap_nums = 1 << bitmap_bits;
12792
12793 bitmap_mask = bitmap_nums - 1;
12794
12795 bitmap_size = bitmap_nums * sizeof (uint);
12796
12797 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12798
12799 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;
12800 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;
12801
12802 break;
12803 }
12804
12805 bitmap_nums = 1 << bitmap_bits;
12806
12807 bitmap_mask = bitmap_nums - 1;
12808
12809 bitmap_size = bitmap_nums * sizeof (uint);
12810
12811 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);
12812 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);
12813
12814 /**
12815 * prepare quick rule
12816 */
12817
12818 data.rule_buf_l = rule_buf_l;
12819 data.rule_buf_r = rule_buf_r;
12820
12821 int rule_len_l = (int) strlen (rule_buf_l);
12822 int rule_len_r = (int) strlen (rule_buf_r);
12823
12824 data.rule_len_l = rule_len_l;
12825 data.rule_len_r = rule_len_r;
12826
12827 /**
12828 * load rules
12829 */
12830
12831 uint *all_kernel_rules_cnt = NULL;
12832
12833 kernel_rule_t **all_kernel_rules_buf = NULL;
12834
12835 if (rp_files_cnt)
12836 {
12837 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12838
12839 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12840 }
12841
12842 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12843
12844 int rule_len = 0;
12845
12846 for (uint i = 0; i < rp_files_cnt; i++)
12847 {
12848 uint kernel_rules_avail = 0;
12849
12850 uint kernel_rules_cnt = 0;
12851
12852 kernel_rule_t *kernel_rules_buf = NULL;
12853
12854 char *rp_file = rp_files[i];
12855
12856 char in[BLOCK_SIZE] = { 0 };
12857 char out[BLOCK_SIZE] = { 0 };
12858
12859 FILE *fp = NULL;
12860
12861 uint rule_line = 0;
12862
12863 if ((fp = fopen (rp_file, "rb")) == NULL)
12864 {
12865 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12866
12867 return (-1);
12868 }
12869
12870 while (!feof (fp))
12871 {
12872 memset (rule_buf, 0, HCBUFSIZ);
12873
12874 rule_len = fgetl (fp, rule_buf);
12875
12876 rule_line++;
12877
12878 if (rule_len == 0) continue;
12879
12880 if (rule_buf[0] == '#') continue;
12881
12882 if (kernel_rules_avail == kernel_rules_cnt)
12883 {
12884 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12885
12886 kernel_rules_avail += INCR_RULES;
12887 }
12888
12889 memset (in, 0, BLOCK_SIZE);
12890 memset (out, 0, BLOCK_SIZE);
12891
12892 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12893
12894 if (result == -1)
12895 {
12896 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12897
12898 continue;
12899 }
12900
12901 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12902 {
12903 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12904
12905 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12906
12907 continue;
12908 }
12909
12910 /* its so slow
12911 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12912 {
12913 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12914
12915 continue;
12916 }
12917 */
12918
12919 kernel_rules_cnt++;
12920 }
12921
12922 fclose (fp);
12923
12924 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12925
12926 all_kernel_rules_buf[i] = kernel_rules_buf;
12927 }
12928
12929 /**
12930 * merge rules or automatic rule generator
12931 */
12932
12933 uint kernel_rules_cnt = 0;
12934
12935 kernel_rule_t *kernel_rules_buf = NULL;
12936
12937 if (attack_mode == ATTACK_MODE_STRAIGHT)
12938 {
12939 if (rp_files_cnt)
12940 {
12941 kernel_rules_cnt = 1;
12942
12943 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12944
12945 repeats[0] = kernel_rules_cnt;
12946
12947 for (uint i = 0; i < rp_files_cnt; i++)
12948 {
12949 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12950
12951 repeats[i + 1] = kernel_rules_cnt;
12952 }
12953
12954 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12955
12956 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12957
12958 for (uint i = 0; i < kernel_rules_cnt; i++)
12959 {
12960 uint out_pos = 0;
12961
12962 kernel_rule_t *out = &kernel_rules_buf[i];
12963
12964 for (uint j = 0; j < rp_files_cnt; j++)
12965 {
12966 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12967 uint in_pos;
12968
12969 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12970
12971 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12972 {
12973 if (out_pos == RULES_MAX - 1)
12974 {
12975 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12976
12977 break;
12978 }
12979
12980 out->cmds[out_pos] = in->cmds[in_pos];
12981 }
12982 }
12983 }
12984
12985 local_free (repeats);
12986 }
12987 else if (rp_gen)
12988 {
12989 uint kernel_rules_avail = 0;
12990
12991 while (kernel_rules_cnt < rp_gen)
12992 {
12993 if (kernel_rules_avail == kernel_rules_cnt)
12994 {
12995 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12996
12997 kernel_rules_avail += INCR_RULES;
12998 }
12999
13000 memset (rule_buf, 0, HCBUFSIZ);
13001
13002 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13003
13004 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13005
13006 kernel_rules_cnt++;
13007 }
13008 }
13009 }
13010
13011 myfree (rule_buf);
13012
13013 /**
13014 * generate NOP rules
13015 */
13016
13017 if (kernel_rules_cnt == 0)
13018 {
13019 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13020
13021 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13022
13023 kernel_rules_cnt++;
13024 }
13025
13026 data.kernel_rules_cnt = kernel_rules_cnt;
13027 data.kernel_rules_buf = kernel_rules_buf;
13028
13029 /**
13030 * OpenCL platforms: detect
13031 */
13032
13033 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13034 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13035
13036 cl_uint platforms_cnt = 0;
13037 cl_uint platform_devices_cnt = 0;
13038
13039 if (keyspace == 0)
13040 {
13041 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13042
13043 if (platforms_cnt == 0)
13044 {
13045 log_info ("");
13046 log_info ("ATTENTION! No OpenCL compatible platform found");
13047 log_info ("");
13048 log_info ("You're probably missing the OpenCL runtime installation");
13049 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13050 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13051 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13052 log_info ("");
13053
13054 return (-1);
13055 }
13056
13057 if (opencl_platforms_filter != (uint) -1)
13058 {
13059 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13060
13061 if (opencl_platforms_filter > platform_cnt_mask)
13062 {
13063 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13064
13065 return (-1);
13066 }
13067 }
13068 }
13069
13070 /**
13071 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
13072 */
13073
13074 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13075 {
13076 cl_platform_id platform = platforms[platform_id];
13077
13078 char platform_vendor[INFOSZ] = { 0 };
13079
13080 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13081
13082 #ifdef HAVE_HWMON
13083 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13084 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13085 {
13086 // make sure that we do not directly control the fan for NVidia
13087
13088 gpu_temp_retain = 0;
13089
13090 data.gpu_temp_retain = gpu_temp_retain;
13091 }
13092 #endif // HAVE_NVML || HAVE_NVAPI
13093 #endif
13094 }
13095
13096 /**
13097 * OpenCL device types:
13098 * In case the user did not specify --opencl-device-types and the user runs hashcat in a system with only a CPU only he probably want to use that CPU.
13099 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13100 */
13101
13102 if (opencl_device_types == NULL)
13103 {
13104 cl_device_type device_types_all = 0;
13105
13106 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13107 {
13108 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13109
13110 cl_platform_id platform = platforms[platform_id];
13111
13112 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13113
13114 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13115 {
13116 cl_device_id device = platform_devices[platform_devices_id];
13117
13118 cl_device_type device_type;
13119
13120 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13121
13122 device_types_all |= device_type;
13123 }
13124 }
13125
13126 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13127 {
13128 device_types_filter |= CL_DEVICE_TYPE_CPU;
13129 }
13130 }
13131
13132 /**
13133 * OpenCL devices: simply push all devices from all platforms into the same device array
13134 */
13135
13136 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13137
13138 data.devices_param = devices_param;
13139
13140 uint devices_cnt = 0;
13141
13142 uint devices_active = 0;
13143
13144 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13145 {
13146 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13147
13148 cl_platform_id platform = platforms[platform_id];
13149
13150 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13151
13152 char platform_vendor[INFOSZ] = { 0 };
13153
13154 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13155
13156 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13157 // this causes trouble with vendor id based macros
13158 // we'll assign generic to those without special optimization available
13159
13160 cl_uint vendor_id = 0;
13161
13162 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13163 {
13164 vendor_id = VENDOR_ID_AMD;
13165 }
13166 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13167 {
13168 vendor_id = VENDOR_ID_APPLE;
13169 }
13170 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13171 {
13172 vendor_id = VENDOR_ID_INTEL_BEIGNET;
13173 }
13174 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13175 {
13176 vendor_id = VENDOR_ID_INTEL_SDK;
13177 }
13178 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13179 {
13180 vendor_id = VENDOR_ID_MESA;
13181 }
13182 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13183 {
13184 vendor_id = VENDOR_ID_NV;
13185 }
13186 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13187 {
13188 vendor_id = VENDOR_ID_POCL;
13189 }
13190 else
13191 {
13192 vendor_id = VENDOR_ID_GENERIC;
13193 }
13194
13195 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13196 {
13197 size_t param_value_size = 0;
13198
13199 const uint device_id = devices_cnt;
13200
13201 hc_device_param_t *device_param = &data.devices_param[device_id];
13202
13203 device_param->vendor_id = vendor_id;
13204
13205 device_param->device = platform_devices[platform_devices_id];
13206
13207 device_param->device_id = device_id;
13208
13209 device_param->platform_devices_id = platform_devices_id;
13210
13211 // device_type
13212
13213 cl_device_type device_type;
13214
13215 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13216
13217 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13218
13219 device_param->device_type = device_type;
13220
13221 // device_name
13222
13223 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13224
13225 char *device_name = (char *) mymalloc (param_value_size);
13226
13227 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13228
13229 device_param->device_name = device_name;
13230
13231 // tuning db
13232
13233 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13234
13235 // device_version
13236
13237 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13238
13239 char *device_version = (char *) mymalloc (param_value_size);
13240
13241 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13242
13243 device_param->device_version = device_version;
13244
13245 // device_opencl_version
13246
13247 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13248
13249 char *device_opencl_version = (char *) mymalloc (param_value_size);
13250
13251 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13252
13253 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13254
13255 myfree (device_opencl_version);
13256
13257 // vector_width
13258
13259 cl_uint vector_width;
13260
13261 if (opencl_vector_width_chgd == 0)
13262 {
13263 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13264 {
13265 if (opti_type & OPTI_TYPE_USES_BITS_64)
13266 {
13267 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13268 }
13269 else
13270 {
13271 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13272 }
13273 }
13274 else
13275 {
13276 vector_width = (cl_uint) tuningdb_entry->vector_width;
13277 }
13278 }
13279 else
13280 {
13281 vector_width = opencl_vector_width;
13282 }
13283
13284 if (vector_width > 16) vector_width = 16;
13285
13286 device_param->vector_width = vector_width;
13287
13288 // max_compute_units
13289
13290 cl_uint device_processors;
13291
13292 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13293
13294 device_param->device_processors = device_processors;
13295
13296 // device_maxmem_alloc
13297 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13298
13299 cl_ulong device_maxmem_alloc;
13300
13301 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13302
13303 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13304
13305 // device_global_mem
13306
13307 cl_ulong device_global_mem;
13308
13309 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13310
13311 device_param->device_global_mem = device_global_mem;
13312
13313 // max_work_group_size
13314
13315 size_t device_maxworkgroup_size;
13316
13317 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13318
13319 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13320
13321 // max_clock_frequency
13322
13323 cl_uint device_maxclock_frequency;
13324
13325 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13326
13327 device_param->device_maxclock_frequency = device_maxclock_frequency;
13328
13329 // device_endian_little
13330
13331 cl_bool device_endian_little;
13332
13333 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13334
13335 if (device_endian_little == CL_FALSE)
13336 {
13337 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13338
13339 device_param->skipped = 1;
13340 }
13341
13342 // device_available
13343
13344 cl_bool device_available;
13345
13346 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13347
13348 if (device_available == CL_FALSE)
13349 {
13350 log_info ("Device #%u: WARNING: device not available", device_id + 1);
13351
13352 device_param->skipped = 1;
13353 }
13354
13355 // device_compiler_available
13356
13357 cl_bool device_compiler_available;
13358
13359 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13360
13361 if (device_compiler_available == CL_FALSE)
13362 {
13363 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13364
13365 device_param->skipped = 1;
13366 }
13367
13368 // device_execution_capabilities
13369
13370 cl_device_exec_capabilities device_execution_capabilities;
13371
13372 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13373
13374 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13375 {
13376 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13377
13378 device_param->skipped = 1;
13379 }
13380
13381 // device_extensions
13382
13383 size_t device_extensions_size;
13384
13385 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13386
13387 char *device_extensions = mymalloc (device_extensions_size + 1);
13388
13389 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13390
13391 if (strstr (device_extensions, "base_atomics") == 0)
13392 {
13393 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13394
13395 device_param->skipped = 1;
13396 }
13397
13398 if (strstr (device_extensions, "byte_addressable_store") == 0)
13399 {
13400 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13401
13402 device_param->skipped = 1;
13403 }
13404
13405 myfree (device_extensions);
13406
13407 // device_local_mem_size
13408
13409 cl_ulong device_local_mem_size;
13410
13411 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13412
13413 if (device_local_mem_size < 32768)
13414 {
13415 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13416
13417 device_param->skipped = 1;
13418 }
13419
13420
13421 // skipped
13422
13423 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13424 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13425
13426 // driver_version
13427
13428 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13429
13430 char *driver_version = (char *) mymalloc (param_value_size);
13431
13432 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13433
13434 device_param->driver_version = driver_version;
13435
13436 // device_name_chksum
13437
13438 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13439
13440 #if __x86_64__
13441 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);
13442 #else
13443 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);
13444 #endif
13445
13446 uint device_name_digest[4] = { 0 };
13447
13448 md5_64 ((uint *) device_name_chksum, device_name_digest);
13449
13450 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13451
13452 device_param->device_name_chksum = device_name_chksum;
13453
13454 // device_processor_cores
13455
13456 if (device_type & CL_DEVICE_TYPE_CPU)
13457 {
13458 cl_uint device_processor_cores = 1;
13459
13460 device_param->device_processor_cores = device_processor_cores;
13461 }
13462
13463 if (device_type & CL_DEVICE_TYPE_GPU)
13464 {
13465 if (vendor_id == VENDOR_ID_AMD)
13466 {
13467 cl_uint device_processor_cores = 0;
13468
13469 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13470
13471 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13472
13473 device_param->device_processor_cores = device_processor_cores;
13474 }
13475 else if (vendor_id == VENDOR_ID_NV)
13476 {
13477 cl_uint kernel_exec_timeout = 0;
13478
13479 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13480
13481 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13482
13483 device_param->kernel_exec_timeout = kernel_exec_timeout;
13484
13485 cl_uint device_processor_cores = 0;
13486
13487 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13488
13489 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13490
13491 device_param->device_processor_cores = device_processor_cores;
13492
13493 cl_uint sm_minor = 0;
13494 cl_uint sm_major = 0;
13495
13496 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13497 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13498
13499 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13500 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13501
13502 device_param->sm_minor = sm_minor;
13503 device_param->sm_major = sm_major;
13504 }
13505 else
13506 {
13507 cl_uint device_processor_cores = 1;
13508
13509 device_param->device_processor_cores = device_processor_cores;
13510 }
13511 }
13512
13513 // display results
13514
13515 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13516 {
13517 if (status_automat == 0)
13518 {
13519 if (device_param->skipped == 0)
13520 {
13521 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
13522 device_id + 1,
13523 device_name,
13524 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13525 (unsigned int) (device_global_mem / 1024 / 1024),
13526 (unsigned int) (device_maxclock_frequency),
13527 (unsigned int) device_processors);
13528 }
13529 else
13530 {
13531 log_info ("Device #%u: %s, skipped",
13532 device_id + 1,
13533 device_name);
13534 }
13535 }
13536 }
13537
13538 // common driver check
13539
13540 if (device_param->skipped == 0)
13541 {
13542 if (device_type & CL_DEVICE_TYPE_GPU)
13543 {
13544 if (vendor_id == VENDOR_ID_AMD)
13545 {
13546 int catalyst_check = (force == 1) ? 0 : 1;
13547
13548 int catalyst_warn = 0;
13549
13550 int catalyst_broken = 0;
13551
13552 if (catalyst_check == 1)
13553 {
13554 catalyst_warn = 1;
13555
13556 // v14.9 and higher
13557 if (atoi (device_param->driver_version) >= 1573)
13558 {
13559 catalyst_warn = 0;
13560 }
13561
13562 catalyst_check = 0;
13563 }
13564
13565 if (catalyst_broken == 1)
13566 {
13567 log_info ("");
13568 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13569 log_info ("It will pass over cracked hashes and does not report them as cracked");
13570 log_info ("You are STRONGLY encouraged not to use it");
13571 log_info ("You can use --force to override this but do not post error reports if you do so");
13572 log_info ("");
13573
13574 return (-1);
13575 }
13576
13577 if (catalyst_warn == 1)
13578 {
13579 log_info ("");
13580 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13581 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13582 log_info ("See hashcat's homepage for official supported catalyst drivers");
13583 #ifdef _WIN
13584 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13585 #endif
13586 log_info ("You can use --force to override this but do not post error reports if you do so");
13587 log_info ("");
13588
13589 return (-1);
13590 }
13591 }
13592 else if (vendor_id == VENDOR_ID_NV)
13593 {
13594 if (device_param->kernel_exec_timeout != 0)
13595 {
13596 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);
13597 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13598 }
13599 }
13600 }
13601
13602 if (device_type & CL_DEVICE_TYPE_CPU)
13603 {
13604 if (vendor_id == VENDOR_ID_AMD)
13605 {
13606 if (force == 0)
13607 {
13608 log_info ("");
13609 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13610 log_info ("You are STRONGLY encouraged not to use it");
13611 log_info ("You can use --force to override this but do not post error reports if you do so");
13612 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13613 log_info ("");
13614
13615 return (-1);
13616 }
13617 }
13618 }
13619
13620 /**
13621 * kernel accel and loops tuning db adjustment
13622 */
13623
13624 device_param->kernel_accel_min = 1;
13625 device_param->kernel_accel_max = 1024;
13626
13627 device_param->kernel_loops_min = 1;
13628 device_param->kernel_loops_max = 1024;
13629
13630 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13631
13632 if (tuningdb_entry)
13633 {
13634 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13635 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13636
13637 if (_kernel_accel)
13638 {
13639 device_param->kernel_accel_min = _kernel_accel;
13640 device_param->kernel_accel_max = _kernel_accel;
13641 }
13642
13643 if (_kernel_loops)
13644 {
13645 if (workload_profile == 1)
13646 {
13647 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13648 }
13649 else if (workload_profile == 2)
13650 {
13651 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13652 }
13653
13654 device_param->kernel_loops_min = _kernel_loops;
13655 device_param->kernel_loops_max = _kernel_loops;
13656 }
13657 }
13658
13659 // commandline parameters overwrite tuningdb entries
13660
13661 if (kernel_accel)
13662 {
13663 device_param->kernel_accel_min = kernel_accel;
13664 device_param->kernel_accel_max = kernel_accel;
13665 }
13666
13667 if (kernel_loops)
13668 {
13669 device_param->kernel_loops_min = kernel_loops;
13670 device_param->kernel_loops_max = kernel_loops;
13671 }
13672
13673 /**
13674 * activate device
13675 */
13676
13677 devices_active++;
13678 }
13679
13680 // next please
13681
13682 devices_cnt++;
13683 }
13684 }
13685
13686 if (keyspace == 0 && devices_active == 0)
13687 {
13688 log_error ("ERROR: No devices found/left");
13689
13690 return (-1);
13691 }
13692
13693 // 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)
13694
13695 if (devices_filter != (uint) -1)
13696 {
13697 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13698
13699 if (devices_filter > devices_cnt_mask)
13700 {
13701 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13702
13703 return (-1);
13704 }
13705 }
13706
13707 data.devices_cnt = devices_cnt;
13708
13709 data.devices_active = devices_active;
13710
13711 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13712 {
13713 if (status_automat == 0)
13714 {
13715 log_info ("");
13716 }
13717 }
13718
13719 /**
13720 * HM devices: init
13721 */
13722
13723 #ifdef HAVE_HWMON
13724 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13725 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13726 #endif
13727
13728 #ifdef HAVE_ADL
13729 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13730 #endif
13731
13732 if (gpu_temp_disable == 0)
13733 {
13734 #if defined(WIN) && defined(HAVE_NVAPI)
13735 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13736
13737 if (nvapi_init (nvapi) == 0)
13738 data.hm_nv = nvapi;
13739
13740 if (data.hm_nv)
13741 {
13742 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13743 {
13744 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13745
13746 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13747
13748 int tmp_out = 0;
13749
13750 for (int i = 0; i < tmp_in; i++)
13751 {
13752 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13753 }
13754
13755 for (int i = 0; i < tmp_out; i++)
13756 {
13757 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13758
13759 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13760
13761 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;
13762 }
13763 }
13764 }
13765 #endif // WIN && HAVE_NVAPI
13766
13767 #if defined(LINUX) && defined(HAVE_NVML)
13768 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13769
13770 if (nvml_init (nvml) == 0)
13771 data.hm_nv = nvml;
13772
13773 if (data.hm_nv)
13774 {
13775 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13776 {
13777 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13778
13779 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13780
13781 int tmp_out = 0;
13782
13783 for (int i = 0; i < tmp_in; i++)
13784 {
13785 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13786 }
13787
13788 for (int i = 0; i < tmp_out; i++)
13789 {
13790 unsigned int speed;
13791
13792 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;
13793 }
13794 }
13795 }
13796 #endif // LINUX && HAVE_NVML
13797
13798 data.hm_amd = NULL;
13799
13800 #ifdef HAVE_ADL
13801 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13802
13803 if (adl_init (adl) == 0)
13804 data.hm_amd = adl;
13805
13806 if (data.hm_amd)
13807 {
13808 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13809 {
13810 // total number of adapters
13811
13812 int hm_adapters_num;
13813
13814 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13815
13816 // adapter info
13817
13818 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13819
13820 if (lpAdapterInfo == NULL) return (-1);
13821
13822 // get a list (of ids of) valid/usable adapters
13823
13824 int num_adl_adapters = 0;
13825
13826 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13827
13828 if (num_adl_adapters > 0)
13829 {
13830 hc_thread_mutex_lock (mux_adl);
13831
13832 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13833
13834 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13835
13836 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13837 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13838
13839 hc_thread_mutex_unlock (mux_adl);
13840 }
13841
13842 myfree (valid_adl_device_list);
13843 myfree (lpAdapterInfo);
13844 }
13845 }
13846 #endif // HAVE_ADL
13847
13848 if (data.hm_amd == NULL && data.hm_nv == NULL)
13849 {
13850 gpu_temp_disable = 1;
13851 }
13852 }
13853
13854 /**
13855 * OpenCL devices: allocate buffer for device specific information
13856 */
13857
13858 #ifdef HAVE_HWMON
13859 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13860
13861 #ifdef HAVE_ADL
13862 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13863
13864 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13865 #endif // ADL
13866 #endif
13867
13868 /**
13869 * enable custom signal handler(s)
13870 */
13871
13872 if (benchmark == 0)
13873 {
13874 hc_signal (sigHandler_default);
13875 }
13876 else
13877 {
13878 hc_signal (sigHandler_benchmark);
13879 }
13880
13881 /**
13882 * User-defined GPU temp handling
13883 */
13884
13885 #ifdef HAVE_HWMON
13886 if (gpu_temp_disable == 1)
13887 {
13888 gpu_temp_abort = 0;
13889 gpu_temp_retain = 0;
13890 }
13891
13892 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13893 {
13894 if (gpu_temp_abort < gpu_temp_retain)
13895 {
13896 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13897
13898 return (-1);
13899 }
13900 }
13901
13902 data.gpu_temp_disable = gpu_temp_disable;
13903 data.gpu_temp_abort = gpu_temp_abort;
13904 data.gpu_temp_retain = gpu_temp_retain;
13905 #endif
13906
13907 /**
13908 * inform the user
13909 */
13910
13911 if (data.quiet == 0)
13912 {
13913 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13914
13915 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);
13916
13917 if (attack_mode == ATTACK_MODE_STRAIGHT)
13918 {
13919 log_info ("Rules: %u", kernel_rules_cnt);
13920 }
13921
13922 if (opti_type)
13923 {
13924 log_info ("Applicable Optimizers:");
13925
13926 for (uint i = 0; i < 32; i++)
13927 {
13928 const uint opti_bit = 1u << i;
13929
13930 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13931 }
13932 }
13933
13934 /**
13935 * Watchdog and Temperature balance
13936 */
13937
13938 #ifdef HAVE_HWMON
13939 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13940 {
13941 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13942 }
13943
13944 if (gpu_temp_abort == 0)
13945 {
13946 log_info ("Watchdog: Temperature abort trigger disabled");
13947 }
13948 else
13949 {
13950 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13951 }
13952
13953 if (gpu_temp_retain == 0)
13954 {
13955 log_info ("Watchdog: Temperature retain trigger disabled");
13956 }
13957 else
13958 {
13959 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13960 }
13961
13962 if (data.quiet == 0) log_info ("");
13963 #endif
13964 }
13965
13966 /**
13967 * HM devices: copy
13968 */
13969
13970 if (gpu_temp_disable == 0)
13971 {
13972 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13973 {
13974 hc_device_param_t *device_param = &data.devices_param[device_id];
13975
13976 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13977
13978 if (device_param->skipped) continue;
13979
13980 const uint platform_devices_id = device_param->platform_devices_id;
13981
13982 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13983 if (device_param->vendor_id == VENDOR_ID_NV)
13984 {
13985 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13986 }
13987 #endif
13988
13989 #ifdef HAVE_ADL
13990 if (device_param->vendor_id == VENDOR_ID_AMD)
13991 {
13992 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13993 }
13994 #endif
13995 }
13996 }
13997
13998 /*
13999 * Temporary fix:
14000 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14001 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14002 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14003 * Driver / ADL bug?
14004 */
14005
14006 #ifdef HAVE_ADL
14007 if (powertune_enable == 1)
14008 {
14009 hc_thread_mutex_lock (mux_adl);
14010
14011 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14012 {
14013 hc_device_param_t *device_param = &data.devices_param[device_id];
14014
14015 if (device_param->skipped) continue;
14016
14017 if (data.hm_device[device_id].od_version == 6)
14018 {
14019 // set powertune value only
14020
14021 int powertune_supported = 0;
14022
14023 int ADL_rc = 0;
14024
14025 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14026 {
14027 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14028
14029 return (-1);
14030 }
14031
14032 if (powertune_supported != 0)
14033 {
14034 // powertune set
14035 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14036
14037 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
14038 {
14039 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14040
14041 return (-1);
14042 }
14043
14044 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14045 {
14046 log_error ("ERROR: Failed to set new ADL PowerControl values");
14047
14048 return (-1);
14049 }
14050 }
14051 }
14052 }
14053
14054 hc_thread_mutex_unlock (mux_adl);
14055 }
14056 #endif // HAVE_ADK
14057 #endif // HAVE_HWMON
14058
14059 #ifdef DEBUG
14060 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14061 #endif
14062
14063 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14064
14065 uint kernel_power_all = 0;
14066
14067 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14068 {
14069 /**
14070 * host buffer
14071 */
14072
14073 hc_device_param_t *device_param = &data.devices_param[device_id];
14074
14075 if (device_param->skipped) continue;
14076
14077 /**
14078 * device properties
14079 */
14080
14081 const char *device_name_chksum = device_param->device_name_chksum;
14082 const u32 device_processors = device_param->device_processors;
14083 const u32 device_processor_cores = device_param->device_processor_cores;
14084
14085 /**
14086 * create context for each device
14087 */
14088
14089 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14090
14091 /**
14092 * create command-queue
14093 */
14094
14095 // not supported with NV
14096 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14097
14098 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14099
14100 /**
14101 * kernel threads: some algorithms need a fixed kernel-threads count
14102 * because of shared memory usage or bitslice
14103 * there needs to be some upper limit, otherwise there's too much overhead
14104 */
14105
14106 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14107
14108 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14109 {
14110 kernel_threads = KERNEL_THREADS_MAX_CPU;
14111 }
14112
14113 if (hash_mode == 1500) kernel_threads = 64; // DES
14114 if (hash_mode == 3000) kernel_threads = 64; // DES
14115 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14116 if (hash_mode == 7500) kernel_threads = 64; // RC4
14117 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14118 if (hash_mode == 9700) kernel_threads = 64; // RC4
14119 if (hash_mode == 9710) kernel_threads = 64; // RC4
14120 if (hash_mode == 9800) kernel_threads = 64; // RC4
14121 if (hash_mode == 9810) kernel_threads = 64; // RC4
14122 if (hash_mode == 10400) kernel_threads = 64; // RC4
14123 if (hash_mode == 10410) kernel_threads = 64; // RC4
14124 if (hash_mode == 10500) kernel_threads = 64; // RC4
14125 if (hash_mode == 13100) kernel_threads = 64; // RC4
14126
14127 /**
14128 * create input buffers on device : calculate size of fixed memory buffers
14129 */
14130
14131 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14132 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14133
14134 device_param->size_root_css = size_root_css;
14135 device_param->size_markov_css = size_markov_css;
14136
14137 size_t size_results = sizeof (uint);
14138
14139 device_param->size_results = size_results;
14140
14141 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14142 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14143
14144 size_t size_plains = digests_cnt * sizeof (plain_t);
14145 size_t size_salts = salts_cnt * sizeof (salt_t);
14146 size_t size_esalts = salts_cnt * esalt_size;
14147
14148 device_param->size_plains = size_plains;
14149 device_param->size_digests = size_digests;
14150 device_param->size_shown = size_shown;
14151 device_param->size_salts = size_salts;
14152
14153 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14154 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14155 size_t size_tm = 32 * sizeof (bs_word_t);
14156
14157 // scryptV stuff
14158
14159 size_t size_scryptV = 1;
14160
14161 if ((hash_mode == 8900) || (hash_mode == 9300))
14162 {
14163 uint tmto_start = 0;
14164 uint tmto_stop = 10;
14165
14166 if (scrypt_tmto)
14167 {
14168 tmto_start = scrypt_tmto;
14169 }
14170 else
14171 {
14172 // in case the user did not specify the tmto manually
14173 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14174 // but set the lower end only in case the user has a device with too less memory
14175
14176 if (hash_mode == 8900)
14177 {
14178 if (device_param->vendor_id == VENDOR_ID_AMD)
14179 {
14180 tmto_start = 1;
14181 }
14182 else if (device_param->vendor_id == VENDOR_ID_NV)
14183 {
14184 tmto_start = 2;
14185 }
14186 }
14187 else if (hash_mode == 9300)
14188 {
14189 if (device_param->vendor_id == VENDOR_ID_AMD)
14190 {
14191 tmto_start = 2;
14192 }
14193 else if (device_param->vendor_id == VENDOR_ID_NV)
14194 {
14195 tmto_start = 2;
14196 }
14197 }
14198 }
14199
14200 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14201 {
14202 // TODO: in theory the following calculation needs to be done per salt, not global
14203 // we assume all hashes have the same scrypt settings
14204
14205 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14206
14207 size_scryptV /= 1 << tmto;
14208
14209 size_scryptV *= device_processors * device_processor_cores;
14210
14211 if (size_scryptV > device_param->device_maxmem_alloc)
14212 {
14213 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14214
14215 continue;
14216 }
14217
14218 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14219 {
14220 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14221 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14222 }
14223
14224 break;
14225 }
14226
14227 if (data.salts_buf[0].scrypt_phy == 0)
14228 {
14229 log_error ("ERROR: can't allocate enough device memory");
14230
14231 return -1;
14232 }
14233
14234 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14235 }
14236
14237 /**
14238 * some algorithms need a fixed kernel-loops count
14239 */
14240
14241 if (hash_mode == 1500)
14242 {
14243 const u32 kernel_loops_fixed = 1024;
14244
14245 device_param->kernel_loops_min = kernel_loops_fixed;
14246 device_param->kernel_loops_max = kernel_loops_fixed;
14247 }
14248
14249 if (hash_mode == 3000)
14250 {
14251 const u32 kernel_loops_fixed = 1024;
14252
14253 device_param->kernel_loops_min = kernel_loops_fixed;
14254 device_param->kernel_loops_max = kernel_loops_fixed;
14255 }
14256
14257 if (hash_mode == 8900)
14258 {
14259 const u32 kernel_loops_fixed = 1;
14260
14261 device_param->kernel_loops_min = kernel_loops_fixed;
14262 device_param->kernel_loops_max = kernel_loops_fixed;
14263 }
14264
14265 if (hash_mode == 9300)
14266 {
14267 const u32 kernel_loops_fixed = 1;
14268
14269 device_param->kernel_loops_min = kernel_loops_fixed;
14270 device_param->kernel_loops_max = kernel_loops_fixed;
14271 }
14272
14273 if (hash_mode == 12500)
14274 {
14275 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14276
14277 device_param->kernel_loops_min = kernel_loops_fixed;
14278 device_param->kernel_loops_max = kernel_loops_fixed;
14279 }
14280
14281 /**
14282 * some algorithms have a maximum kernel-loops count
14283 */
14284
14285 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14286 {
14287 u32 innerloop_cnt = 0;
14288
14289 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14290 {
14291 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14292 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14293 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14294 }
14295 else
14296 {
14297 innerloop_cnt = data.salts_buf[0].salt_iter;
14298 }
14299
14300 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14301 (innerloop_cnt <= device_param->kernel_loops_max))
14302 {
14303 device_param->kernel_loops_max = innerloop_cnt;
14304 }
14305 }
14306
14307 /**
14308 * some algorithms need a special kernel-accel
14309 */
14310
14311 if (hash_mode == 8900)
14312 {
14313 device_param->kernel_accel_min = 1;
14314 device_param->kernel_accel_max = 64;
14315 }
14316
14317 if (hash_mode == 9300)
14318 {
14319 device_param->kernel_accel_min = 1;
14320 device_param->kernel_accel_max = 64;
14321 }
14322
14323 u32 kernel_accel_min = device_param->kernel_accel_min;
14324 u32 kernel_accel_max = device_param->kernel_accel_max;
14325
14326 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14327
14328 size_t size_pws = 4;
14329 size_t size_tmps = 4;
14330 size_t size_hooks = 4;
14331
14332 while (kernel_accel_max >= kernel_accel_min)
14333 {
14334 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14335
14336 // size_pws
14337
14338 size_pws = kernel_power_max * sizeof (pw_t);
14339
14340 // size_tmps
14341
14342 switch (hash_mode)
14343 {
14344 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14345 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14346 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14347 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14348 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14349 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14350 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14351 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14352 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14353 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14354 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14355 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14356 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14357 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14358 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14359 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14360 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14361 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14362 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14363 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14364 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14365 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14366 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14367 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14368 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14369 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14370 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14371 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14372 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14373 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14374 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14375 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14376 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14377 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14378 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14379 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14380 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14381 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14382 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14383 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14384 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14385 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14386 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14387 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14388 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14389 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14390 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14391 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14392 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14393 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14394 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14395 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14396 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14397 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14398 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14399 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14400 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14401 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14402 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14403 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14404 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14405 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14406 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14407 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14408 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14409 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14410 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14411 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14412 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14413 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14414 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14415 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14416 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14417 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14418 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14419 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14420 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14421 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14422 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14423 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14424 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14425 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14426 };
14427
14428 // size_hooks
14429
14430 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14431 {
14432 // none yet
14433 }
14434
14435 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14436 // if not, decrease amplifier and try again
14437
14438 int skip = 0;
14439
14440 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
14441 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
14442 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
14443
14444 if (( bitmap_size
14445 + bitmap_size
14446 + bitmap_size
14447 + bitmap_size
14448 + bitmap_size
14449 + bitmap_size
14450 + bitmap_size
14451 + bitmap_size
14452 + size_bfs
14453 + size_combs
14454 + size_digests
14455 + size_esalts
14456 + size_hooks
14457 + size_markov_css
14458 + size_plains
14459 + size_pws
14460 + size_pws // not a bug
14461 + size_results
14462 + size_root_css
14463 + size_rules
14464 + size_rules_c
14465 + size_salts
14466 + size_scryptV
14467 + size_shown
14468 + size_tm
14469 + size_tmps) > device_param->device_global_mem) skip = 1;
14470
14471 if (skip == 1)
14472 {
14473 kernel_accel_max--;
14474
14475 continue;
14476 }
14477
14478 break;
14479 }
14480
14481 /*
14482 if (kernel_accel_max == 0)
14483 {
14484 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14485
14486 return -1;
14487 }
14488 */
14489
14490 device_param->kernel_accel_min = kernel_accel_min;
14491 device_param->kernel_accel_max = kernel_accel_max;
14492
14493 /*
14494 if (kernel_accel_max < kernel_accel)
14495 {
14496 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14497
14498 device_param->kernel_accel = kernel_accel_max;
14499 }
14500 */
14501
14502 device_param->size_bfs = size_bfs;
14503 device_param->size_combs = size_combs;
14504 device_param->size_rules = size_rules;
14505 device_param->size_rules_c = size_rules_c;
14506 device_param->size_pws = size_pws;
14507 device_param->size_tmps = size_tmps;
14508 device_param->size_hooks = size_hooks;
14509
14510 // do not confuse kernel_accel_max with kernel_accel here
14511
14512 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
14513
14514 device_param->kernel_threads = kernel_threads;
14515 device_param->kernel_power_user = kernel_power;
14516
14517 kernel_power_all += kernel_power;
14518
14519 /**
14520 * default building options
14521 */
14522
14523 char build_opts[1024] = { 0 };
14524
14525 // we don't have sm_* on vendors not NV but it doesn't matter
14526
14527 snprintf (build_opts, sizeof (build_opts) - 1, "-cl-std=CL1.1 -I\"%s/\" -DVENDOR_ID=%u -DCUDA_ARCH=%d -DVECT_SIZE=%u -DDEVICE_TYPE=%u -DKERN_TYPE=%u -D_unroll", shared_dir, device_param->vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type, kern_type);
14528
14529 if (device_param->vendor_id == VENDOR_ID_INTEL_SDK)
14530 {
14531 // we do vectorizing much better than the auto-vectorizer
14532
14533 char build_opts_new[1024] = { 0 };
14534
14535 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14536
14537 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14538 }
14539
14540 #ifdef DEBUG
14541 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14542 #endif
14543
14544 /**
14545 * main kernel
14546 */
14547
14548 {
14549 /**
14550 * kernel source filename
14551 */
14552
14553 char source_file[256] = { 0 };
14554
14555 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14556
14557 struct stat sst;
14558
14559 if (stat (source_file, &sst) == -1)
14560 {
14561 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14562
14563 return -1;
14564 }
14565
14566 /**
14567 * kernel cached filename
14568 */
14569
14570 char cached_file[256] = { 0 };
14571
14572 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14573
14574 int cached = 1;
14575
14576 struct stat cst;
14577
14578 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14579 {
14580 cached = 0;
14581 }
14582
14583 /**
14584 * kernel compile or load
14585 */
14586
14587 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14588
14589 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14590
14591 if (force_jit_compilation == -1)
14592 {
14593 if (cached == 0)
14594 {
14595 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14596
14597 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14598
14599 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14600
14601 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14602
14603 #ifdef DEBUG
14604 size_t build_log_size = 0;
14605
14606 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14607
14608 if (build_log_size > 1)
14609 {
14610 char *build_log = (char *) malloc (build_log_size + 1);
14611
14612 memset (build_log, 0, build_log_size + 1);
14613
14614 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14615
14616 puts (build_log);
14617
14618 free (build_log);
14619 }
14620 #endif
14621
14622 if (rc != 0)
14623 {
14624 device_param->skipped = true;
14625
14626 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14627
14628 continue;
14629 }
14630
14631 size_t binary_size;
14632
14633 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14634
14635 u8 *binary = (u8 *) mymalloc (binary_size);
14636
14637 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14638
14639 writeProgramBin (cached_file, binary, binary_size);
14640
14641 local_free (binary);
14642 }
14643 else
14644 {
14645 #ifdef DEBUG
14646 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14647 #endif
14648
14649 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14650
14651 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14652
14653 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14654 }
14655 }
14656 else
14657 {
14658 #ifdef DEBUG
14659 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14660 #endif
14661
14662 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14663
14664 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14665
14666 char build_opts_update[1024] = { 0 };
14667
14668 if (force_jit_compilation == 1500)
14669 {
14670 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14671 }
14672 else if (force_jit_compilation == 8900)
14673 {
14674 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);
14675 }
14676 else
14677 {
14678 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14679 }
14680
14681 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14682
14683 #ifdef DEBUG
14684 size_t build_log_size = 0;
14685
14686 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14687
14688 if (build_log_size > 1)
14689 {
14690 char *build_log = (char *) malloc (build_log_size + 1);
14691
14692 memset (build_log, 0, build_log_size + 1);
14693
14694 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14695
14696 puts (build_log);
14697
14698 free (build_log);
14699 }
14700 #endif
14701
14702 if (rc != 0)
14703 {
14704 device_param->skipped = true;
14705
14706 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14707 }
14708 }
14709
14710 local_free (kernel_lengths);
14711 local_free (kernel_sources[0]);
14712 local_free (kernel_sources);
14713 }
14714
14715 /**
14716 * word generator kernel
14717 */
14718
14719 if (attack_mode != ATTACK_MODE_STRAIGHT)
14720 {
14721 /**
14722 * kernel mp source filename
14723 */
14724
14725 char source_file[256] = { 0 };
14726
14727 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14728
14729 struct stat sst;
14730
14731 if (stat (source_file, &sst) == -1)
14732 {
14733 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14734
14735 return -1;
14736 }
14737
14738 /**
14739 * kernel mp cached filename
14740 */
14741
14742 char cached_file[256] = { 0 };
14743
14744 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14745
14746 int cached = 1;
14747
14748 struct stat cst;
14749
14750 if (stat (cached_file, &cst) == -1)
14751 {
14752 cached = 0;
14753 }
14754
14755 /**
14756 * kernel compile or load
14757 */
14758
14759 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14760
14761 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14762
14763 if (cached == 0)
14764 {
14765 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14766 if (quiet == 0) log_info ("");
14767
14768 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14769
14770 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14771
14772 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14773
14774 if (rc != 0)
14775 {
14776 device_param->skipped = true;
14777
14778 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14779
14780 continue;
14781 }
14782
14783 size_t binary_size;
14784
14785 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14786
14787 u8 *binary = (u8 *) mymalloc (binary_size);
14788
14789 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14790
14791 writeProgramBin (cached_file, binary, binary_size);
14792
14793 local_free (binary);
14794 }
14795 else
14796 {
14797 #ifdef DEBUG
14798 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14799 #endif
14800
14801 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14802
14803 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14804
14805 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14806 }
14807
14808 local_free (kernel_lengths);
14809 local_free (kernel_sources[0]);
14810 local_free (kernel_sources);
14811 }
14812
14813 /**
14814 * amplifier kernel
14815 */
14816
14817 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14818 {
14819
14820 }
14821 else
14822 {
14823 /**
14824 * kernel amp source filename
14825 */
14826
14827 char source_file[256] = { 0 };
14828
14829 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14830
14831 struct stat sst;
14832
14833 if (stat (source_file, &sst) == -1)
14834 {
14835 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14836
14837 return -1;
14838 }
14839
14840 /**
14841 * kernel amp cached filename
14842 */
14843
14844 char cached_file[256] = { 0 };
14845
14846 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14847
14848 int cached = 1;
14849
14850 struct stat cst;
14851
14852 if (stat (cached_file, &cst) == -1)
14853 {
14854 cached = 0;
14855 }
14856
14857 /**
14858 * kernel compile or load
14859 */
14860
14861 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14862
14863 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14864
14865 if (cached == 0)
14866 {
14867 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14868 if (quiet == 0) log_info ("");
14869
14870 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14871
14872 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14873
14874 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14875
14876 if (rc != 0)
14877 {
14878 device_param->skipped = true;
14879
14880 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14881
14882 continue;
14883 }
14884
14885 size_t binary_size;
14886
14887 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14888
14889 u8 *binary = (u8 *) mymalloc (binary_size);
14890
14891 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14892
14893 writeProgramBin (cached_file, binary, binary_size);
14894
14895 local_free (binary);
14896 }
14897 else
14898 {
14899 #ifdef DEBUG
14900 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14901 #endif
14902
14903 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14904
14905 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14906
14907 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14908 }
14909
14910 local_free (kernel_lengths);
14911 local_free (kernel_sources[0]);
14912 local_free (kernel_sources);
14913 }
14914
14915 // some algorithm collide too fast, make that impossible
14916
14917 if (benchmark == 1)
14918 {
14919 ((uint *) digests_buf)[0] = -1;
14920 ((uint *) digests_buf)[1] = -1;
14921 ((uint *) digests_buf)[2] = -1;
14922 ((uint *) digests_buf)[3] = -1;
14923 }
14924
14925 /**
14926 * global buffers
14927 */
14928
14929 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14930 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14931 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14932 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14933 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14934 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14935 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14936 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14937 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14938 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14939 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14940 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14941 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14942 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14943 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14944 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14945 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14946 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14947
14948 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);
14949 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);
14950 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);
14951 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);
14952 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);
14953 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);
14954 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);
14955 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);
14956 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14957 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14958 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14959
14960 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14961 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14962 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14963 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14964 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14965 run_kernel_bzero (device_param, device_param->d_result, size_results);
14966
14967 /**
14968 * special buffers
14969 */
14970
14971 if (attack_kern == ATTACK_KERN_STRAIGHT)
14972 {
14973 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14974 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14975
14976 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14977
14978 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14979 }
14980 else if (attack_kern == ATTACK_KERN_COMBI)
14981 {
14982 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14983 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14984 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14985 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14986
14987 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14988 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14989 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14990 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14991 }
14992 else if (attack_kern == ATTACK_KERN_BF)
14993 {
14994 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14995 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14996 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14997 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14998 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14999
15000 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15001 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15002 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15003 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15004 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15005 }
15006
15007 if (size_esalts)
15008 {
15009 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15010
15011 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15012 }
15013
15014 /**
15015 * main host data
15016 */
15017
15018 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15019
15020 device_param->pws_buf = pws_buf;
15021
15022 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15023
15024 device_param->combs_buf = combs_buf;
15025
15026 void *hooks_buf = mymalloc (size_hooks);
15027
15028 device_param->hooks_buf = hooks_buf;
15029
15030 /**
15031 * kernel args
15032 */
15033
15034 device_param->kernel_params_buf32[21] = bitmap_mask;
15035 device_param->kernel_params_buf32[22] = bitmap_shift1;
15036 device_param->kernel_params_buf32[23] = bitmap_shift2;
15037 device_param->kernel_params_buf32[24] = 0; // salt_pos
15038 device_param->kernel_params_buf32[25] = 0; // loop_pos
15039 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15040 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15041 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15042 device_param->kernel_params_buf32[29] = 0; // digests_offset
15043 device_param->kernel_params_buf32[30] = 0; // combs_mode
15044 device_param->kernel_params_buf32[31] = 0; // gid_max
15045
15046 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15047 ? &device_param->d_pws_buf
15048 : &device_param->d_pws_amp_buf;
15049 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15050 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15051 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15052 device_param->kernel_params[ 4] = &device_param->d_tmps;
15053 device_param->kernel_params[ 5] = &device_param->d_hooks;
15054 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15055 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15056 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15057 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15058 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15059 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15060 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15061 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15062 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15063 device_param->kernel_params[15] = &device_param->d_digests_buf;
15064 device_param->kernel_params[16] = &device_param->d_digests_shown;
15065 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15066 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15067 device_param->kernel_params[19] = &device_param->d_result;
15068 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15069 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15070 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15071 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15072 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15073 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15074 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15075 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15076 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15077 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15078 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15079 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15080
15081 device_param->kernel_params_mp_buf64[3] = 0;
15082 device_param->kernel_params_mp_buf32[4] = 0;
15083 device_param->kernel_params_mp_buf32[5] = 0;
15084 device_param->kernel_params_mp_buf32[6] = 0;
15085 device_param->kernel_params_mp_buf32[7] = 0;
15086 device_param->kernel_params_mp_buf32[8] = 0;
15087
15088 device_param->kernel_params_mp[0] = NULL;
15089 device_param->kernel_params_mp[1] = NULL;
15090 device_param->kernel_params_mp[2] = NULL;
15091 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15092 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15093 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15094 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15095 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15096 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15097
15098 device_param->kernel_params_mp_l_buf64[3] = 0;
15099 device_param->kernel_params_mp_l_buf32[4] = 0;
15100 device_param->kernel_params_mp_l_buf32[5] = 0;
15101 device_param->kernel_params_mp_l_buf32[6] = 0;
15102 device_param->kernel_params_mp_l_buf32[7] = 0;
15103 device_param->kernel_params_mp_l_buf32[8] = 0;
15104 device_param->kernel_params_mp_l_buf32[9] = 0;
15105
15106 device_param->kernel_params_mp_l[0] = NULL;
15107 device_param->kernel_params_mp_l[1] = NULL;
15108 device_param->kernel_params_mp_l[2] = NULL;
15109 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15110 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15111 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15112 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15113 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15114 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15115 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15116
15117 device_param->kernel_params_mp_r_buf64[3] = 0;
15118 device_param->kernel_params_mp_r_buf32[4] = 0;
15119 device_param->kernel_params_mp_r_buf32[5] = 0;
15120 device_param->kernel_params_mp_r_buf32[6] = 0;
15121 device_param->kernel_params_mp_r_buf32[7] = 0;
15122 device_param->kernel_params_mp_r_buf32[8] = 0;
15123
15124 device_param->kernel_params_mp_r[0] = NULL;
15125 device_param->kernel_params_mp_r[1] = NULL;
15126 device_param->kernel_params_mp_r[2] = NULL;
15127 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15128 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15129 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15130 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15131 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15132 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15133
15134 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15135 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15136
15137 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15138 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15139 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15140 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15141 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15142 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15143 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15144
15145 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15146 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15147
15148 /**
15149 * kernel name
15150 */
15151
15152 size_t kernel_wgs_tmp;
15153
15154 char kernel_name[64] = { 0 };
15155
15156 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15157 {
15158 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15159 {
15160 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15161
15162 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15163
15164 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15165
15166 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15167
15168 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15169
15170 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15171 }
15172 else
15173 {
15174 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15175
15176 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15177
15178 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15179
15180 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15181
15182 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15183
15184 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15185 }
15186
15187 if (data.attack_mode == ATTACK_MODE_BF)
15188 {
15189 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15190 {
15191 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15192
15193 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15194
15195 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_tm, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
15196 }
15197 }
15198 }
15199 else
15200 {
15201 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15202
15203 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15204
15205 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15206
15207 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15208
15209 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15210
15211 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15212
15213 if (opts_type & OPTS_TYPE_HOOK12)
15214 {
15215 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15216
15217 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15218
15219 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel12, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
15220 }
15221
15222 if (opts_type & OPTS_TYPE_HOOK23)
15223 {
15224 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15225
15226 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15227
15228 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel23, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
15229 }
15230 }
15231
15232 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel1, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
15233 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel2, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
15234 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel3, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
15235
15236 for (uint i = 0; i <= 20; i++)
15237 {
15238 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15239 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15240 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15241
15242 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15243 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15244 }
15245
15246 for (uint i = 21; i <= 31; i++)
15247 {
15248 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15249 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15250 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15251
15252 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15253 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15254 }
15255
15256 if (attack_mode == ATTACK_MODE_BF)
15257 {
15258 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15259 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15260
15261 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_mp_l, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
15262 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_mp_r, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
15263
15264 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15265 {
15266 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15267 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15268 }
15269 }
15270 else if (attack_mode == ATTACK_MODE_HYBRID1)
15271 {
15272 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15273
15274 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_mp, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
15275 }
15276 else if (attack_mode == ATTACK_MODE_HYBRID2)
15277 {
15278 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15279
15280 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_mp, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
15281 }
15282
15283 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15284 {
15285 // nothing to do
15286 }
15287 else
15288 {
15289 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15290
15291 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_amp, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
15292 }
15293
15294 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15295 {
15296 // nothing to do
15297 }
15298 else
15299 {
15300 for (uint i = 0; i < 5; i++)
15301 {
15302 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15303 }
15304
15305 for (uint i = 5; i < 7; i++)
15306 {
15307 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15308 }
15309 }
15310
15311 // maybe this has been updated by clGetKernelWorkGroupInfo()
15312 // value can only be decreased, so we don't need to reallocate buffers
15313
15314 device_param->kernel_threads = kernel_threads;
15315
15316 /**
15317 * Store initial fanspeed if gpu_temp_retain is enabled
15318 */
15319
15320 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
15321 int gpu_temp_retain_set = 0;
15322
15323 if (gpu_temp_disable == 0)
15324 {
15325 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
15326 {
15327 hc_thread_mutex_lock (mux_adl);
15328
15329 if (data.hm_device[device_id].fan_supported == 1)
15330 {
15331 if (gpu_temp_retain_chgd == 0)
15332 {
15333 uint cur_temp = 0;
15334 uint default_temp = 0;
15335
15336 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);
15337
15338 if (ADL_rc == ADL_OK)
15339 {
15340 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
15341
15342 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
15343
15344 // special case with multi gpu setups: always use minimum retain
15345
15346 if (gpu_temp_retain_set == 0)
15347 {
15348 gpu_temp_retain = gpu_temp_retain_target;
15349 gpu_temp_retain_set = 1;
15350 }
15351 else
15352 {
15353 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
15354 }
15355
15356 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
15357 }
15358 }
15359
15360 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
15361
15362 temp_retain_fanspeed_value[device_id] = fan_speed;
15363
15364 if (fan_speed == -1)
15365 {
15366 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
15367
15368 temp_retain_fanspeed_value[device_id] = 0;
15369 }
15370 }
15371
15372 hc_thread_mutex_unlock (mux_adl);
15373 }
15374 }
15375
15376 /**
15377 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
15378 */
15379
15380 if (powertune_enable == 1) // VENDOR_ID_AMD implied
15381 {
15382 hc_thread_mutex_lock (mux_adl);
15383
15384 if (data.hm_device[device_id].od_version == 6)
15385 {
15386 int ADL_rc;
15387
15388 // check powertune capabilities first, if not available then skip device
15389
15390 int powertune_supported = 0;
15391
15392 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
15393 {
15394 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
15395
15396 return (-1);
15397 }
15398
15399 if (powertune_supported != 0)
15400 {
15401 // powercontrol settings
15402
15403 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
15404
15405 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
15406 {
15407 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
15408 }
15409
15410 if (ADL_rc != ADL_OK)
15411 {
15412 log_error ("ERROR: Failed to get current ADL PowerControl settings");
15413
15414 return (-1);
15415 }
15416
15417 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
15418 {
15419 log_error ("ERROR: Failed to set new ADL PowerControl values");
15420
15421 return (-1);
15422 }
15423
15424 // clocks
15425
15426 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
15427
15428 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
15429
15430 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)
15431 {
15432 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
15433
15434 return (-1);
15435 }
15436
15437 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
15438
15439 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
15440
15441 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
15442 {
15443 log_error ("ERROR: Failed to get ADL device capabilities");
15444
15445 return (-1);
15446 }
15447
15448 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
15449 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
15450
15451 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
15452 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
15453
15454 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
15455 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
15456
15457 // warning if profile has too low max values
15458
15459 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
15460 {
15461 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
15462 }
15463
15464 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
15465 {
15466 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
15467 }
15468
15469 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
15470
15471 performance_state->iNumberOfPerformanceLevels = 2;
15472
15473 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
15474 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
15475 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
15476 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
15477
15478 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)
15479 {
15480 log_info ("ERROR: Failed to set ADL performance state");
15481
15482 return (-1);
15483 }
15484
15485 local_free (performance_state);
15486 }
15487 }
15488
15489 hc_thread_mutex_unlock (mux_adl);
15490 }
15491 #endif // HAVE_HWMON && HAVE_ADL
15492 }
15493
15494 data.kernel_power_all = kernel_power_all;
15495
15496 if (data.quiet == 0) log_info_nn ("");
15497
15498 /**
15499 * In benchmark-mode, inform user which algorithm is checked
15500 */
15501
15502 if (benchmark == 1)
15503 {
15504 if (status_automat == 0)
15505 {
15506 quiet = 0;
15507
15508 data.quiet = quiet;
15509
15510 char *hash_type = strhashtype (data.hash_mode); // not a bug
15511
15512 log_info ("Hashtype: %s", hash_type);
15513 log_info ("");
15514 }
15515 }
15516
15517 /**
15518 * keep track of the progress
15519 */
15520
15521 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15522 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15523 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15524
15525 /**
15526 * open filehandles
15527 */
15528
15529 #if _WIN
15530 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15531 {
15532 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15533
15534 return (-1);
15535 }
15536
15537 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15538 {
15539 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15540
15541 return (-1);
15542 }
15543
15544 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15545 {
15546 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15547
15548 return (-1);
15549 }
15550 #endif
15551
15552 /**
15553 * dictionary pad
15554 */
15555
15556 segment_size *= (1024 * 1024);
15557
15558 data.segment_size = segment_size;
15559
15560 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15561
15562 wl_data->buf = (char *) mymalloc (segment_size);
15563 wl_data->avail = segment_size;
15564 wl_data->incr = segment_size;
15565 wl_data->cnt = 0;
15566 wl_data->pos = 0;
15567
15568 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15569
15570 data.wordlist_mode = wordlist_mode;
15571
15572 cs_t *css_buf = NULL;
15573 uint css_cnt = 0;
15574 uint dictcnt = 0;
15575 uint maskcnt = 1;
15576 char **masks = NULL;
15577 char **dictfiles = NULL;
15578
15579 uint mask_from_file = 0;
15580
15581 if (attack_mode == ATTACK_MODE_STRAIGHT)
15582 {
15583 if (wordlist_mode == WL_MODE_FILE)
15584 {
15585 int wls_left = myargc - (optind + 1);
15586
15587 for (int i = 0; i < wls_left; i++)
15588 {
15589 char *l0_filename = myargv[optind + 1 + i];
15590
15591 struct stat l0_stat;
15592
15593 if (stat (l0_filename, &l0_stat) == -1)
15594 {
15595 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15596
15597 return (-1);
15598 }
15599
15600 uint is_dir = S_ISDIR (l0_stat.st_mode);
15601
15602 if (is_dir == 0)
15603 {
15604 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15605
15606 dictcnt++;
15607
15608 dictfiles[dictcnt - 1] = l0_filename;
15609 }
15610 else
15611 {
15612 // do not allow --keyspace w/ a directory
15613
15614 if (keyspace == 1)
15615 {
15616 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15617
15618 return (-1);
15619 }
15620
15621 char **dictionary_files = NULL;
15622
15623 dictionary_files = scan_directory (l0_filename);
15624
15625 if (dictionary_files != NULL)
15626 {
15627 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15628
15629 for (int d = 0; dictionary_files[d] != NULL; d++)
15630 {
15631 char *l1_filename = dictionary_files[d];
15632
15633 struct stat l1_stat;
15634
15635 if (stat (l1_filename, &l1_stat) == -1)
15636 {
15637 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15638
15639 return (-1);
15640 }
15641
15642 if (S_ISREG (l1_stat.st_mode))
15643 {
15644 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15645
15646 dictcnt++;
15647
15648 dictfiles[dictcnt - 1] = strdup (l1_filename);
15649 }
15650 }
15651 }
15652
15653 local_free (dictionary_files);
15654 }
15655 }
15656
15657 if (dictcnt < 1)
15658 {
15659 log_error ("ERROR: No usable dictionary file found.");
15660
15661 return (-1);
15662 }
15663 }
15664 else if (wordlist_mode == WL_MODE_STDIN)
15665 {
15666 dictcnt = 1;
15667 }
15668 }
15669 else if (attack_mode == ATTACK_MODE_COMBI)
15670 {
15671 // display
15672
15673 char *dictfile1 = myargv[optind + 1 + 0];
15674 char *dictfile2 = myargv[optind + 1 + 1];
15675
15676 // find the bigger dictionary and use as base
15677
15678 FILE *fp1 = NULL;
15679 FILE *fp2 = NULL;
15680
15681 struct stat tmp_stat;
15682
15683 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15684 {
15685 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15686
15687 return (-1);
15688 }
15689
15690 if (stat (dictfile1, &tmp_stat) == -1)
15691 {
15692 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15693
15694 fclose (fp1);
15695
15696 return (-1);
15697 }
15698
15699 if (S_ISDIR (tmp_stat.st_mode))
15700 {
15701 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15702
15703 fclose (fp1);
15704
15705 return (-1);
15706 }
15707
15708 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15709 {
15710 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15711
15712 fclose (fp1);
15713
15714 return (-1);
15715 }
15716
15717 if (stat (dictfile2, &tmp_stat) == -1)
15718 {
15719 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15720
15721 fclose (fp1);
15722 fclose (fp2);
15723
15724 return (-1);
15725 }
15726
15727 if (S_ISDIR (tmp_stat.st_mode))
15728 {
15729 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15730
15731 fclose (fp1);
15732 fclose (fp2);
15733
15734 return (-1);
15735 }
15736
15737 data.combs_cnt = 1;
15738
15739 data.quiet = 1;
15740
15741 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15742
15743 data.quiet = quiet;
15744
15745 if (words1_cnt == 0)
15746 {
15747 log_error ("ERROR: %s: empty file", dictfile1);
15748
15749 fclose (fp1);
15750 fclose (fp2);
15751
15752 return (-1);
15753 }
15754
15755 data.combs_cnt = 1;
15756
15757 data.quiet = 1;
15758
15759 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15760
15761 data.quiet = quiet;
15762
15763 if (words2_cnt == 0)
15764 {
15765 log_error ("ERROR: %s: empty file", dictfile2);
15766
15767 fclose (fp1);
15768 fclose (fp2);
15769
15770 return (-1);
15771 }
15772
15773 fclose (fp1);
15774 fclose (fp2);
15775
15776 data.dictfile = dictfile1;
15777 data.dictfile2 = dictfile2;
15778
15779 if (words1_cnt >= words2_cnt)
15780 {
15781 data.combs_cnt = words2_cnt;
15782 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15783
15784 dictfiles = &data.dictfile;
15785
15786 dictcnt = 1;
15787 }
15788 else
15789 {
15790 data.combs_cnt = words1_cnt;
15791 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15792
15793 dictfiles = &data.dictfile2;
15794
15795 dictcnt = 1;
15796
15797 // we also have to switch wordlist related rules!
15798
15799 char *tmpc = data.rule_buf_l;
15800
15801 data.rule_buf_l = data.rule_buf_r;
15802 data.rule_buf_r = tmpc;
15803
15804 int tmpi = data.rule_len_l;
15805
15806 data.rule_len_l = data.rule_len_r;
15807 data.rule_len_r = tmpi;
15808 }
15809 }
15810 else if (attack_mode == ATTACK_MODE_BF)
15811 {
15812 char *mask = NULL;
15813
15814 maskcnt = 0;
15815
15816 if (benchmark == 0)
15817 {
15818 mask = myargv[optind + 1];
15819
15820 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15821
15822 if ((optind + 2) <= myargc)
15823 {
15824 struct stat file_stat;
15825
15826 if (stat (mask, &file_stat) == -1)
15827 {
15828 maskcnt = 1;
15829
15830 masks[maskcnt - 1] = mystrdup (mask);
15831 }
15832 else
15833 {
15834 int wls_left = myargc - (optind + 1);
15835
15836 uint masks_avail = INCR_MASKS;
15837
15838 for (int i = 0; i < wls_left; i++)
15839 {
15840 if (i != 0)
15841 {
15842 mask = myargv[optind + 1 + i];
15843
15844 if (stat (mask, &file_stat) == -1)
15845 {
15846 log_error ("ERROR: %s: %s", mask, strerror (errno));
15847
15848 return (-1);
15849 }
15850 }
15851
15852 uint is_file = S_ISREG (file_stat.st_mode);
15853
15854 if (is_file == 1)
15855 {
15856 FILE *mask_fp;
15857
15858 if ((mask_fp = fopen (mask, "r")) == NULL)
15859 {
15860 log_error ("ERROR: %s: %s", mask, strerror (errno));
15861
15862 return (-1);
15863 }
15864
15865 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15866
15867 while (!feof (mask_fp))
15868 {
15869 memset (line_buf, 0, HCBUFSIZ);
15870
15871 int line_len = fgetl (mask_fp, line_buf);
15872
15873 if (line_len == 0) continue;
15874
15875 if (line_buf[0] == '#') continue;
15876
15877 if (masks_avail == maskcnt)
15878 {
15879 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15880
15881 masks_avail += INCR_MASKS;
15882 }
15883
15884 masks[maskcnt] = mystrdup (line_buf);
15885
15886 maskcnt++;
15887 }
15888
15889 myfree (line_buf);
15890
15891 fclose (mask_fp);
15892 }
15893 else
15894 {
15895 log_error ("ERROR: %s: unsupported file-type", mask);
15896
15897 return (-1);
15898 }
15899 }
15900
15901 mask_from_file = 1;
15902 }
15903 }
15904 else
15905 {
15906 custom_charset_1 = (char *) "?l?d?u";
15907 custom_charset_2 = (char *) "?l?d";
15908 custom_charset_3 = (char *) "?l?d*!$@_";
15909
15910 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15911 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15912 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15913
15914 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15915
15916 wordlist_mode = WL_MODE_MASK;
15917
15918 data.wordlist_mode = wordlist_mode;
15919
15920 increment = 1;
15921
15922 maskcnt = 1;
15923 }
15924 }
15925 else
15926 {
15927 /**
15928 * generate full masks and charsets
15929 */
15930
15931 masks = (char **) mymalloc (sizeof (char *));
15932
15933 switch (hash_mode)
15934 {
15935 case 1731: pw_min = 5;
15936 pw_max = 5;
15937 mask = mystrdup ("?b?b?b?b?b");
15938 break;
15939 case 12500: pw_min = 5;
15940 pw_max = 5;
15941 mask = mystrdup ("?b?b?b?b?b");
15942 break;
15943 default: pw_min = 7;
15944 pw_max = 7;
15945 mask = mystrdup ("?b?b?b?b?b?b?b");
15946 break;
15947 }
15948
15949 maskcnt = 1;
15950
15951 masks[maskcnt - 1] = mystrdup (mask);
15952
15953 wordlist_mode = WL_MODE_MASK;
15954
15955 data.wordlist_mode = wordlist_mode;
15956
15957 increment = 1;
15958 }
15959
15960 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15961
15962 if (increment)
15963 {
15964 if (increment_min > pw_min) pw_min = increment_min;
15965
15966 if (increment_max < pw_max) pw_max = increment_max;
15967 }
15968 }
15969 else if (attack_mode == ATTACK_MODE_HYBRID1)
15970 {
15971 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15972
15973 // display
15974
15975 char *mask = myargv[myargc - 1];
15976
15977 maskcnt = 0;
15978
15979 masks = (char **) mymalloc (1 * sizeof (char *));
15980
15981 // mod
15982
15983 struct stat file_stat;
15984
15985 if (stat (mask, &file_stat) == -1)
15986 {
15987 maskcnt = 1;
15988
15989 masks[maskcnt - 1] = mystrdup (mask);
15990 }
15991 else
15992 {
15993 uint is_file = S_ISREG (file_stat.st_mode);
15994
15995 if (is_file == 1)
15996 {
15997 FILE *mask_fp;
15998
15999 if ((mask_fp = fopen (mask, "r")) == NULL)
16000 {
16001 log_error ("ERROR: %s: %s", mask, strerror (errno));
16002
16003 return (-1);
16004 }
16005
16006 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16007
16008 uint masks_avail = 1;
16009
16010 while (!feof (mask_fp))
16011 {
16012 memset (line_buf, 0, HCBUFSIZ);
16013
16014 int line_len = fgetl (mask_fp, line_buf);
16015
16016 if (line_len == 0) continue;
16017
16018 if (line_buf[0] == '#') continue;
16019
16020 if (masks_avail == maskcnt)
16021 {
16022 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16023
16024 masks_avail += INCR_MASKS;
16025 }
16026
16027 masks[maskcnt] = mystrdup (line_buf);
16028
16029 maskcnt++;
16030 }
16031
16032 myfree (line_buf);
16033
16034 fclose (mask_fp);
16035
16036 mask_from_file = 1;
16037 }
16038 else
16039 {
16040 maskcnt = 1;
16041
16042 masks[maskcnt - 1] = mystrdup (mask);
16043 }
16044 }
16045
16046 // base
16047
16048 int wls_left = myargc - (optind + 2);
16049
16050 for (int i = 0; i < wls_left; i++)
16051 {
16052 char *filename = myargv[optind + 1 + i];
16053
16054 struct stat file_stat;
16055
16056 if (stat (filename, &file_stat) == -1)
16057 {
16058 log_error ("ERROR: %s: %s", filename, strerror (errno));
16059
16060 return (-1);
16061 }
16062
16063 uint is_dir = S_ISDIR (file_stat.st_mode);
16064
16065 if (is_dir == 0)
16066 {
16067 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16068
16069 dictcnt++;
16070
16071 dictfiles[dictcnt - 1] = filename;
16072 }
16073 else
16074 {
16075 // do not allow --keyspace w/ a directory
16076
16077 if (keyspace == 1)
16078 {
16079 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16080
16081 return (-1);
16082 }
16083
16084 char **dictionary_files = NULL;
16085
16086 dictionary_files = scan_directory (filename);
16087
16088 if (dictionary_files != NULL)
16089 {
16090 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16091
16092 for (int d = 0; dictionary_files[d] != NULL; d++)
16093 {
16094 char *l1_filename = dictionary_files[d];
16095
16096 struct stat l1_stat;
16097
16098 if (stat (l1_filename, &l1_stat) == -1)
16099 {
16100 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16101
16102 return (-1);
16103 }
16104
16105 if (S_ISREG (l1_stat.st_mode))
16106 {
16107 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16108
16109 dictcnt++;
16110
16111 dictfiles[dictcnt - 1] = strdup (l1_filename);
16112 }
16113 }
16114 }
16115
16116 local_free (dictionary_files);
16117 }
16118 }
16119
16120 if (dictcnt < 1)
16121 {
16122 log_error ("ERROR: No usable dictionary file found.");
16123
16124 return (-1);
16125 }
16126
16127 if (increment)
16128 {
16129 maskcnt = 0;
16130
16131 uint mask_min = increment_min; // we can't reject smaller masks here
16132 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16133
16134 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16135 {
16136 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16137
16138 if (cur_mask == NULL) break;
16139
16140 masks[maskcnt] = cur_mask;
16141
16142 maskcnt++;
16143
16144 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16145 }
16146 }
16147 }
16148 else if (attack_mode == ATTACK_MODE_HYBRID2)
16149 {
16150 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16151
16152 // display
16153
16154 char *mask = myargv[optind + 1 + 0];
16155
16156 maskcnt = 0;
16157
16158 masks = (char **) mymalloc (1 * sizeof (char *));
16159
16160 // mod
16161
16162 struct stat file_stat;
16163
16164 if (stat (mask, &file_stat) == -1)
16165 {
16166 maskcnt = 1;
16167
16168 masks[maskcnt - 1] = mystrdup (mask);
16169 }
16170 else
16171 {
16172 uint is_file = S_ISREG (file_stat.st_mode);
16173
16174 if (is_file == 1)
16175 {
16176 FILE *mask_fp;
16177
16178 if ((mask_fp = fopen (mask, "r")) == NULL)
16179 {
16180 log_error ("ERROR: %s: %s", mask, strerror (errno));
16181
16182 return (-1);
16183 }
16184
16185 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16186
16187 uint masks_avail = 1;
16188
16189 while (!feof (mask_fp))
16190 {
16191 memset (line_buf, 0, HCBUFSIZ);
16192
16193 int line_len = fgetl (mask_fp, line_buf);
16194
16195 if (line_len == 0) continue;
16196
16197 if (line_buf[0] == '#') continue;
16198
16199 if (masks_avail == maskcnt)
16200 {
16201 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16202
16203 masks_avail += INCR_MASKS;
16204 }
16205
16206 masks[maskcnt] = mystrdup (line_buf);
16207
16208 maskcnt++;
16209 }
16210
16211 myfree (line_buf);
16212
16213 fclose (mask_fp);
16214
16215 mask_from_file = 1;
16216 }
16217 else
16218 {
16219 maskcnt = 1;
16220
16221 masks[maskcnt - 1] = mystrdup (mask);
16222 }
16223 }
16224
16225 // base
16226
16227 int wls_left = myargc - (optind + 2);
16228
16229 for (int i = 0; i < wls_left; i++)
16230 {
16231 char *filename = myargv[optind + 2 + i];
16232
16233 struct stat file_stat;
16234
16235 if (stat (filename, &file_stat) == -1)
16236 {
16237 log_error ("ERROR: %s: %s", filename, strerror (errno));
16238
16239 return (-1);
16240 }
16241
16242 uint is_dir = S_ISDIR (file_stat.st_mode);
16243
16244 if (is_dir == 0)
16245 {
16246 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16247
16248 dictcnt++;
16249
16250 dictfiles[dictcnt - 1] = filename;
16251 }
16252 else
16253 {
16254 // do not allow --keyspace w/ a directory
16255
16256 if (keyspace == 1)
16257 {
16258 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16259
16260 return (-1);
16261 }
16262
16263 char **dictionary_files = NULL;
16264
16265 dictionary_files = scan_directory (filename);
16266
16267 if (dictionary_files != NULL)
16268 {
16269 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16270
16271 for (int d = 0; dictionary_files[d] != NULL; d++)
16272 {
16273 char *l1_filename = dictionary_files[d];
16274
16275 struct stat l1_stat;
16276
16277 if (stat (l1_filename, &l1_stat) == -1)
16278 {
16279 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16280
16281 return (-1);
16282 }
16283
16284 if (S_ISREG (l1_stat.st_mode))
16285 {
16286 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16287
16288 dictcnt++;
16289
16290 dictfiles[dictcnt - 1] = strdup (l1_filename);
16291 }
16292 }
16293 }
16294
16295 local_free (dictionary_files);
16296 }
16297 }
16298
16299 if (dictcnt < 1)
16300 {
16301 log_error ("ERROR: No usable dictionary file found.");
16302
16303 return (-1);
16304 }
16305
16306 if (increment)
16307 {
16308 maskcnt = 0;
16309
16310 uint mask_min = increment_min; // we can't reject smaller masks here
16311 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16312
16313 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16314 {
16315 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16316
16317 if (cur_mask == NULL) break;
16318
16319 masks[maskcnt] = cur_mask;
16320
16321 maskcnt++;
16322
16323 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16324 }
16325 }
16326 }
16327
16328 data.pw_min = pw_min;
16329 data.pw_max = pw_max;
16330
16331 /**
16332 * weak hash check
16333 */
16334
16335 if (weak_hash_threshold >= salts_cnt)
16336 {
16337 hc_device_param_t *device_param = NULL;
16338
16339 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16340 {
16341 device_param = &data.devices_param[device_id];
16342
16343 if (device_param->skipped) continue;
16344
16345 break;
16346 }
16347
16348 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16349
16350 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16351 {
16352 weak_hash_check (device_param, salt_pos);
16353 }
16354
16355 // Display hack, guarantee that there is at least one \r before real start
16356
16357 //if (data.quiet == 0) log_info ("");
16358 }
16359
16360 /**
16361 * status and monitor threads
16362 */
16363
16364 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16365
16366 hc_thread_t i_thread = 0;
16367
16368 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16369 {
16370 hc_thread_create (i_thread, thread_keypress, &benchmark);
16371 }
16372
16373 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16374
16375 uint ni_threads_cnt = 0;
16376
16377 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16378
16379 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16380
16381 ni_threads_cnt++;
16382
16383 /**
16384 * Outfile remove
16385 */
16386
16387 if (keyspace == 0)
16388 {
16389 if (outfile_check_timer != 0)
16390 {
16391 if (data.outfile_check_directory != NULL)
16392 {
16393 if ((hash_mode != 5200) &&
16394 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16395 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16396 (hash_mode != 9000))
16397 {
16398 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16399
16400 ni_threads_cnt++;
16401 }
16402 else
16403 {
16404 outfile_check_timer = 0;
16405 }
16406 }
16407 else
16408 {
16409 outfile_check_timer = 0;
16410 }
16411 }
16412 }
16413
16414 /**
16415 * Inform the user if we got some hashes remove because of the pot file remove feature
16416 */
16417
16418 if (data.quiet == 0)
16419 {
16420 if (potfile_remove_cracks > 0)
16421 {
16422 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16423 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16424 }
16425 }
16426
16427 data.outfile_check_timer = outfile_check_timer;
16428
16429 /**
16430 * main loop
16431 */
16432
16433 char **induction_dictionaries = NULL;
16434
16435 int induction_dictionaries_cnt = 0;
16436
16437 hcstat_table_t *root_table_buf = NULL;
16438 hcstat_table_t *markov_table_buf = NULL;
16439
16440 uint initial_restore_done = 0;
16441
16442 data.maskcnt = maskcnt;
16443
16444 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16445 {
16446 if (data.devices_status == STATUS_CRACKED) break;
16447
16448 data.devices_status = STATUS_INIT;
16449
16450 if (maskpos > rd->maskpos)
16451 {
16452 rd->dictpos = 0;
16453 }
16454
16455 rd->maskpos = maskpos;
16456 data.maskpos = maskpos;
16457
16458 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16459 {
16460 char *mask = masks[maskpos];
16461
16462 if (mask_from_file == 1)
16463 {
16464 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16465
16466 char *str_ptr;
16467 uint str_pos;
16468
16469 uint mask_offset = 0;
16470
16471 uint separator_cnt;
16472
16473 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16474 {
16475 str_ptr = strstr (mask + mask_offset, ",");
16476
16477 if (str_ptr == NULL) break;
16478
16479 str_pos = str_ptr - mask;
16480
16481 // escaped separator, i.e. "\,"
16482
16483 if (str_pos > 0)
16484 {
16485 if (mask[str_pos - 1] == '\\')
16486 {
16487 separator_cnt --;
16488
16489 mask_offset = str_pos + 1;
16490
16491 continue;
16492 }
16493 }
16494
16495 // reset the offset
16496
16497 mask_offset = 0;
16498
16499 mask[str_pos] = '\0';
16500
16501 switch (separator_cnt)
16502 {
16503 case 0:
16504 mp_reset_usr (mp_usr, 0);
16505
16506 custom_charset_1 = mask;
16507 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16508 break;
16509
16510 case 1:
16511 mp_reset_usr (mp_usr, 1);
16512
16513 custom_charset_2 = mask;
16514 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16515 break;
16516
16517 case 2:
16518 mp_reset_usr (mp_usr, 2);
16519
16520 custom_charset_3 = mask;
16521 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16522 break;
16523
16524 case 3:
16525 mp_reset_usr (mp_usr, 3);
16526
16527 custom_charset_4 = mask;
16528 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16529 break;
16530 }
16531
16532 mask = mask + str_pos + 1;
16533 }
16534 }
16535
16536 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16537 {
16538 if (maskpos > 0)
16539 {
16540 local_free (css_buf);
16541 local_free (data.root_css_buf);
16542 local_free (data.markov_css_buf);
16543
16544 local_free (masks[maskpos - 1]);
16545 }
16546
16547 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16548
16549 data.mask = mask;
16550 data.css_cnt = css_cnt;
16551 data.css_buf = css_buf;
16552
16553 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16554
16555 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16556
16557 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16558 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16559
16560 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16561
16562 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16563
16564 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16565 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16566
16567 data.root_css_buf = root_css_buf;
16568 data.markov_css_buf = markov_css_buf;
16569
16570 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16571
16572 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16573
16574 local_free (root_table_buf);
16575 local_free (markov_table_buf);
16576
16577 // args
16578
16579 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16580 {
16581 hc_device_param_t *device_param = &data.devices_param[device_id];
16582
16583 if (device_param->skipped) continue;
16584
16585 device_param->kernel_params_mp[0] = &device_param->d_combs;
16586 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16587 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16588
16589 device_param->kernel_params_mp_buf64[3] = 0;
16590 device_param->kernel_params_mp_buf32[4] = css_cnt;
16591 device_param->kernel_params_mp_buf32[5] = 0;
16592 device_param->kernel_params_mp_buf32[6] = 0;
16593 device_param->kernel_params_mp_buf32[7] = 0;
16594
16595 if (attack_mode == ATTACK_MODE_HYBRID1)
16596 {
16597 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16598 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16599 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16600 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16601 }
16602 else if (attack_mode == ATTACK_MODE_HYBRID2)
16603 {
16604 device_param->kernel_params_mp_buf32[5] = 0;
16605 device_param->kernel_params_mp_buf32[6] = 0;
16606 device_param->kernel_params_mp_buf32[7] = 0;
16607 }
16608
16609 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]);
16610 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]);
16611 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]);
16612
16613 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);
16614 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);
16615 }
16616 }
16617 else if (attack_mode == ATTACK_MODE_BF)
16618 {
16619 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16620
16621 if (increment)
16622 {
16623 for (uint i = 0; i < dictcnt; i++)
16624 {
16625 local_free (dictfiles[i]);
16626 }
16627
16628 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16629 {
16630 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16631
16632 if (l1_filename == NULL) break;
16633
16634 dictcnt++;
16635
16636 dictfiles[dictcnt - 1] = l1_filename;
16637 }
16638 }
16639 else
16640 {
16641 dictcnt++;
16642
16643 dictfiles[dictcnt - 1] = mask;
16644 }
16645
16646 if (dictcnt == 0)
16647 {
16648 log_error ("ERROR: Mask is too small");
16649
16650 return (-1);
16651 }
16652 }
16653 }
16654
16655 free (induction_dictionaries);
16656
16657 // induction_dictionaries_cnt = 0; // implied
16658
16659 if (attack_mode != ATTACK_MODE_BF)
16660 {
16661 if (keyspace == 0)
16662 {
16663 induction_dictionaries = scan_directory (induction_directory);
16664
16665 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16666 }
16667 }
16668
16669 if (induction_dictionaries_cnt)
16670 {
16671 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16672 }
16673
16674 /**
16675 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16676 */
16677 if (keyspace == 1)
16678 {
16679 if ((maskcnt > 1) || (dictcnt > 1))
16680 {
16681 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16682
16683 return (-1);
16684 }
16685 }
16686
16687 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16688 {
16689 char *subid = logfile_generate_subid ();
16690
16691 data.subid = subid;
16692
16693 logfile_sub_msg ("START");
16694
16695 data.devices_status = STATUS_INIT;
16696
16697 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16698 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16699 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16700
16701 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16702
16703 data.cpt_pos = 0;
16704
16705 data.cpt_start = time (NULL);
16706
16707 data.cpt_total = 0;
16708
16709 if (data.restore == 0)
16710 {
16711 rd->words_cur = skip;
16712
16713 skip = 0;
16714
16715 data.skip = 0;
16716 }
16717
16718 data.ms_paused = 0;
16719
16720 data.words_cur = rd->words_cur;
16721
16722 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16723 {
16724 hc_device_param_t *device_param = &data.devices_param[device_id];
16725
16726 if (device_param->skipped) continue;
16727
16728 device_param->speed_pos = 0;
16729
16730 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16731 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16732
16733 device_param->exec_pos = 0;
16734
16735 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16736
16737 device_param->kernel_power = device_param->kernel_power_user;
16738
16739 device_param->outerloop_pos = 0;
16740 device_param->outerloop_left = 0;
16741 device_param->innerloop_pos = 0;
16742 device_param->innerloop_left = 0;
16743
16744 // some more resets:
16745
16746 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16747
16748 device_param->pws_cnt = 0;
16749
16750 device_param->words_off = 0;
16751 device_param->words_done = 0;
16752 }
16753
16754 data.kernel_power_div = 0;
16755
16756 // figure out some workload
16757
16758 if (attack_mode == ATTACK_MODE_STRAIGHT)
16759 {
16760 if (data.wordlist_mode == WL_MODE_FILE)
16761 {
16762 char *dictfile = NULL;
16763
16764 if (induction_dictionaries_cnt)
16765 {
16766 dictfile = induction_dictionaries[0];
16767 }
16768 else
16769 {
16770 dictfile = dictfiles[dictpos];
16771 }
16772
16773 data.dictfile = dictfile;
16774
16775 logfile_sub_string (dictfile);
16776
16777 for (uint i = 0; i < rp_files_cnt; i++)
16778 {
16779 logfile_sub_var_string ("rulefile", rp_files[i]);
16780 }
16781
16782 FILE *fd2 = fopen (dictfile, "rb");
16783
16784 if (fd2 == NULL)
16785 {
16786 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16787
16788 return (-1);
16789 }
16790
16791 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16792
16793 fclose (fd2);
16794
16795 if (data.words_cnt == 0)
16796 {
16797 if (data.devices_status == STATUS_CRACKED) break;
16798 if (data.devices_status == STATUS_ABORTED) break;
16799
16800 dictpos++;
16801
16802 continue;
16803 }
16804 }
16805 }
16806 else if (attack_mode == ATTACK_MODE_COMBI)
16807 {
16808 char *dictfile = data.dictfile;
16809 char *dictfile2 = data.dictfile2;
16810
16811 logfile_sub_string (dictfile);
16812 logfile_sub_string (dictfile2);
16813
16814 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16815 {
16816 FILE *fd2 = fopen (dictfile, "rb");
16817
16818 if (fd2 == NULL)
16819 {
16820 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16821
16822 return (-1);
16823 }
16824
16825 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16826
16827 fclose (fd2);
16828 }
16829 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16830 {
16831 FILE *fd2 = fopen (dictfile2, "rb");
16832
16833 if (fd2 == NULL)
16834 {
16835 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16836
16837 return (-1);
16838 }
16839
16840 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16841
16842 fclose (fd2);
16843 }
16844
16845 if (data.words_cnt == 0)
16846 {
16847 if (data.devices_status == STATUS_CRACKED) break;
16848 if (data.devices_status == STATUS_ABORTED) break;
16849
16850 dictpos++;
16851
16852 continue;
16853 }
16854 }
16855 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16856 {
16857 char *dictfile = NULL;
16858
16859 if (induction_dictionaries_cnt)
16860 {
16861 dictfile = induction_dictionaries[0];
16862 }
16863 else
16864 {
16865 dictfile = dictfiles[dictpos];
16866 }
16867
16868 data.dictfile = dictfile;
16869
16870 char *mask = data.mask;
16871
16872 logfile_sub_string (dictfile);
16873 logfile_sub_string (mask);
16874
16875 FILE *fd2 = fopen (dictfile, "rb");
16876
16877 if (fd2 == NULL)
16878 {
16879 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16880
16881 return (-1);
16882 }
16883
16884 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16885
16886 fclose (fd2);
16887
16888 if (data.words_cnt == 0)
16889 {
16890 if (data.devices_status == STATUS_CRACKED) break;
16891 if (data.devices_status == STATUS_ABORTED) break;
16892
16893 dictpos++;
16894
16895 continue;
16896 }
16897 }
16898 else if (attack_mode == ATTACK_MODE_BF)
16899 {
16900 local_free (css_buf);
16901 local_free (data.root_css_buf);
16902 local_free (data.markov_css_buf);
16903
16904 char *mask = dictfiles[dictpos];
16905
16906 logfile_sub_string (mask);
16907
16908 // base
16909
16910 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16911
16912 if (opts_type & OPTS_TYPE_PT_UNICODE)
16913 {
16914 uint css_cnt_unicode = css_cnt * 2;
16915
16916 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16917
16918 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16919 {
16920 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16921
16922 css_buf_unicode[j + 1].cs_buf[0] = 0;
16923 css_buf_unicode[j + 1].cs_len = 1;
16924 }
16925
16926 free (css_buf);
16927
16928 css_buf = css_buf_unicode;
16929 css_cnt = css_cnt_unicode;
16930 }
16931
16932 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16933
16934 uint mask_min = pw_min;
16935 uint mask_max = pw_max;
16936
16937 if (opts_type & OPTS_TYPE_PT_UNICODE)
16938 {
16939 mask_min *= 2;
16940 mask_max *= 2;
16941 }
16942
16943 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16944 {
16945 if (css_cnt < mask_min)
16946 {
16947 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16948 }
16949
16950 if (css_cnt > mask_max)
16951 {
16952 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16953 }
16954
16955 // skip to next mask
16956
16957 dictpos++;
16958
16959 rd->dictpos = dictpos;
16960
16961 logfile_sub_msg ("STOP");
16962
16963 continue;
16964 }
16965
16966 uint save_css_cnt = css_cnt;
16967
16968 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16969 {
16970 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16971 {
16972 uint salt_len = (uint) data.salts_buf[0].salt_len;
16973 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16974
16975 uint css_cnt_salt = css_cnt + salt_len;
16976
16977 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16978
16979 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16980
16981 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16982 {
16983 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16984 css_buf_salt[j].cs_len = 1;
16985 }
16986
16987 free (css_buf);
16988
16989 css_buf = css_buf_salt;
16990 css_cnt = css_cnt_salt;
16991 }
16992 }
16993
16994 data.mask = mask;
16995 data.css_cnt = css_cnt;
16996 data.css_buf = css_buf;
16997
16998 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16999
17000 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17001
17002 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17003
17004 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17005 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17006
17007 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17008
17009 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17010
17011 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17012 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17013
17014 data.root_css_buf = root_css_buf;
17015 data.markov_css_buf = markov_css_buf;
17016
17017 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17018
17019 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17020
17021 local_free (root_table_buf);
17022 local_free (markov_table_buf);
17023
17024 // copy + args
17025
17026 uint css_cnt_l = css_cnt;
17027 uint css_cnt_r;
17028
17029 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17030 {
17031 if (save_css_cnt < 6)
17032 {
17033 css_cnt_r = 1;
17034 }
17035 else if (save_css_cnt == 6)
17036 {
17037 css_cnt_r = 2;
17038 }
17039 else
17040 {
17041 if (opts_type & OPTS_TYPE_PT_UNICODE)
17042 {
17043 if (save_css_cnt == 8 || save_css_cnt == 10)
17044 {
17045 css_cnt_r = 2;
17046 }
17047 else
17048 {
17049 css_cnt_r = 4;
17050 }
17051 }
17052 else
17053 {
17054 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17055 {
17056 css_cnt_r = 3;
17057 }
17058 else
17059 {
17060 css_cnt_r = 4;
17061 }
17062 }
17063 }
17064 }
17065 else
17066 {
17067 css_cnt_r = 1;
17068
17069 /* unfinished code?
17070 int sum = css_buf[css_cnt_r - 1].cs_len;
17071
17072 for (uint i = 1; i < 4 && i < css_cnt; i++)
17073 {
17074 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17075
17076 css_cnt_r++;
17077
17078 sum *= css_buf[css_cnt_r - 1].cs_len;
17079 }
17080 */
17081 }
17082
17083 css_cnt_l -= css_cnt_r;
17084
17085 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17086
17087 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17088 {
17089 hc_device_param_t *device_param = &data.devices_param[device_id];
17090
17091 if (device_param->skipped) continue;
17092
17093 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17094 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17095 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17096
17097 device_param->kernel_params_mp_l_buf64[3] = 0;
17098 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17099 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17100 device_param->kernel_params_mp_l_buf32[6] = 0;
17101 device_param->kernel_params_mp_l_buf32[7] = 0;
17102 device_param->kernel_params_mp_l_buf32[8] = 0;
17103
17104 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17105 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17106 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17107 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17108
17109 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17110 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17111 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17112
17113 device_param->kernel_params_mp_r_buf64[3] = 0;
17114 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17115 device_param->kernel_params_mp_r_buf32[5] = 0;
17116 device_param->kernel_params_mp_r_buf32[6] = 0;
17117 device_param->kernel_params_mp_r_buf32[7] = 0;
17118
17119 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]);
17120 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]);
17121 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]);
17122
17123 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]);
17124 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]);
17125 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]);
17126
17127 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);
17128 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);
17129 }
17130 }
17131
17132 u64 words_base = data.words_cnt;
17133
17134 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17135 {
17136 if (data.kernel_rules_cnt)
17137 {
17138 words_base /= data.kernel_rules_cnt;
17139 }
17140 }
17141 else if (data.attack_kern == ATTACK_KERN_COMBI)
17142 {
17143 if (data.combs_cnt)
17144 {
17145 words_base /= data.combs_cnt;
17146 }
17147 }
17148 else if (data.attack_kern == ATTACK_KERN_BF)
17149 {
17150 if (data.bfs_cnt)
17151 {
17152 words_base /= data.bfs_cnt;
17153 }
17154 }
17155
17156 data.words_base = words_base;
17157
17158 if (keyspace == 1)
17159 {
17160 log_info ("%llu", (unsigned long long int) words_base);
17161
17162 return (0);
17163 }
17164
17165 if (data.words_cur > data.words_base)
17166 {
17167 log_error ("ERROR: restore value greater keyspace");
17168
17169 return (-1);
17170 }
17171
17172 if (data.words_cur)
17173 {
17174 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17175 {
17176 for (uint i = 0; i < data.salts_cnt; i++)
17177 {
17178 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17179 }
17180 }
17181 else if (data.attack_kern == ATTACK_KERN_COMBI)
17182 {
17183 for (uint i = 0; i < data.salts_cnt; i++)
17184 {
17185 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17186 }
17187 }
17188 else if (data.attack_kern == ATTACK_KERN_BF)
17189 {
17190 for (uint i = 0; i < data.salts_cnt; i++)
17191 {
17192 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17193 }
17194 }
17195 }
17196
17197 /*
17198 * Inform user about possible slow speeds
17199 */
17200
17201 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17202 {
17203 if (data.words_base < kernel_power_all)
17204 {
17205 if (quiet == 0)
17206 {
17207 log_info ("ATTENTION!");
17208 log_info (" The wordlist or mask you are using is too small.");
17209 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17210 log_info (" The cracking speed will drop.");
17211 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17212 log_info ("");
17213 }
17214 }
17215 }
17216
17217 /*
17218 * Update loopback file
17219 */
17220
17221 if (loopback == 1)
17222 {
17223 time_t now;
17224
17225 time (&now);
17226
17227 uint random_num = get_random_num (0, 9999);
17228
17229 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17230
17231 data.loopback_file = loopback_file;
17232 }
17233
17234 /*
17235 * Update dictionary statistic
17236 */
17237
17238 if (keyspace == 0)
17239 {
17240 dictstat_fp = fopen (dictstat, "wb");
17241
17242 if (dictstat_fp)
17243 {
17244 lock_file (dictstat_fp);
17245
17246 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17247
17248 fclose (dictstat_fp);
17249 }
17250 }
17251
17252 data.devices_status = STATUS_RUNNING;
17253
17254 if (initial_restore_done == 0)
17255 {
17256 if (data.restore_disable == 0) cycle_restore ();
17257
17258 initial_restore_done = 1;
17259 }
17260
17261 hc_timer_set (&data.timer_running);
17262
17263 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17264 {
17265 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17266 {
17267 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17268 if (quiet == 0) fflush (stdout);
17269 }
17270 }
17271 else if (wordlist_mode == WL_MODE_STDIN)
17272 {
17273 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17274 if (data.quiet == 0) log_info ("");
17275 }
17276
17277 time_t runtime_start;
17278
17279 time (&runtime_start);
17280
17281 data.runtime_start = runtime_start;
17282
17283 /**
17284 * create cracker threads
17285 */
17286
17287 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17288
17289 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17290 {
17291 hc_device_param_t *device_param = &devices_param[device_id];
17292
17293 if (wordlist_mode == WL_MODE_STDIN)
17294 {
17295 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17296 }
17297 else
17298 {
17299 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17300 }
17301 }
17302
17303 // wait for crack threads to exit
17304
17305 hc_thread_wait (data.devices_cnt, c_threads);
17306
17307 local_free (c_threads);
17308
17309 data.restore = 0;
17310
17311 // finalize task
17312
17313 logfile_sub_var_uint ("status-after-work", data.devices_status);
17314
17315 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17316
17317 if (data.devices_status == STATUS_CRACKED) break;
17318 if (data.devices_status == STATUS_ABORTED) break;
17319
17320 if (data.devices_status == STATUS_BYPASS)
17321 {
17322 data.devices_status = STATUS_RUNNING;
17323 }
17324
17325 if (induction_dictionaries_cnt)
17326 {
17327 unlink (induction_dictionaries[0]);
17328 }
17329
17330 free (induction_dictionaries);
17331
17332 if (attack_mode != ATTACK_MODE_BF)
17333 {
17334 induction_dictionaries = scan_directory (induction_directory);
17335
17336 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17337 }
17338
17339 if (benchmark == 0)
17340 {
17341 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17342 {
17343 if (quiet == 0) clear_prompt ();
17344
17345 if (quiet == 0) log_info ("");
17346
17347 if (status == 1)
17348 {
17349 status_display ();
17350 }
17351 else
17352 {
17353 if (quiet == 0) status_display ();
17354 }
17355
17356 if (quiet == 0) log_info ("");
17357 }
17358 }
17359
17360 if (attack_mode == ATTACK_MODE_BF)
17361 {
17362 dictpos++;
17363
17364 rd->dictpos = dictpos;
17365 }
17366 else
17367 {
17368 if (induction_dictionaries_cnt)
17369 {
17370 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17371 }
17372 else
17373 {
17374 dictpos++;
17375
17376 rd->dictpos = dictpos;
17377 }
17378 }
17379
17380 time_t runtime_stop;
17381
17382 time (&runtime_stop);
17383
17384 data.runtime_stop = runtime_stop;
17385
17386 logfile_sub_uint (runtime_start);
17387 logfile_sub_uint (runtime_stop);
17388
17389 logfile_sub_msg ("STOP");
17390
17391 global_free (subid);
17392 }
17393
17394 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17395
17396 if (data.devices_status == STATUS_CRACKED) break;
17397 if (data.devices_status == STATUS_ABORTED) break;
17398 if (data.devices_status == STATUS_QUIT) break;
17399
17400 if (data.devices_status == STATUS_BYPASS)
17401 {
17402 data.devices_status = STATUS_RUNNING;
17403 }
17404 }
17405
17406 // 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
17407
17408 if (attack_mode == ATTACK_MODE_STRAIGHT)
17409 {
17410 if (data.wordlist_mode == WL_MODE_FILE)
17411 {
17412 if (data.dictfile == NULL)
17413 {
17414 if (dictfiles != NULL)
17415 {
17416 data.dictfile = dictfiles[0];
17417
17418 hc_timer_set (&data.timer_running);
17419 }
17420 }
17421 }
17422 }
17423 // NOTE: combi is okay because it is already set beforehand
17424 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17425 {
17426 if (data.dictfile == NULL)
17427 {
17428 if (dictfiles != NULL)
17429 {
17430 hc_timer_set (&data.timer_running);
17431
17432 data.dictfile = dictfiles[0];
17433 }
17434 }
17435 }
17436 else if (attack_mode == ATTACK_MODE_BF)
17437 {
17438 if (data.mask == NULL)
17439 {
17440 hc_timer_set (&data.timer_running);
17441
17442 data.mask = masks[0];
17443 }
17444 }
17445
17446 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17447 {
17448 data.devices_status = STATUS_EXHAUSTED;
17449 }
17450
17451 // if cracked / aborted remove last induction dictionary
17452
17453 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17454 {
17455 struct stat induct_stat;
17456
17457 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17458 {
17459 unlink (induction_dictionaries[file_pos]);
17460 }
17461 }
17462
17463 // wait for non-interactive threads
17464
17465 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17466 {
17467 hc_thread_wait (1, &ni_threads[thread_idx]);
17468 }
17469
17470 local_free (ni_threads);
17471
17472 // wait for interactive threads
17473
17474 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17475 {
17476 hc_thread_wait (1, &i_thread);
17477 }
17478
17479 // we dont need restore file anymore
17480 if (data.restore_disable == 0)
17481 {
17482 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17483 {
17484 unlink (eff_restore_file);
17485 unlink (new_restore_file);
17486 }
17487 else
17488 {
17489 cycle_restore ();
17490 }
17491 }
17492
17493 // finally save left hashes
17494
17495 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17496 {
17497 save_hash ();
17498 }
17499
17500 /**
17501 * Clean up
17502 */
17503
17504 if (benchmark == 1)
17505 {
17506 status_benchmark ();
17507
17508 if (status_automat == 0)
17509 {
17510 log_info ("");
17511 }
17512 }
17513 else
17514 {
17515 if (quiet == 0) clear_prompt ();
17516
17517 if (quiet == 0) log_info ("");
17518
17519 if (status == 1)
17520 {
17521 status_display ();
17522 }
17523 else
17524 {
17525 if (quiet == 0) status_display ();
17526 }
17527
17528 if (quiet == 0) log_info ("");
17529 }
17530
17531 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17532 {
17533 hc_device_param_t *device_param = &data.devices_param[device_id];
17534
17535 if (device_param->skipped) continue;
17536
17537 local_free (device_param->combs_buf);
17538
17539 local_free (device_param->hooks_buf);
17540
17541 local_free (device_param->device_name);
17542
17543 local_free (device_param->device_name_chksum);
17544
17545 local_free (device_param->device_version);
17546
17547 local_free (device_param->driver_version);
17548
17549 if (device_param->pws_buf) myfree (device_param->pws_buf);
17550 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17551 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17552 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17553 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17554 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17555 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17556 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17557 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17558 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17559 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17560 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17561 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17562 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17563 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17564 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17565 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17566 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17567 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17568 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17569 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17570 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17571 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17572 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17573 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17574 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17575 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17576 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17577 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17578
17579 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17580 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17581 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17582 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17583 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17584 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17585 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17586 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17587 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17588 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17589
17590 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17591 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17592 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17593
17594 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17595 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17596 }
17597
17598 // reset default fan speed
17599
17600 #ifdef HAVE_HWMON
17601 if (gpu_temp_disable == 0)
17602 {
17603 #ifdef HAVE_ADL
17604 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17605 {
17606 hc_thread_mutex_lock (mux_adl);
17607
17608 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17609 {
17610 hc_device_param_t *device_param = &data.devices_param[device_id];
17611
17612 if (device_param->skipped) continue;
17613
17614 if (data.hm_device[device_id].fan_supported == 1)
17615 {
17616 int fanspeed = temp_retain_fanspeed_value[device_id];
17617
17618 if (fanspeed == -1) continue;
17619
17620 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
17621
17622 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
17623 }
17624 }
17625
17626 hc_thread_mutex_unlock (mux_adl);
17627 }
17628 #endif // HAVE_ADL
17629 }
17630
17631 #ifdef HAVE_ADL
17632 // reset power tuning
17633
17634 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17635 {
17636 hc_thread_mutex_lock (mux_adl);
17637
17638 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17639 {
17640 hc_device_param_t *device_param = &data.devices_param[device_id];
17641
17642 if (device_param->skipped) continue;
17643
17644 if (data.hm_device[device_id].od_version == 6)
17645 {
17646 // check powertune capabilities first, if not available then skip device
17647
17648 int powertune_supported = 0;
17649
17650 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17651 {
17652 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17653
17654 return (-1);
17655 }
17656
17657 if (powertune_supported != 0)
17658 {
17659 // powercontrol settings
17660
17661 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)
17662 {
17663 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17664
17665 return (-1);
17666 }
17667
17668 // clocks
17669
17670 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17671
17672 performance_state->iNumberOfPerformanceLevels = 2;
17673
17674 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17675 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17676 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17677 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17678
17679 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)
17680 {
17681 log_info ("ERROR: Failed to restore ADL performance state");
17682
17683 return (-1);
17684 }
17685
17686 local_free (performance_state);
17687 }
17688 }
17689 }
17690
17691 hc_thread_mutex_unlock (mux_adl);
17692 }
17693 #endif // HAVE_ADL
17694
17695 if (gpu_temp_disable == 0)
17696 {
17697 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17698 if (data.hm_nv)
17699 {
17700 #if defined(LINUX) && defined(HAVE_NVML)
17701
17702 hm_NVML_nvmlShutdown (data.hm_nv);
17703
17704 nvml_close (data.hm_nv);
17705
17706 #elif defined(WIN) && (HAVE_NVAPI)
17707
17708 hm_NvAPI_Unload (data.hm_nv);
17709
17710 nvapi_close (data.hm_nv);
17711
17712 #endif
17713
17714 data.hm_nv = NULL;
17715 }
17716 #endif
17717
17718 #ifdef HAVE_ADL
17719 if (data.hm_amd)
17720 {
17721 hm_ADL_Main_Control_Destroy (data.hm_amd);
17722
17723 adl_close (data.hm_amd);
17724 data.hm_amd = NULL;
17725 }
17726 #endif
17727 }
17728 #endif // HAVE_HWMON
17729
17730 // free memory
17731
17732 local_free (masks);
17733
17734 local_free (dictstat_base);
17735
17736 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17737 {
17738 pot_t *pot_ptr = &pot[pot_pos];
17739
17740 hash_t *hash = &pot_ptr->hash;
17741
17742 local_free (hash->digest);
17743
17744 if (isSalted)
17745 {
17746 local_free (hash->salt);
17747 }
17748 }
17749
17750 local_free (pot);
17751
17752 local_free (all_kernel_rules_cnt);
17753 local_free (all_kernel_rules_buf);
17754
17755 local_free (wl_data->buf);
17756 local_free (wl_data);
17757
17758 local_free (bitmap_s1_a);
17759 local_free (bitmap_s1_b);
17760 local_free (bitmap_s1_c);
17761 local_free (bitmap_s1_d);
17762 local_free (bitmap_s2_a);
17763 local_free (bitmap_s2_b);
17764 local_free (bitmap_s2_c);
17765 local_free (bitmap_s2_d);
17766
17767 #ifdef HAVE_HWMON
17768 local_free (temp_retain_fanspeed_value);
17769 #ifdef HAVE_ADL
17770 local_free (od_clock_mem_status);
17771 local_free (od_power_control_status);
17772 #endif // ADL
17773 #endif
17774
17775 global_free (devices_param);
17776
17777 global_free (kernel_rules_buf);
17778
17779 global_free (root_css_buf);
17780 global_free (markov_css_buf);
17781
17782 global_free (digests_buf);
17783 global_free (digests_shown);
17784 global_free (digests_shown_tmp);
17785
17786 global_free (salts_buf);
17787 global_free (salts_shown);
17788
17789 global_free (esalts_buf);
17790
17791 global_free (words_progress_done);
17792 global_free (words_progress_rejected);
17793 global_free (words_progress_restored);
17794
17795 if (pot_fp) fclose (pot_fp);
17796
17797 if (data.devices_status == STATUS_QUIT) break;
17798 }
17799
17800 // destroy others mutex
17801
17802 hc_thread_mutex_delete (mux_dispatcher);
17803 hc_thread_mutex_delete (mux_counter);
17804 hc_thread_mutex_delete (mux_display);
17805 hc_thread_mutex_delete (mux_adl);
17806
17807 // free memory
17808
17809 local_free (eff_restore_file);
17810 local_free (new_restore_file);
17811
17812 local_free (rd);
17813
17814 // tuning db
17815
17816 tuning_db_destroy (tuning_db);
17817
17818 // loopback
17819
17820 local_free (loopback_file);
17821
17822 if (loopback == 1) unlink (loopback_file);
17823
17824 // induction directory
17825
17826 if (induction_dir == NULL)
17827 {
17828 if (attack_mode != ATTACK_MODE_BF)
17829 {
17830 if (rmdir (induction_directory) == -1)
17831 {
17832 if (errno == ENOENT)
17833 {
17834 // good, we can ignore
17835 }
17836 else if (errno == ENOTEMPTY)
17837 {
17838 // good, we can ignore
17839 }
17840 else
17841 {
17842 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17843
17844 return (-1);
17845 }
17846 }
17847
17848 local_free (induction_directory);
17849 }
17850 }
17851
17852 // outfile-check directory
17853
17854 if (outfile_check_dir == NULL)
17855 {
17856 if (rmdir (outfile_check_directory) == -1)
17857 {
17858 if (errno == ENOENT)
17859 {
17860 // good, we can ignore
17861 }
17862 else if (errno == ENOTEMPTY)
17863 {
17864 // good, we can ignore
17865 }
17866 else
17867 {
17868 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17869
17870 return (-1);
17871 }
17872 }
17873
17874 local_free (outfile_check_directory);
17875 }
17876
17877 time_t proc_stop;
17878
17879 time (&proc_stop);
17880
17881 logfile_top_uint (proc_start);
17882 logfile_top_uint (proc_stop);
17883
17884 logfile_top_msg ("STOP");
17885
17886 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17887 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17888
17889 if (data.ocl) ocl_close (data.ocl);
17890
17891 if (data.devices_status == STATUS_ABORTED) return 2;
17892 if (data.devices_status == STATUS_QUIT) return 2;
17893 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17894 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17895 if (data.devices_status == STATUS_CRACKED) return 0;
17896
17897 return -1;
17898 }
Hashcat additions to support pwdhash