projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Enabled support of --status-automat in combination with --benchmark for automated...
[hashcat.git] / src / hashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "hashcat";
19 const uint VERSION_BIN = 300;
20 const uint RESTORE_MIN = 300;
21
22 double TARGET_MS_PROFILE[3] = { 8, 16, 96 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define RESTORE 0
37 #define RESTORE_TIMER 60
38 #define RESTORE_DISABLE 0
39 #define STATUS 0
40 #define STATUS_TIMER 10
41 #define STATUS_AUTOMAT 0
42 #define LOOPBACK 0
43 #define WEAK_HASH_THRESHOLD 100
44 #define SHOW 0
45 #define LEFT 0
46 #define USERNAME 0
47 #define REMOVE 0
48 #define REMOVE_TIMER 60
49 #define SKIP 0
50 #define LIMIT 0
51 #define KEYSPACE 0
52 #define POTFILE_DISABLE 0
53 #define DEBUG_MODE 0
54 #define RP_GEN 0
55 #define RP_GEN_FUNC_MIN 1
56 #define RP_GEN_FUNC_MAX 4
57 #define RP_GEN_SEED 0
58 #define RULE_BUF_L ":"
59 #define RULE_BUF_R ":"
60 #define FORCE 0
61 #define RUNTIME 0
62 #define HEX_CHARSET 0
63 #define HEX_SALT 0
64 #define HEX_WORDLIST 0
65 #define OUTFILE_FORMAT 3
66 #define OUTFILE_AUTOHEX 1
67 #define OUTFILE_CHECK_TIMER 5
68 #define ATTACK_MODE 0
69 #define HASH_MODE 0
70 #define SEGMENT_SIZE 32
71 #define INCREMENT 0
72 #define INCREMENT_MIN 1
73 #define INCREMENT_MAX PW_MAX
74 #define SEPARATOR ':'
75 #define BITMAP_MIN 16
76 #define BITMAP_MAX 24
77 #define GPU_TEMP_DISABLE 0
78 #define GPU_TEMP_ABORT 90
79 #define GPU_TEMP_RETAIN 80
80 #define WORKLOAD_PROFILE 2
81 #define KERNEL_ACCEL 0
82 #define KERNEL_LOOPS 0
83 #define KERNEL_RULES 1024
84 #define KERNEL_COMBS 1024
85 #define KERNEL_BFS 1024
86 #define KERNEL_THREADS_MAX 256
87 #define KERNEL_THREADS_MAX_CPU 16
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 137
152
153 #define global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
168 {
169 900,
170 0,
171 5100,
172 100,
173 1400,
174 10800,
175 1700,
176 5000,
177 10100,
178 6000,
179 6100,
180 6900,
181 11700,
182 11800,
183 400,
184 8900,
185 11900,
186 12000,
187 10900,
188 12100,
189 23,
190 2500,
191 5300,
192 5400,
193 5500,
194 5600,
195 7300,
196 7500,
197 13100,
198 8300,
199 11100,
200 11200,
201 11400,
202 121,
203 2611,
204 2711,
205 2811,
206 8400,
207 11,
208 2612,
209 7900,
210 21,
211 11000,
212 124,
213 10000,
214 3711,
215 7600,
216 12,
217 131,
218 132,
219 1731,
220 200,
221 300,
222 3100,
223 112,
224 12300,
225 8000,
226 141,
227 1441,
228 1600,
229 12600,
230 1421,
231 101,
232 111,
233 1711,
234 3000,
235 1000,
236 1100,
237 2100,
238 12800,
239 1500,
240 12400,
241 500,
242 3200,
243 7400,
244 1800,
245 122,
246 1722,
247 7100,
248 6300,
249 6700,
250 6400,
251 6500,
252 2400,
253 2410,
254 5700,
255 9200,
256 9300,
257 22,
258 501,
259 5800,
260 8100,
261 8500,
262 7200,
263 9900,
264 7700,
265 7800,
266 10300,
267 8600,
268 8700,
269 9100,
270 133,
271 13500,
272 11600,
273 13600,
274 12500,
275 13000,
276 13200,
277 13300,
278 6211,
279 6221,
280 6231,
281 6241,
282 8800,
283 12900,
284 12200,
285 9700,
286 9710,
287 9800,
288 9810,
289 9400,
290 9500,
291 9600,
292 10400,
293 10410,
294 10500,
295 10600,
296 10700,
297 9000,
298 5200,
299 6800,
300 6600,
301 8200,
302 11300,
303 12700,
304 13400,
305 125
306 };
307
308 /**
309 * types
310 */
311
312 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
313
314 /**
315 * globals
316 */
317
318 static unsigned int full01 = 0x01010101;
319 static unsigned int full80 = 0x80808080;
320
321 int SUPPRESS_OUTPUT = 0;
322
323 hc_thread_mutex_t mux_adl;
324 hc_thread_mutex_t mux_counter;
325 hc_thread_mutex_t mux_dispatcher;
326 hc_thread_mutex_t mux_display;
327
328 hc_global_data_t data;
329
330 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
331
332 const char *USAGE_MINI[] =
333 {
334 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
335 "",
336 "Try --help for more help.",
337 NULL
338 };
339
340 const char *USAGE_BIG[] =
341 {
342 "%s, advanced password recovery",
343 "",
344 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
345 "",
346 "=======",
347 "Options",
348 "=======",
349 "",
350 "* General:",
351 "",
352 " -m, --hash-type=NUM Hash-type, see references below",
353 " -a, --attack-mode=NUM Attack-mode, see references below",
354 " -V, --version Print version",
355 " -h, --help Print help",
356 " --quiet Suppress output",
357 "",
358 "* Misc:",
359 "",
360 " --hex-charset Assume charset is given in hex",
361 " --hex-salt Assume salt is given in hex",
362 " --hex-wordlist Assume words in wordlist is given in hex",
363 " --force Ignore warnings",
364 " --status Enable automatic update of the status-screen",
365 " --status-timer=NUM Seconds between status-screen update",
366 " --status-automat Display the status view in a machine readable format",
367 " --loopback Add new plains to induct directory",
368 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
369 "",
370 "* Markov:",
371 "",
372 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
373 " --markov-disable Disables markov-chains, emulates classic brute-force",
374 " --markov-classic Enables classic markov-chains, no per-position enhancement",
375 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
376 "",
377 "* Session:",
378 "",
379 " --runtime=NUM Abort session after NUM seconds of runtime",
380 " --session=STR Define specific session name",
381 " --restore Restore session from --session",
382 " --restore-disable Do not write restore file",
383 "",
384 "* Files:",
385 "",
386 " -o, --outfile=FILE Define outfile for recovered hash",
387 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
388 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
389 " --outfile-check-timer=NUM Seconds between outfile checks",
390 " -p, --separator=CHAR Separator char for hashlists and outfile",
391 " --show Show cracked passwords only",
392 " --left Show un-cracked passwords only",
393 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
394 " --remove Enable remove of hash once it is cracked",
395 " --remove-timer=NUM Update input hash file each NUM seconds",
396 " --potfile-disable Do not write potfile",
397 " --potfile-path Specific path to potfile",
398 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
399 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
400 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
401 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
402 " --logfile-disable Disable the logfile",
403 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
404 "",
405 "* Resources:",
406 "",
407 " -b, --benchmark Run benchmark",
408 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
409 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
410 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
411 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
412 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
413 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
414 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
415 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
416 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
417 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
418 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
419 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
420 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
421 #ifdef HAVE_HWMON
422 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
423 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
424 #ifdef HAVE_ADL
425 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
426 #endif
427 #endif
428 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
429 "",
430 "* Distributed:",
431 "",
432 " -s, --skip=NUM Skip number of words",
433 " -l, --limit=NUM Limit number of words",
434 " --keyspace Show keyspace base:mod values and quit",
435 "",
436 "* Rules:",
437 "",
438 " -j, --rule-left=RULE Single rule applied to each word from left dict",
439 " -k, --rule-right=RULE Single rule applied to each word from right dict",
440 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
441 " -g, --generate-rules=NUM Generate NUM random rules",
442 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
443 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
444 " --generate-rules-seed=NUM Force RNG seed to NUM",
445 "",
446 "* Custom charsets:",
447 "",
448 " -1, --custom-charset1=CS User-defined charsets",
449 " -2, --custom-charset2=CS Example:",
450 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
451 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
452 "",
453 "* Increment:",
454 "",
455 " -i, --increment Enable increment mode",
456 " --increment-min=NUM Start incrementing at NUM",
457 " --increment-max=NUM Stop incrementing at NUM",
458 "",
459 "==========",
460 "References",
461 "==========",
462 "",
463 "* Workload Profile:",
464 "",
465 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
466 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
467 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
468 "",
469 "* OpenCL device-types:",
470 "",
471 " 1 = CPU devices",
472 " 2 = GPU devices",
473 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
474 "",
475 "* Outfile Formats:",
476 "",
477 " 1 = hash[:salt]",
478 " 2 = plain",
479 " 3 = hash[:salt]:plain",
480 " 4 = hex_plain",
481 " 5 = hash[:salt]:hex_plain",
482 " 6 = plain:hex_plain",
483 " 7 = hash[:salt]:plain:hex_plain",
484 " 8 = crackpos",
485 " 9 = hash[:salt]:crackpos",
486 " 10 = plain:crackpos",
487 " 11 = hash[:salt]:plain:crackpos",
488 " 12 = hex_plain:crackpos",
489 " 13 = hash[:salt]:hex_plain:crackpos",
490 " 14 = plain:hex_plain:crackpos",
491 " 15 = hash[:salt]:plain:hex_plain:crackpos",
492 "",
493 "* Debug mode output formats (for hybrid mode only, by using rules):",
494 "",
495 " 1 = save finding rule",
496 " 2 = save original word",
497 " 3 = save original word and finding rule",
498 " 4 = save original word, finding rule and modified plain",
499 "",
500 "* Built-in charsets:",
501 "",
502 " ?l = abcdefghijklmnopqrstuvwxyz",
503 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
504 " ?d = 0123456789",
505 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
506 " ?a = ?l?u?d?s",
507 " ?b = 0x00 - 0xff",
508 "",
509 "* Attack modes:",
510 "",
511 " 0 = Straight",
512 " 1 = Combination",
513 " 3 = Brute-force",
514 " 6 = Hybrid dict + mask",
515 " 7 = Hybrid mask + dict",
516 "",
517 "* Hash types:",
518 "",
519 "[[ Roll-your-own: Raw Hashes ]]",
520 "",
521 " 900 = MD4",
522 " 0 = MD5",
523 " 5100 = Half MD5",
524 " 100 = SHA1",
525 " 10800 = SHA-384",
526 " 1400 = SHA-256",
527 " 1700 = SHA-512",
528 " 5000 = SHA-3(Keccak)",
529 " 10100 = SipHash",
530 " 6000 = RipeMD160",
531 " 6100 = Whirlpool",
532 " 6900 = GOST R 34.11-94",
533 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
534 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
535 "",
536 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
537 "",
538 " 10 = md5($pass.$salt)",
539 " 20 = md5($salt.$pass)",
540 " 30 = md5(unicode($pass).$salt)",
541 " 40 = md5($salt.unicode($pass))",
542 " 3800 = md5($salt.$pass.$salt)",
543 " 3710 = md5($salt.md5($pass))",
544 " 2600 = md5(md5($pass)",
545 " 4300 = md5(strtoupper(md5($pass)))",
546 " 4400 = md5(sha1($pass))",
547 " 110 = sha1($pass.$salt)",
548 " 120 = sha1($salt.$pass)",
549 " 130 = sha1(unicode($pass).$salt)",
550 " 140 = sha1($salt.unicode($pass))",
551 " 4500 = sha1(sha1($pass)",
552 " 4700 = sha1(md5($pass))",
553 " 4900 = sha1($salt.$pass.$salt)",
554 " 1410 = sha256($pass.$salt)",
555 " 1420 = sha256($salt.$pass)",
556 " 1430 = sha256(unicode($pass).$salt)",
557 " 1440 = sha256($salt.unicode($pass))",
558 " 1710 = sha512($pass.$salt)",
559 " 1720 = sha512($salt.$pass)",
560 " 1730 = sha512(unicode($pass).$salt)",
561 " 1740 = sha512($salt.unicode($pass))",
562 "",
563 "[[ Roll-your-own: Authenticated Hashes ]]",
564 "",
565 " 50 = HMAC-MD5 (key = $pass)",
566 " 60 = HMAC-MD5 (key = $salt)",
567 " 150 = HMAC-SHA1 (key = $pass)",
568 " 160 = HMAC-SHA1 (key = $salt)",
569 " 1450 = HMAC-SHA256 (key = $pass)",
570 " 1460 = HMAC-SHA256 (key = $salt)",
571 " 1750 = HMAC-SHA512 (key = $pass)",
572 " 1760 = HMAC-SHA512 (key = $salt)",
573 "",
574 "[[ Generic KDF ]]",
575 "",
576 " 400 = phpass",
577 " 8900 = scrypt",
578 " 11900 = PBKDF2-HMAC-MD5",
579 " 12000 = PBKDF2-HMAC-SHA1",
580 " 10900 = PBKDF2-HMAC-SHA256",
581 " 12100 = PBKDF2-HMAC-SHA512",
582 "",
583 "[[ Network protocols, Challenge-Response ]]",
584 "",
585 " 23 = Skype",
586 " 2500 = WPA/WPA2",
587 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
588 " 5300 = IKE-PSK MD5",
589 " 5400 = IKE-PSK SHA1",
590 " 5500 = NetNTLMv1",
591 " 5500 = NetNTLMv1 + ESS",
592 " 5600 = NetNTLMv2",
593 " 7300 = IPMI2 RAKP HMAC-SHA1",
594 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
595 " 8300 = DNSSEC (NSEC3)",
596 " 10200 = Cram MD5",
597 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
598 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
599 " 11400 = SIP digest authentication (MD5)",
600 " 13100 = Kerberos 5 TGS-REP etype 23",
601 "",
602 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
603 "",
604 " 121 = SMF (Simple Machines Forum)",
605 " 400 = phpBB3",
606 " 2611 = vBulletin < v3.8.5",
607 " 2711 = vBulletin > v3.8.5",
608 " 2811 = MyBB",
609 " 2811 = IPB (Invison Power Board)",
610 " 8400 = WBB3 (Woltlab Burning Board)",
611 " 11 = Joomla < 2.5.18",
612 " 400 = Joomla > 2.5.18",
613 " 400 = Wordpress",
614 " 2612 = PHPS",
615 " 7900 = Drupal7",
616 " 21 = osCommerce",
617 " 21 = xt:Commerce",
618 " 11000 = PrestaShop",
619 " 124 = Django (SHA-1)",
620 " 10000 = Django (PBKDF2-SHA256)",
621 " 3711 = Mediawiki B type",
622 " 7600 = Redmine",
623 "",
624 "[[ Database Server ]]",
625 "",
626 " 12 = PostgreSQL",
627 " 131 = MSSQL(2000)",
628 " 132 = MSSQL(2005)",
629 " 1731 = MSSQL(2012)",
630 " 1731 = MSSQL(2014)",
631 " 200 = MySQL323",
632 " 300 = MySQL4.1/MySQL5",
633 " 3100 = Oracle H: Type (Oracle 7+)",
634 " 112 = Oracle S: Type (Oracle 11+)",
635 " 12300 = Oracle T: Type (Oracle 12+)",
636 " 8000 = Sybase ASE",
637 "",
638 "[[ HTTP, SMTP, LDAP Server ]]",
639 "",
640 " 141 = EPiServer 6.x < v4",
641 " 1441 = EPiServer 6.x > v4",
642 " 1600 = Apache $apr1$",
643 " 12600 = ColdFusion 10+",
644 " 1421 = hMailServer",
645 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
646 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
647 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
648 "",
649 "[[ Checksums ]]",
650 "",
651 " 11500 = CRC32",
652 "",
653 "[[ Operating-Systems ]]",
654 "",
655 " 3000 = LM",
656 " 1000 = NTLM",
657 " 1100 = Domain Cached Credentials (DCC), MS Cache",
658 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
659 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
660 " 1500 = descrypt, DES(Unix), Traditional DES",
661 " 12400 = BSDiCrypt, Extended DES",
662 " 500 = md5crypt $1$, MD5(Unix)",
663 " 3200 = bcrypt $2*$, Blowfish(Unix)",
664 " 7400 = sha256crypt $5$, SHA256(Unix)",
665 " 1800 = sha512crypt $6$, SHA512(Unix)",
666 " 122 = OSX v10.4",
667 " 122 = OSX v10.5",
668 " 122 = OSX v10.6",
669 " 1722 = OSX v10.7",
670 " 7100 = OSX v10.8",
671 " 7100 = OSX v10.9",
672 " 7100 = OSX v10.10",
673 " 6300 = AIX {smd5}",
674 " 6700 = AIX {ssha1}",
675 " 6400 = AIX {ssha256}",
676 " 6500 = AIX {ssha512}",
677 " 2400 = Cisco-PIX",
678 " 2410 = Cisco-ASA",
679 " 500 = Cisco-IOS $1$",
680 " 5700 = Cisco-IOS $4$",
681 " 9200 = Cisco-IOS $8$",
682 " 9300 = Cisco-IOS $9$",
683 " 22 = Juniper Netscreen/SSG (ScreenOS)",
684 " 501 = Juniper IVE",
685 " 5800 = Android PIN",
686 " 8100 = Citrix Netscaler",
687 " 8500 = RACF",
688 " 7200 = GRUB 2",
689 " 9900 = Radmin2",
690 " 125 = ArubaOS",
691 "",
692 "[[ Enterprise Application Software (EAS) ]]",
693 "",
694 " 7700 = SAP CODVN B (BCODE)",
695 " 7800 = SAP CODVN F/G (PASSCODE)",
696 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
697 " 8600 = Lotus Notes/Domino 5",
698 " 8700 = Lotus Notes/Domino 6",
699 " 9100 = Lotus Notes/Domino 8",
700 " 133 = PeopleSoft",
701 " 13500 = PeopleSoft Token",
702 "",
703 "[[ Archives ]]",
704 "",
705 " 11600 = 7-Zip",
706 " 12500 = RAR3-hp",
707 " 13000 = RAR5",
708 " 13200 = AxCrypt",
709 " 13300 = AxCrypt in memory SHA1",
710 " 13600 = WinZip",
711 "",
712 "[[ Full-Disk encryptions (FDE) ]]",
713 "",
714 " 62XY = TrueCrypt 5.0+",
715 " X = 1 = PBKDF2-HMAC-RipeMD160",
716 " X = 2 = PBKDF2-HMAC-SHA512",
717 " X = 3 = PBKDF2-HMAC-Whirlpool",
718 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
719 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
720 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
721 " Y = 3 = XTS 1536 bit (Ciphers: All)",
722 " 8800 = Android FDE < v4.3",
723 " 12900 = Android FDE (Samsung DEK)",
724 " 12200 = eCryptfs",
725 "",
726 "[[ Documents ]]",
727 "",
728 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
729 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
730 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
731 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
732 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
733 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
734 " 9400 = MS Office 2007",
735 " 9500 = MS Office 2010",
736 " 9600 = MS Office 2013",
737 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
738 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
739 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
740 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
741 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
742 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
743 "",
744 "[[ Password Managers ]]",
745 "",
746 " 9000 = Password Safe v2",
747 " 5200 = Password Safe v3",
748 " 6800 = Lastpass",
749 " 6600 = 1Password, agilekeychain",
750 " 8200 = 1Password, cloudkeychain",
751 " 11300 = Bitcoin/Litecoin wallet.dat",
752 " 12700 = Blockchain, My Wallet",
753 " 13400 = Keepass 1 (AES/Twofish) and Keepass 2 (AES)",
754 "",
755 NULL
756 };
757
758 /**
759 * hashcat specific functions
760 */
761
762 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
763 {
764 int exec_pos = (int) device_param->exec_pos - last_num_entries;
765
766 if (exec_pos < 0) exec_pos += EXEC_CACHE;
767
768 double exec_ms_sum = 0;
769
770 int exec_ms_cnt = 0;
771
772 for (int i = 0; i < last_num_entries; i++)
773 {
774 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
775
776 if (exec_ms)
777 {
778 exec_ms_sum += exec_ms;
779
780 exec_ms_cnt++;
781 }
782 }
783
784 if (exec_ms_cnt == 0) return 0;
785
786 return exec_ms_sum / exec_ms_cnt;
787 }
788
789 void status_display_automat ()
790 {
791 FILE *out = stdout;
792
793 fprintf (out, "STATUS\t%u\t", data.devices_status);
794
795 /**
796 * speed new
797 */
798
799 fprintf (out, "SPEED\t");
800
801 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
802 {
803 hc_device_param_t *device_param = &data.devices_param[device_id];
804
805 if (device_param->skipped) continue;
806
807 u64 speed_cnt = 0;
808 double speed_ms = 0;
809
810 for (int i = 0; i < SPEED_CACHE; i++)
811 {
812 speed_cnt += device_param->speed_cnt[i];
813 speed_ms += device_param->speed_ms[i];
814 }
815
816 speed_cnt /= SPEED_CACHE;
817 speed_ms /= SPEED_CACHE;
818
819 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
820 }
821
822 /**
823 * exec time
824 */
825
826 fprintf (out, "EXEC_RUNTIME\t");
827
828 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
829 {
830 hc_device_param_t *device_param = &data.devices_param[device_id];
831
832 if (device_param->skipped) continue;
833
834 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
835
836 fprintf (out, "%f\t", exec_ms_avg);
837 }
838
839 /**
840 * words_cur
841 */
842
843 u64 words_cur = get_lowest_words_done ();
844
845 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
846
847 /**
848 * counter
849 */
850
851 u64 progress_total = data.words_cnt * data.salts_cnt;
852
853 u64 all_done = 0;
854 u64 all_rejected = 0;
855 u64 all_restored = 0;
856
857 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
858 {
859 all_done += data.words_progress_done[salt_pos];
860 all_rejected += data.words_progress_rejected[salt_pos];
861 all_restored += data.words_progress_restored[salt_pos];
862 }
863
864 u64 progress_cur = all_restored + all_done + all_rejected;
865 u64 progress_end = progress_total;
866
867 u64 progress_skip = 0;
868
869 if (data.skip)
870 {
871 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
872
873 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
874 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
875 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
876 }
877
878 if (data.limit)
879 {
880 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
881
882 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
883 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
884 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
885 }
886
887 u64 progress_cur_relative_skip = progress_cur - progress_skip;
888 u64 progress_end_relative_skip = progress_end - progress_skip;
889
890 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
891
892 /**
893 * cracks
894 */
895
896 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
897 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
898
899 /**
900 * temperature
901 */
902
903 #ifdef HAVE_HWMON
904 if (data.gpu_temp_disable == 0)
905 {
906 fprintf (out, "TEMP\t");
907
908 hc_thread_mutex_lock (mux_adl);
909
910 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
911 {
912 hc_device_param_t *device_param = &data.devices_param[device_id];
913
914 if (device_param->skipped) continue;
915
916 int temp = hm_get_temperature_with_device_id (device_id);
917
918 fprintf (out, "%d\t", temp);
919 }
920
921 hc_thread_mutex_unlock (mux_adl);
922 }
923 #endif // HAVE_HWMON
924
925 /**
926 * flush
927 */
928
929 #ifdef _WIN
930 fputc ('\r', out);
931 fputc ('\n', out);
932 #endif
933
934 #ifdef _POSIX
935 fputc ('\n', out);
936 #endif
937
938 fflush (out);
939 }
940
941 void status_display ()
942 {
943 if (data.devices_status == STATUS_INIT) return;
944 if (data.devices_status == STATUS_STARTING) return;
945 if (data.devices_status == STATUS_BYPASS) return;
946
947 if (data.status_automat == 1)
948 {
949 status_display_automat ();
950
951 return;
952 }
953
954 char tmp_buf[1000] = { 0 };
955
956 uint tmp_len = 0;
957
958 log_info ("Session.Name...: %s", data.session);
959
960 char *status_type = strstatus (data.devices_status);
961
962 uint hash_mode = data.hash_mode;
963
964 char *hash_type = strhashtype (hash_mode); // not a bug
965
966 log_info ("Status.........: %s", status_type);
967
968 /**
969 * show rules
970 */
971
972 if (data.rp_files_cnt)
973 {
974 uint i;
975
976 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
977 {
978 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
979 }
980
981 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
982
983 log_info ("Rules.Type.....: %s", tmp_buf);
984
985 tmp_len = 0;
986 }
987
988 if (data.rp_gen)
989 {
990 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
991
992 if (data.rp_gen_seed)
993 {
994 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
995 }
996 }
997
998 /**
999 * show input
1000 */
1001
1002 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1003 {
1004 if (data.wordlist_mode == WL_MODE_FILE)
1005 {
1006 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1007 }
1008 else if (data.wordlist_mode == WL_MODE_STDIN)
1009 {
1010 log_info ("Input.Mode.....: Pipe");
1011 }
1012 }
1013 else if (data.attack_mode == ATTACK_MODE_COMBI)
1014 {
1015 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1016 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1017 }
1018 else if (data.attack_mode == ATTACK_MODE_BF)
1019 {
1020 char *mask = data.mask;
1021
1022 if (mask != NULL)
1023 {
1024 uint mask_len = data.css_cnt;
1025
1026 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1027
1028 if (mask_len > 0)
1029 {
1030 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1031 {
1032 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1033 {
1034 mask_len -= data.salts_buf[0].salt_len;
1035 }
1036 }
1037
1038 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1039
1040 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1041 }
1042
1043 if (data.maskcnt > 1)
1044 {
1045 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1046
1047 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1048 }
1049
1050 log_info ("Input.Mode.....: %s", tmp_buf);
1051 }
1052
1053 tmp_len = 0;
1054 }
1055 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1056 {
1057 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1058 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1059 }
1060 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1061 {
1062 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1063 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1064 }
1065
1066 if (data.digests_cnt == 1)
1067 {
1068 if (data.hash_mode == 2500)
1069 {
1070 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1071
1072 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1073 (char *) data.salts_buf[0].salt_buf,
1074 wpa->orig_mac1[0],
1075 wpa->orig_mac1[1],
1076 wpa->orig_mac1[2],
1077 wpa->orig_mac1[3],
1078 wpa->orig_mac1[4],
1079 wpa->orig_mac1[5],
1080 wpa->orig_mac2[0],
1081 wpa->orig_mac2[1],
1082 wpa->orig_mac2[2],
1083 wpa->orig_mac2[3],
1084 wpa->orig_mac2[4],
1085 wpa->orig_mac2[5]);
1086 }
1087 else if (data.hash_mode == 5200)
1088 {
1089 log_info ("Hash.Target....: File (%s)", data.hashfile);
1090 }
1091 else if (data.hash_mode == 9000)
1092 {
1093 log_info ("Hash.Target....: File (%s)", data.hashfile);
1094 }
1095 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1096 {
1097 log_info ("Hash.Target....: File (%s)", data.hashfile);
1098 }
1099 else
1100 {
1101 char out_buf[HCBUFSIZ] = { 0 };
1102
1103 ascii_digest (out_buf, 0, 0);
1104
1105 // limit length
1106 if (strlen (out_buf) > 40)
1107 {
1108 out_buf[41] = '.';
1109 out_buf[42] = '.';
1110 out_buf[43] = '.';
1111 out_buf[44] = 0;
1112 }
1113
1114 log_info ("Hash.Target....: %s", out_buf);
1115 }
1116 }
1117 else
1118 {
1119 if (data.hash_mode == 3000)
1120 {
1121 char out_buf1[32] = { 0 };
1122 char out_buf2[32] = { 0 };
1123
1124 ascii_digest (out_buf1, 0, 0);
1125 ascii_digest (out_buf2, 0, 1);
1126
1127 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1128 }
1129 else
1130 {
1131 log_info ("Hash.Target....: File (%s)", data.hashfile);
1132 }
1133 }
1134
1135 log_info ("Hash.Type......: %s", hash_type);
1136
1137 /**
1138 * speed new
1139 */
1140
1141 u64 speed_cnt[DEVICES_MAX] = { 0 };
1142 double speed_ms[DEVICES_MAX] = { 0 };
1143
1144 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1145 {
1146 hc_device_param_t *device_param = &data.devices_param[device_id];
1147
1148 if (device_param->skipped) continue;
1149
1150 speed_cnt[device_id] = 0;
1151 speed_ms[device_id] = 0;
1152
1153 for (int i = 0; i < SPEED_CACHE; i++)
1154 {
1155 speed_cnt[device_id] += device_param->speed_cnt[i];
1156 speed_ms[device_id] += device_param->speed_ms[i];
1157 }
1158
1159 speed_cnt[device_id] /= SPEED_CACHE;
1160 speed_ms[device_id] /= SPEED_CACHE;
1161 }
1162
1163 double hashes_all_ms = 0;
1164
1165 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1166
1167 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1168 {
1169 hc_device_param_t *device_param = &data.devices_param[device_id];
1170
1171 if (device_param->skipped) continue;
1172
1173 hashes_dev_ms[device_id] = 0;
1174
1175 if (speed_ms[device_id])
1176 {
1177 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1178
1179 hashes_all_ms += hashes_dev_ms[device_id];
1180 }
1181 }
1182
1183 /**
1184 * exec time
1185 */
1186
1187 double exec_all_ms[DEVICES_MAX] = { 0 };
1188
1189 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1190 {
1191 hc_device_param_t *device_param = &data.devices_param[device_id];
1192
1193 if (device_param->skipped) continue;
1194
1195 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1196
1197 exec_all_ms[device_id] = exec_ms_avg;
1198 }
1199
1200 /**
1201 * timers
1202 */
1203
1204 double ms_running = 0;
1205
1206 hc_timer_get (data.timer_running, ms_running);
1207
1208 double ms_paused = data.ms_paused;
1209
1210 if (data.devices_status == STATUS_PAUSED)
1211 {
1212 double ms_paused_tmp = 0;
1213
1214 hc_timer_get (data.timer_paused, ms_paused_tmp);
1215
1216 ms_paused += ms_paused_tmp;
1217 }
1218
1219 #ifdef WIN
1220
1221 __time64_t sec_run = ms_running / 1000;
1222
1223 #else
1224
1225 time_t sec_run = ms_running / 1000;
1226
1227 #endif
1228
1229 if (sec_run)
1230 {
1231 char display_run[32] = { 0 };
1232
1233 struct tm tm_run;
1234
1235 struct tm *tmp = NULL;
1236
1237 #ifdef WIN
1238
1239 tmp = _gmtime64 (&sec_run);
1240
1241 #else
1242
1243 tmp = gmtime (&sec_run);
1244
1245 #endif
1246
1247 if (tmp != NULL)
1248 {
1249 memset (&tm_run, 0, sizeof (tm_run));
1250
1251 memcpy (&tm_run, tmp, sizeof (tm_run));
1252
1253 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1254
1255 char *start = ctime (&data.proc_start);
1256
1257 size_t start_len = strlen (start);
1258
1259 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1260 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1261
1262 log_info ("Time.Started...: %s (%s)", start, display_run);
1263 }
1264 }
1265 else
1266 {
1267 log_info ("Time.Started...: 0 secs");
1268 }
1269
1270 /**
1271 * counters
1272 */
1273
1274 u64 progress_total = data.words_cnt * data.salts_cnt;
1275
1276 u64 all_done = 0;
1277 u64 all_rejected = 0;
1278 u64 all_restored = 0;
1279
1280 u64 progress_noneed = 0;
1281
1282 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1283 {
1284 all_done += data.words_progress_done[salt_pos];
1285 all_rejected += data.words_progress_rejected[salt_pos];
1286 all_restored += data.words_progress_restored[salt_pos];
1287
1288 // Important for ETA only
1289
1290 if (data.salts_shown[salt_pos] == 1)
1291 {
1292 const u64 all = data.words_progress_done[salt_pos]
1293 + data.words_progress_rejected[salt_pos]
1294 + data.words_progress_restored[salt_pos];
1295
1296 const u64 left = data.words_cnt - all;
1297
1298 progress_noneed += left;
1299 }
1300 }
1301
1302 u64 progress_cur = all_restored + all_done + all_rejected;
1303 u64 progress_end = progress_total;
1304
1305 u64 progress_skip = 0;
1306
1307 if (data.skip)
1308 {
1309 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1310
1311 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1312 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1313 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1314 }
1315
1316 if (data.limit)
1317 {
1318 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1319
1320 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1321 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1322 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1323 }
1324
1325 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1326 u64 progress_end_relative_skip = progress_end - progress_skip;
1327
1328 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1329 {
1330 if (data.devices_status != STATUS_CRACKED)
1331 {
1332 #ifdef WIN
1333 __time64_t sec_etc = 0;
1334 #else
1335 time_t sec_etc = 0;
1336 #endif
1337
1338 if (hashes_all_ms)
1339 {
1340 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1341
1342 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1343
1344 sec_etc = ms_left / 1000;
1345 }
1346
1347 if (sec_etc == 0)
1348 {
1349 //log_info ("Time.Estimated.: 0 secs");
1350 }
1351 else if ((u64) sec_etc > ETC_MAX)
1352 {
1353 log_info ("Time.Estimated.: > 10 Years");
1354 }
1355 else
1356 {
1357 char display_etc[32] = { 0 };
1358
1359 struct tm tm_etc;
1360
1361 struct tm *tmp = NULL;
1362
1363 #ifdef WIN
1364
1365 tmp = _gmtime64 (&sec_etc);
1366
1367 #else
1368
1369 tmp = gmtime (&sec_etc);
1370
1371 #endif
1372
1373 if (tmp != NULL)
1374 {
1375 memset (&tm_etc, 0, sizeof (tm_etc));
1376
1377 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1378
1379 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1380
1381 time_t now;
1382
1383 time (&now);
1384
1385 now += sec_etc;
1386
1387 char *etc = ctime (&now);
1388
1389 size_t etc_len = strlen (etc);
1390
1391 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1392 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1393
1394 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1395 }
1396 }
1397 }
1398 }
1399
1400 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1401 {
1402 hc_device_param_t *device_param = &data.devices_param[device_id];
1403
1404 if (device_param->skipped) continue;
1405
1406 char display_dev_cur[16] = { 0 };
1407
1408 strncpy (display_dev_cur, "0.00", 4);
1409
1410 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1411
1412 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1413 }
1414
1415 char display_all_cur[16] = { 0 };
1416
1417 strncpy (display_all_cur, "0.00", 4);
1418
1419 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1420
1421 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1422
1423 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1424 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1425
1426 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1427
1428 // crack-per-time
1429
1430 if (data.digests_cnt > 100)
1431 {
1432 time_t now = time (NULL);
1433
1434 int cpt_cur_min = 0;
1435 int cpt_cur_hour = 0;
1436 int cpt_cur_day = 0;
1437
1438 for (int i = 0; i < CPT_BUF; i++)
1439 {
1440 const uint cracked = data.cpt_buf[i].cracked;
1441 const time_t timestamp = data.cpt_buf[i].timestamp;
1442
1443 if ((timestamp + 60) > now)
1444 {
1445 cpt_cur_min += cracked;
1446 }
1447
1448 if ((timestamp + 3600) > now)
1449 {
1450 cpt_cur_hour += cracked;
1451 }
1452
1453 if ((timestamp + 86400) > now)
1454 {
1455 cpt_cur_day += cracked;
1456 }
1457 }
1458
1459 double ms_real = ms_running - ms_paused;
1460
1461 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1462 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1463 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1464
1465 if ((data.cpt_start + 86400) < now)
1466 {
1467 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1468 cpt_cur_min,
1469 cpt_cur_hour,
1470 cpt_cur_day,
1471 cpt_avg_min,
1472 cpt_avg_hour,
1473 cpt_avg_day);
1474 }
1475 else if ((data.cpt_start + 3600) < now)
1476 {
1477 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1478 cpt_cur_min,
1479 cpt_cur_hour,
1480 cpt_avg_min,
1481 cpt_avg_hour,
1482 cpt_avg_day);
1483 }
1484 else if ((data.cpt_start + 60) < now)
1485 {
1486 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1487 cpt_cur_min,
1488 cpt_avg_min,
1489 cpt_avg_hour,
1490 cpt_avg_day);
1491 }
1492 else
1493 {
1494 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1495 cpt_avg_min,
1496 cpt_avg_hour,
1497 cpt_avg_day);
1498 }
1499 }
1500
1501 // Restore point
1502
1503 u64 restore_point = get_lowest_words_done ();
1504
1505 u64 restore_total = data.words_base;
1506
1507 float percent_restore = 0;
1508
1509 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1510
1511 if (progress_end_relative_skip)
1512 {
1513 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1514 {
1515 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1516 float percent_rejected = 0.0;
1517
1518 if (progress_cur)
1519 {
1520 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1521 }
1522
1523 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1524 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1525
1526 if (data.restore_disable == 0)
1527 {
1528 if (percent_finished != 1)
1529 {
1530 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1531 }
1532 }
1533 }
1534 }
1535 else
1536 {
1537 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1538 {
1539 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1540 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1541
1542 if (data.restore_disable == 0)
1543 {
1544 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1545 }
1546 }
1547 else
1548 {
1549 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1550 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1551
1552 // --restore not allowed if stdin is used -- really? why?
1553
1554 //if (data.restore_disable == 0)
1555 //{
1556 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1557 //}
1558 }
1559 }
1560
1561 #ifdef HAVE_HWMON
1562 if (data.gpu_temp_disable == 0)
1563 {
1564 hc_thread_mutex_lock (mux_adl);
1565
1566 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1567 {
1568 hc_device_param_t *device_param = &data.devices_param[device_id];
1569
1570 if (device_param->skipped) continue;
1571
1572 #define HM_STR_BUF_SIZE 255
1573
1574 if (data.hm_device[device_id].fan_supported == 1)
1575 {
1576 char utilization[HM_STR_BUF_SIZE] = { 0 };
1577 char temperature[HM_STR_BUF_SIZE] = { 0 };
1578 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1579
1580 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1581 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1582
1583 if (device_param->vendor_id == VENDOR_ID_AMD)
1584 {
1585 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1586 }
1587 else if (device_param->vendor_id == VENDOR_ID_NV)
1588 {
1589 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1590 }
1591
1592 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1593 }
1594 else
1595 {
1596 char utilization[HM_STR_BUF_SIZE] = { 0 };
1597 char temperature[HM_STR_BUF_SIZE] = { 0 };
1598
1599 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1600 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1601
1602 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1603 }
1604 }
1605
1606 hc_thread_mutex_unlock (mux_adl);
1607 }
1608 #endif // HAVE_HWMON
1609 }
1610
1611 static void status_benchmark_automat ()
1612 {
1613 u64 speed_cnt[DEVICES_MAX] = { 0 };
1614 double speed_ms[DEVICES_MAX] = { 0 };
1615
1616 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1617 {
1618 hc_device_param_t *device_param = &data.devices_param[device_id];
1619
1620 if (device_param->skipped) continue;
1621
1622 speed_cnt[device_id] = device_param->speed_cnt[0];
1623 speed_ms[device_id] = device_param->speed_ms[0];
1624 }
1625
1626 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1627
1628 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1629 {
1630 hc_device_param_t *device_param = &data.devices_param[device_id];
1631
1632 if (device_param->skipped) continue;
1633
1634 hashes_dev_ms[device_id] = 0;
1635
1636 if (speed_ms[device_id])
1637 {
1638 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1639 }
1640 }
1641
1642 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1643 {
1644 hc_device_param_t *device_param = &data.devices_param[device_id];
1645
1646 if (device_param->skipped) continue;
1647
1648 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1649 }
1650 }
1651
1652 static void status_benchmark ()
1653 {
1654 if (data.devices_status == STATUS_INIT) return;
1655 if (data.devices_status == STATUS_STARTING) return;
1656 if (data.devices_status == STATUS_BYPASS) return;
1657
1658 if (data.status_automat == 1)
1659 {
1660 status_benchmark_automat ();
1661
1662 return;
1663 }
1664
1665 u64 speed_cnt[DEVICES_MAX] = { 0 };
1666 double speed_ms[DEVICES_MAX] = { 0 };
1667
1668 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1669 {
1670 hc_device_param_t *device_param = &data.devices_param[device_id];
1671
1672 if (device_param->skipped) continue;
1673
1674 speed_cnt[device_id] = device_param->speed_cnt[0];
1675 speed_ms[device_id] = device_param->speed_ms[0];
1676 }
1677
1678 double hashes_all_ms = 0;
1679
1680 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1681
1682 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1683 {
1684 hc_device_param_t *device_param = &data.devices_param[device_id];
1685
1686 if (device_param->skipped) continue;
1687
1688 hashes_dev_ms[device_id] = 0;
1689
1690 if (speed_ms[device_id])
1691 {
1692 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1693
1694 hashes_all_ms += hashes_dev_ms[device_id];
1695 }
1696 }
1697
1698 /**
1699 * exec time
1700 */
1701
1702 double exec_all_ms[DEVICES_MAX] = { 0 };
1703
1704 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1705 {
1706 hc_device_param_t *device_param = &data.devices_param[device_id];
1707
1708 if (device_param->skipped) continue;
1709
1710 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1711
1712 exec_all_ms[device_id] = exec_ms_avg;
1713 }
1714
1715 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1716 {
1717 hc_device_param_t *device_param = &data.devices_param[device_id];
1718
1719 if (device_param->skipped) continue;
1720
1721 char display_dev_cur[16] = { 0 };
1722
1723 strncpy (display_dev_cur, "0.00", 4);
1724
1725 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1726
1727 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1728 }
1729
1730 char display_all_cur[16] = { 0 };
1731
1732 strncpy (display_all_cur, "0.00", 4);
1733
1734 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1735
1736 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1737 }
1738
1739 /**
1740 * hashcat -only- functions
1741 */
1742
1743 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1744 {
1745 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1746 {
1747 if (attack_kern == ATTACK_KERN_STRAIGHT)
1748 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1749 else if (attack_kern == ATTACK_KERN_COMBI)
1750 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1751 else if (attack_kern == ATTACK_KERN_BF)
1752 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1753 }
1754 else
1755 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1756 }
1757
1758 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1759 {
1760 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1761 {
1762 if (attack_kern == ATTACK_KERN_STRAIGHT)
1763 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1764 else if (attack_kern == ATTACK_KERN_COMBI)
1765 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1766 else if (attack_kern == ATTACK_KERN_BF)
1767 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1768 }
1769 else
1770 {
1771 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1772 }
1773 }
1774
1775 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1776 {
1777 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1778 {
1779 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1780 }
1781 else
1782 {
1783 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1784 }
1785 }
1786
1787 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1788 {
1789 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1790 {
1791 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1792 }
1793 else
1794 {
1795 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1796 }
1797 }
1798
1799 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1800 {
1801 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1802 }
1803
1804 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1805 {
1806 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1807 }
1808
1809 static uint convert_from_hex (char *line_buf, const uint line_len)
1810 {
1811 if (line_len & 1) return (line_len); // not in hex
1812
1813 if (data.hex_wordlist == 1)
1814 {
1815 uint i;
1816 uint j;
1817
1818 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1819 {
1820 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1821 }
1822
1823 memset (line_buf + i, 0, line_len - i);
1824
1825 return (i);
1826 }
1827 else if (line_len >= 6) // $HEX[] = 6
1828 {
1829 if (line_buf[0] != '$') return (line_len);
1830 if (line_buf[1] != 'H') return (line_len);
1831 if (line_buf[2] != 'E') return (line_len);
1832 if (line_buf[3] != 'X') return (line_len);
1833 if (line_buf[4] != '[') return (line_len);
1834 if (line_buf[line_len - 1] != ']') return (line_len);
1835
1836 uint i;
1837 uint j;
1838
1839 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1840 {
1841 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1842 }
1843
1844 memset (line_buf + i, 0, line_len - i);
1845
1846 return (i);
1847 }
1848
1849 return (line_len);
1850 }
1851
1852 static void clear_prompt ()
1853 {
1854 fputc ('\r', stdout);
1855
1856 for (size_t i = 0; i < strlen (PROMPT); i++)
1857 {
1858 fputc (' ', stdout);
1859 }
1860
1861 fputc ('\r', stdout);
1862
1863 fflush (stdout);
1864 }
1865
1866 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1867 {
1868 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1869 }
1870
1871 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1872 {
1873 char *outfile = data.outfile;
1874 uint quiet = data.quiet;
1875 FILE *pot_fp = data.pot_fp;
1876 uint loopback = data.loopback;
1877 uint debug_mode = data.debug_mode;
1878 char *debug_file = data.debug_file;
1879
1880 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1881 int debug_rule_len = 0; // -1 error
1882 uint debug_plain_len = 0;
1883
1884 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1885
1886 // hash
1887
1888 char out_buf[HCBUFSIZ] = { 0 };
1889
1890 ascii_digest (out_buf, salt_pos, digest_pos);
1891
1892 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1893
1894 // plain
1895
1896 plain_t plain;
1897
1898 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1899
1900 uint gidvid = plain.gidvid;
1901 uint il_pos = plain.il_pos;
1902
1903 u64 crackpos = device_param->words_off;
1904
1905 uint plain_buf[16] = { 0 };
1906
1907 u8 *plain_ptr = (u8 *) plain_buf;
1908 unsigned int plain_len = 0;
1909
1910 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1911 {
1912 u64 gidd = gidvid;
1913 u64 gidm = 0;
1914
1915 pw_t pw;
1916
1917 gidd_to_pw_t (device_param, gidd, &pw);
1918
1919 for (int i = 0, j = gidm; i < 16; i++, j++)
1920 {
1921 plain_buf[i] = pw.i[j];
1922 }
1923
1924 plain_len = pw.pw_len;
1925
1926 const uint off = device_param->innerloop_pos + il_pos;
1927
1928 if (debug_mode > 0)
1929 {
1930 debug_rule_len = 0;
1931
1932 // save rule
1933 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1934 {
1935 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1936
1937 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1938 }
1939
1940 // save plain
1941 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1942 {
1943 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1944
1945 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1946
1947 debug_plain_len = plain_len;
1948 }
1949 }
1950
1951 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1952
1953 crackpos += gidvid;
1954 crackpos *= data.kernel_rules_cnt;
1955 crackpos += device_param->innerloop_pos + il_pos;
1956
1957 if (plain_len > data.pw_max) plain_len = data.pw_max;
1958 }
1959 else if (data.attack_mode == ATTACK_MODE_COMBI)
1960 {
1961 u64 gidd = gidvid;
1962 u64 gidm = 0;
1963
1964 pw_t pw;
1965
1966 gidd_to_pw_t (device_param, gidd, &pw);
1967
1968 for (int i = 0, j = gidm; i < 16; i++, j++)
1969 {
1970 plain_buf[i] = pw.i[j];
1971 }
1972
1973 plain_len = pw.pw_len;
1974
1975 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1976 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1977
1978 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1979 {
1980 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1981 }
1982 else
1983 {
1984 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1985
1986 memcpy (plain_ptr, comb_buf, comb_len);
1987 }
1988
1989 plain_len += comb_len;
1990
1991 crackpos += gidvid;
1992 crackpos *= data.combs_cnt;
1993 crackpos += device_param->innerloop_pos + il_pos;
1994
1995 if (data.pw_max != PW_DICTMAX1)
1996 {
1997 if (plain_len > data.pw_max) plain_len = data.pw_max;
1998 }
1999 }
2000 else if (data.attack_mode == ATTACK_MODE_BF)
2001 {
2002 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2003 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2004
2005 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2006 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2007
2008 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2009 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2010
2011 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2012 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2013
2014 plain_len = data.css_cnt;
2015
2016 crackpos += gidvid;
2017 crackpos *= data.bfs_cnt;
2018 crackpos += device_param->innerloop_pos + il_pos;
2019 }
2020 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2021 {
2022 u64 gidd = gidvid;
2023 u64 gidm = 0;
2024
2025 pw_t pw;
2026
2027 gidd_to_pw_t (device_param, gidd, &pw);
2028
2029 for (int i = 0, j = gidm; i < 16; i++, j++)
2030 {
2031 plain_buf[i] = pw.i[j];
2032 }
2033
2034 plain_len = pw.pw_len;
2035
2036 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2037
2038 uint start = 0;
2039 uint stop = device_param->kernel_params_mp_buf32[4];
2040
2041 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2042
2043 plain_len += start + stop;
2044
2045 crackpos += gidvid;
2046 crackpos *= data.combs_cnt;
2047 crackpos += device_param->innerloop_pos + il_pos;
2048
2049 if (data.pw_max != PW_DICTMAX1)
2050 {
2051 if (plain_len > data.pw_max) plain_len = data.pw_max;
2052 }
2053 }
2054 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2055 {
2056 u64 gidd = gidvid;
2057 u64 gidm = 0;
2058
2059 pw_t pw;
2060
2061 gidd_to_pw_t (device_param, gidd, &pw);
2062
2063 for (int i = 0, j = gidm; i < 16; i++, j++)
2064 {
2065 plain_buf[i] = pw.i[j];
2066 }
2067
2068 plain_len = pw.pw_len;
2069
2070 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2071
2072 uint start = 0;
2073 uint stop = device_param->kernel_params_mp_buf32[4];
2074
2075 memmove (plain_ptr + stop, plain_ptr, plain_len);
2076
2077 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2078
2079 plain_len += start + stop;
2080
2081 crackpos += gidvid;
2082 crackpos *= data.combs_cnt;
2083 crackpos += device_param->innerloop_pos + il_pos;
2084
2085 if (data.pw_max != PW_DICTMAX1)
2086 {
2087 if (plain_len > data.pw_max) plain_len = data.pw_max;
2088 }
2089 }
2090
2091 if (data.attack_mode == ATTACK_MODE_BF)
2092 {
2093 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2094 {
2095 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2096 {
2097 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2098 {
2099 plain_len = plain_len - data.salts_buf[0].salt_len;
2100 }
2101 }
2102
2103 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2104 {
2105 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2106 {
2107 plain_ptr[j] = plain_ptr[i];
2108 }
2109
2110 plain_len = plain_len / 2;
2111 }
2112 }
2113 }
2114
2115 // if enabled, update also the potfile
2116
2117 if (pot_fp)
2118 {
2119 lock_file (pot_fp);
2120
2121 fprintf (pot_fp, "%s:", out_buf);
2122
2123 format_plain (pot_fp, plain_ptr, plain_len, 1);
2124
2125 fputc ('\n', pot_fp);
2126
2127 fflush (pot_fp);
2128
2129 unlock_file (pot_fp);
2130 }
2131
2132 // outfile
2133
2134 FILE *out_fp = NULL;
2135
2136 if (outfile != NULL)
2137 {
2138 if ((out_fp = fopen (outfile, "ab")) == NULL)
2139 {
2140 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2141
2142 out_fp = stdout;
2143 }
2144 lock_file (out_fp);
2145 }
2146 else
2147 {
2148 out_fp = stdout;
2149
2150 if (quiet == 0) clear_prompt ();
2151 }
2152
2153 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2154
2155 if (outfile != NULL)
2156 {
2157 if (out_fp != stdout)
2158 {
2159 fclose (out_fp);
2160 }
2161 }
2162 else
2163 {
2164 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2165 {
2166 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2167 {
2168 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2169 if (quiet == 0) fflush (stdout);
2170 }
2171 }
2172 }
2173
2174 // loopback
2175
2176 if (loopback)
2177 {
2178 char *loopback_file = data.loopback_file;
2179
2180 FILE *fb_fp = NULL;
2181
2182 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2183 {
2184 lock_file (fb_fp);
2185
2186 format_plain (fb_fp, plain_ptr, plain_len, 1);
2187
2188 fputc ('\n', fb_fp);
2189
2190 fclose (fb_fp);
2191 }
2192 }
2193
2194 // (rule) debug mode
2195
2196 // the next check implies that:
2197 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2198 // - debug_mode > 0
2199
2200 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2201 {
2202 if (debug_rule_len < 0) debug_rule_len = 0;
2203
2204 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2205
2206 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2207
2208 if ((quiet == 0) && (debug_file == NULL))
2209 {
2210 fprintf (stdout, "%s", PROMPT);
2211
2212 fflush (stdout);
2213 }
2214 }
2215 }
2216
2217 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2218 {
2219 salt_t *salt_buf = &data.salts_buf[salt_pos];
2220
2221 int found = 0;
2222
2223 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2224
2225 for (uint i = 0; i < device_param->kernel_threads; i++) if (device_param->result[i] == 1) found = 1;
2226
2227 if (found == 1)
2228 {
2229 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2230
2231 log_info_nn ("");
2232
2233 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2234
2235 uint cpt_cracked = 0;
2236
2237 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2238 {
2239 uint idx = salt_buf->digests_offset + digest_pos;
2240
2241 if (data.digests_shown_tmp[idx] == 0) continue;
2242
2243 if (data.digests_shown[idx] == 1) continue;
2244
2245 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2246 {
2247 data.digests_shown[idx] = 1;
2248
2249 data.digests_done++;
2250
2251 cpt_cracked++;
2252
2253 salt_buf->digests_done++;
2254
2255 if (salt_buf->digests_done == salt_buf->digests_cnt)
2256 {
2257 data.salts_shown[salt_pos] = 1;
2258
2259 data.salts_done++;
2260 }
2261 }
2262
2263 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2264
2265 check_hash (device_param, salt_pos, digest_pos);
2266 }
2267
2268 if (cpt_cracked > 0)
2269 {
2270 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2271 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2272
2273 data.cpt_pos++;
2274
2275 data.cpt_total += cpt_cracked;
2276
2277 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2278 }
2279
2280 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2281 {
2282 // we need to reset cracked state on the device
2283 // otherwise host thinks again and again the hash was cracked
2284 // and returns invalid password each time
2285
2286 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2287
2288 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2289 }
2290
2291 memset (device_param->result, 0, device_param->size_results);
2292
2293 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2294 }
2295 }
2296
2297 static void save_hash ()
2298 {
2299 char *hashfile = data.hashfile;
2300
2301 char new_hashfile[256] = { 0 };
2302 char old_hashfile[256] = { 0 };
2303
2304 snprintf (new_hashfile, 255, "%s.new", hashfile);
2305 snprintf (old_hashfile, 255, "%s.old", hashfile);
2306
2307 unlink (new_hashfile);
2308
2309 char separator = data.separator;
2310
2311 FILE *fp = fopen (new_hashfile, "wb");
2312
2313 if (fp == NULL)
2314 {
2315 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2316
2317 exit (-1);
2318 }
2319
2320 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2321 {
2322 if (data.salts_shown[salt_pos] == 1) continue;
2323
2324 salt_t *salt_buf = &data.salts_buf[salt_pos];
2325
2326 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2327 {
2328 uint idx = salt_buf->digests_offset + digest_pos;
2329
2330 if (data.digests_shown[idx] == 1) continue;
2331
2332 if (data.hash_mode != 2500)
2333 {
2334 char out_buf[HCBUFSIZ] = { 0 };
2335
2336 if (data.username == 1)
2337 {
2338 user_t *user = data.hash_info[idx]->user;
2339
2340 uint i;
2341
2342 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2343
2344 fputc (separator, fp);
2345 }
2346
2347 ascii_digest (out_buf, salt_pos, digest_pos);
2348
2349 fputs (out_buf, fp);
2350
2351 log_out (fp, "");
2352 }
2353 else
2354 {
2355 hccap_t hccap;
2356
2357 to_hccap_t (&hccap, salt_pos, digest_pos);
2358
2359 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2360 }
2361 }
2362 }
2363
2364 fflush (fp);
2365
2366 fclose (fp);
2367
2368 unlink (old_hashfile);
2369
2370 if (rename (hashfile, old_hashfile) != 0)
2371 {
2372 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2373
2374 exit (-1);
2375 }
2376
2377 unlink (hashfile);
2378
2379 if (rename (new_hashfile, hashfile) != 0)
2380 {
2381 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2382
2383 exit (-1);
2384 }
2385
2386 unlink (old_hashfile);
2387 }
2388
2389 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2390 {
2391 // function called only in case kernel_power_all > words_left
2392
2393 float kernel_power_div = (float) (total_left) / kernel_power_all;
2394
2395 kernel_power_div += kernel_power_div / 100;
2396
2397 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2398
2399 while (kernel_power_new < total_left)
2400 {
2401 kernel_power_div += kernel_power_div / 100;
2402
2403 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2404 }
2405
2406 if (data.quiet == 0)
2407 {
2408 clear_prompt ();
2409
2410 //log_info ("");
2411
2412 log_info ("INFO: approaching final keyspace, workload adjusted");
2413 log_info ("");
2414
2415 fprintf (stdout, "%s", PROMPT);
2416
2417 fflush (stdout);
2418 }
2419
2420 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2421
2422 return kernel_power_div;
2423 }
2424
2425 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2426 {
2427 uint num_elements = num;
2428
2429 device_param->kernel_params_buf32[30] = data.combs_mode;
2430 device_param->kernel_params_buf32[31] = num;
2431
2432 uint kernel_threads = device_param->kernel_threads;
2433
2434 while (num_elements % kernel_threads) num_elements++;
2435
2436 cl_kernel kernel = NULL;
2437
2438 switch (kern_run)
2439 {
2440 case KERN_RUN_1: kernel = device_param->kernel1; break;
2441 case KERN_RUN_12: kernel = device_param->kernel12; break;
2442 case KERN_RUN_2: kernel = device_param->kernel2; break;
2443 case KERN_RUN_23: kernel = device_param->kernel23; break;
2444 case KERN_RUN_3: kernel = device_param->kernel3; break;
2445 }
2446
2447 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2448 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2449 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2450 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2451 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2452 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2453 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2454 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2455 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2456 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2457 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2458
2459 cl_event event;
2460
2461 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2462 {
2463 const size_t global_work_size[3] = { num_elements, 32, 1 };
2464 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2465
2466 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2467 }
2468 else
2469 {
2470 if (kern_run == KERN_RUN_2)
2471 {
2472 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2473 {
2474 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2475 }
2476 }
2477
2478 while (num_elements % kernel_threads) num_elements++;
2479
2480 const size_t global_work_size[3] = { num_elements, 1, 1 };
2481 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2482
2483 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2484 }
2485
2486 hc_clFlush (data.ocl, device_param->command_queue);
2487
2488 hc_clWaitForEvents (data.ocl, 1, &event);
2489
2490 if (event_update)
2491 {
2492 cl_ulong time_start;
2493 cl_ulong time_end;
2494
2495 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2496 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2497
2498 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2499
2500 uint exec_pos = device_param->exec_pos;
2501
2502 device_param->exec_ms[exec_pos] = exec_time;
2503
2504 exec_pos++;
2505
2506 if (exec_pos == EXEC_CACHE)
2507 {
2508 exec_pos = 0;
2509 }
2510
2511 device_param->exec_pos = exec_pos;
2512 }
2513
2514 hc_clReleaseEvent (data.ocl, event);
2515
2516 hc_clFinish (data.ocl, device_param->command_queue);
2517 }
2518
2519 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2520 {
2521 uint num_elements = num;
2522
2523 switch (kern_run)
2524 {
2525 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2526 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2527 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2528 }
2529
2530 // causes problems with special threads like in bcrypt
2531 // const uint kernel_threads = device_param->kernel_threads;
2532
2533 uint kernel_threads = device_param->kernel_threads;
2534
2535 while (num_elements % kernel_threads) num_elements++;
2536
2537 cl_kernel kernel = NULL;
2538
2539 switch (kern_run)
2540 {
2541 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2542 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2543 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2544 }
2545
2546 switch (kern_run)
2547 {
2548 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2549 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2550 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2551 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2552 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2553 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2554 break;
2555 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2556 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2557 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2558 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2559 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2560 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2561 break;
2562 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2563 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2564 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2565 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2566 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2567 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2568 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2569 break;
2570 }
2571
2572 const size_t global_work_size[3] = { num_elements, 1, 1 };
2573 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2574
2575 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2576
2577 hc_clFlush (data.ocl, device_param->command_queue);
2578
2579 hc_clFinish (data.ocl, device_param->command_queue);
2580 }
2581
2582 static void run_kernel_tm (hc_device_param_t *device_param)
2583 {
2584 const uint num_elements = 1024; // fixed
2585
2586 uint kernel_threads = 32;
2587
2588 cl_kernel kernel = device_param->kernel_tm;
2589
2590 const size_t global_work_size[3] = { num_elements, 1, 1 };
2591 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2592
2593 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2594
2595 hc_clFlush (data.ocl, device_param->command_queue);
2596
2597 hc_clFinish (data.ocl, device_param->command_queue);
2598 }
2599
2600 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2601 {
2602 uint num_elements = num;
2603
2604 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2605 device_param->kernel_params_amp_buf32[6] = num_elements;
2606
2607 // causes problems with special threads like in bcrypt
2608 // const uint kernel_threads = device_param->kernel_threads;
2609
2610 uint kernel_threads = device_param->kernel_threads;
2611
2612 while (num_elements % kernel_threads) num_elements++;
2613
2614 cl_kernel kernel = device_param->kernel_amp;
2615
2616 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2617 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2618
2619 const size_t global_work_size[3] = { num_elements, 1, 1 };
2620 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2621
2622 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2623
2624 hc_clFlush (data.ocl, device_param->command_queue);
2625
2626 hc_clFinish (data.ocl, device_param->command_queue);
2627 }
2628
2629 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2630 {
2631 int rc = -1;
2632
2633 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2634 {
2635 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2636
2637 const cl_uchar zero = 0;
2638
2639 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2640 }
2641
2642 if (rc != 0)
2643 {
2644 // NOTE: clEnqueueFillBuffer () always fails with -59
2645 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2646 // How's that possible, OpenCL 1.2 support is advertised??
2647 // We need to workaround...
2648
2649 #define FILLSZ 0x100000
2650
2651 char *tmp = (char *) mymalloc (FILLSZ);
2652
2653 for (size_t i = 0; i < size; i += FILLSZ)
2654 {
2655 const size_t left = size - i;
2656
2657 const size_t fillsz = MIN (FILLSZ, left);
2658
2659 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2660 }
2661
2662 myfree (tmp);
2663 }
2664 }
2665
2666 static void choose_kernel (hc_device_param_t *device_param, const uint attack_exec, const uint attack_mode, const uint opts_type, const salt_t *salt_buf, const uint highest_pw_len, const uint pws_cnt)
2667 {
2668 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2669 {
2670 if (attack_mode == ATTACK_MODE_BF)
2671 {
2672 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2673 {
2674 const uint size_tm = 32 * sizeof (bs_word_t);
2675
2676 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2677
2678 run_kernel_tm (device_param);
2679
2680 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2681 }
2682 }
2683
2684 if (highest_pw_len < 16)
2685 {
2686 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2687 }
2688 else if (highest_pw_len < 32)
2689 {
2690 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2691 }
2692 else
2693 {
2694 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2695 }
2696 }
2697 else
2698 {
2699 run_kernel_amp (device_param, pws_cnt);
2700
2701 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2702
2703 if (opts_type & OPTS_TYPE_HOOK12)
2704 {
2705 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2706 }
2707
2708 uint iter = salt_buf->salt_iter;
2709
2710 uint loop_step = device_param->kernel_loops;
2711
2712 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2713 {
2714 uint loop_left = iter - loop_pos;
2715
2716 loop_left = MIN (loop_left, loop_step);
2717
2718 device_param->kernel_params_buf32[25] = loop_pos;
2719 device_param->kernel_params_buf32[26] = loop_left;
2720
2721 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2722
2723 if (data.devices_status == STATUS_CRACKED) break;
2724 if (data.devices_status == STATUS_ABORTED) break;
2725 if (data.devices_status == STATUS_QUIT) break;
2726
2727 /**
2728 * speed
2729 */
2730
2731 const float iter_part = (float) (loop_pos + loop_left) / iter;
2732
2733 const u64 perf_sum_all = pws_cnt * iter_part;
2734
2735 double speed_ms;
2736
2737 hc_timer_get (device_param->timer_speed, speed_ms);
2738
2739 const u32 speed_pos = device_param->speed_pos;
2740
2741 device_param->speed_cnt[speed_pos] = perf_sum_all;
2742
2743 device_param->speed_ms[speed_pos] = speed_ms;
2744
2745 if (data.benchmark == 1)
2746 {
2747 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2748 }
2749 }
2750
2751 if (opts_type & OPTS_TYPE_HOOK23)
2752 {
2753 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2754
2755 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2756
2757 // do something with data
2758
2759 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2760 }
2761
2762 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2763 }
2764 }
2765
2766 static int run_rule_engine (const int rule_len, const char *rule_buf)
2767 {
2768 if (rule_len == 0)
2769 {
2770 return 0;
2771 }
2772 else if (rule_len == 1)
2773 {
2774 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2775 }
2776
2777 return 1;
2778 }
2779
2780 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2781 {
2782 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2783 {
2784 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2785 }
2786 else if (data.attack_kern == ATTACK_KERN_COMBI)
2787 {
2788 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2789 {
2790 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2791 {
2792 for (u32 i = 0; i < pws_cnt; i++)
2793 {
2794 const u32 pw_len = device_param->pws_buf[i].pw_len;
2795
2796 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2797
2798 ptr[pw_len] = 0x01;
2799 }
2800 }
2801 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2802 {
2803 for (u32 i = 0; i < pws_cnt; i++)
2804 {
2805 const u32 pw_len = device_param->pws_buf[i].pw_len;
2806
2807 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2808
2809 ptr[pw_len] = 0x80;
2810 }
2811 }
2812 }
2813
2814 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2815 }
2816 else if (data.attack_kern == ATTACK_KERN_BF)
2817 {
2818 const u64 off = device_param->words_off;
2819
2820 device_param->kernel_params_mp_l_buf64[3] = off;
2821
2822 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2823 }
2824 }
2825
2826 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2827 {
2828 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2829
2830 device_param->kernel_params_buf32[25] = 0;
2831 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2832 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2833
2834 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2835 {
2836 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2837 }
2838 else
2839 {
2840 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2841 }
2842
2843 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2844
2845 return exec_ms_prev;
2846 }
2847
2848 static void autotune (hc_device_param_t *device_param)
2849 {
2850 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2851
2852 const u32 kernel_accel_min = device_param->kernel_accel_min;
2853 const u32 kernel_accel_max = device_param->kernel_accel_max;
2854
2855 const u32 kernel_loops_min = device_param->kernel_loops_min;
2856 const u32 kernel_loops_max = device_param->kernel_loops_max;
2857
2858 u32 kernel_accel = kernel_accel_min;
2859 u32 kernel_loops = kernel_loops_min;
2860
2861 // init some fake words
2862
2863 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2864
2865 for (u32 i = 0; i < kernel_power_max; i++)
2866 {
2867 device_param->pws_buf[i].i[0] = i;
2868 device_param->pws_buf[i].i[1] = 0x01234567;
2869 device_param->pws_buf[i].pw_len = 7;
2870 }
2871
2872 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2873
2874 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2875 {
2876 run_kernel_amp (device_param, kernel_power_max);
2877 }
2878
2879 // begin actual testing
2880
2881 double exec_ms_final = try_run (device_param, kernel_accel, kernel_loops);
2882
2883 if ((kernel_loops_min == kernel_loops_max) || (kernel_accel_min == kernel_accel_max))
2884 {
2885 // we do this in case the user specified a fixed -u and -n on the commandline
2886 // so we have a cached kernel for benchmark
2887
2888 try_run (device_param, kernel_accel, kernel_loops);
2889 try_run (device_param, kernel_accel, kernel_loops);
2890 try_run (device_param, kernel_accel, kernel_loops);
2891 try_run (device_param, kernel_accel, kernel_loops);
2892 try_run (device_param, kernel_accel, kernel_loops);
2893 }
2894
2895 // first find out highest kernel-loops that stays below target_ms
2896
2897 #define STEPS_CNT 10
2898
2899 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
2900 {
2901 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
2902
2903 if (exec_ms < target_ms) break;
2904 }
2905
2906 // now the same for kernel-accel but with the new kernel-loops from previous loop set
2907
2908 if (kernel_accel_min < kernel_accel_max)
2909 {
2910 for (int i = 0; i < STEPS_CNT; i++)
2911 {
2912 const u32 kernel_accel_try = 1 << i;
2913
2914 if (kernel_accel_try < kernel_accel_min) continue;
2915 if (kernel_accel_try > kernel_accel_max) break;
2916
2917 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
2918
2919 if (exec_ms > target_ms) break;
2920
2921 exec_ms_final = exec_ms;
2922
2923 kernel_accel = kernel_accel_try;
2924 }
2925 }
2926
2927 // there's a chance that we have a fixed kernel_loops but not a fixed kernel_accel
2928 // in such a case the above function would not create any change
2929 // we'll use the runtime to find out if we're allow to do last improvement
2930
2931 if (exec_ms_final > 0)
2932 {
2933 if ((exec_ms_final * 2) <= target_ms)
2934 {
2935 const double exec_left = target_ms / exec_ms_final;
2936
2937 const double accel_left = kernel_accel_max / kernel_accel;
2938
2939 const int exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
2940
2941 if (exec_accel_min >= 2)
2942 {
2943 kernel_accel *= exec_accel_min;
2944 }
2945 }
2946 }
2947
2948 // balancing the workload turns out to be very efficient
2949
2950 if (kernel_loops_min != kernel_loops_max)
2951 {
2952 const u32 kernel_power_balance = kernel_accel * kernel_loops;
2953
2954 u32 sqrtv;
2955
2956 for (sqrtv = 1; sqrtv < 0x100000; sqrtv++)
2957 {
2958 if ((sqrtv * sqrtv) >= kernel_power_balance) break;
2959 }
2960
2961 const u32 kernel_accel_try = sqrtv;
2962 const u32 kernel_loops_try = sqrtv;
2963
2964 if ((kernel_accel_try <= kernel_accel_max) && (kernel_loops_try >= kernel_loops_min))
2965 {
2966 kernel_accel = kernel_accel_try;
2967 kernel_loops = kernel_loops_try;
2968 }
2969 }
2970
2971 // reset fake words
2972
2973 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
2974
2975 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2976 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_amp_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2977
2978 // reset timer
2979
2980 device_param->exec_pos = 0;
2981
2982 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
2983
2984 // store
2985
2986 device_param->kernel_accel = kernel_accel;
2987 device_param->kernel_loops = kernel_loops;
2988
2989 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2990
2991 device_param->kernel_power = kernel_power;
2992
2993 #ifdef DEBUG
2994
2995 if (data.quiet == 0)
2996 {
2997 clear_prompt ();
2998
2999 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3000 "Device #%u: autotuned kernel-loops to %u\n",
3001 device_param->device_id + 1, kernel_accel,
3002 device_param->device_id + 1, kernel_loops);
3003
3004 fprintf (stdout, "%s", PROMPT);
3005
3006 fflush (stdout);
3007 }
3008
3009 #endif
3010 }
3011
3012 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3013 {
3014 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3015
3016 // init speed timer
3017
3018 uint speed_pos = device_param->speed_pos;
3019
3020 #ifdef _POSIX
3021 if (device_param->timer_speed.tv_sec == 0)
3022 {
3023 hc_timer_set (&device_param->timer_speed);
3024 }
3025 #endif
3026
3027 #ifdef _WIN
3028 if (device_param->timer_speed.QuadPart == 0)
3029 {
3030 hc_timer_set (&device_param->timer_speed);
3031 }
3032 #endif
3033
3034 // find higest password length, this is for optimization stuff
3035
3036 uint highest_pw_len = 0;
3037
3038 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3039 {
3040 }
3041 else if (data.attack_kern == ATTACK_KERN_COMBI)
3042 {
3043 }
3044 else if (data.attack_kern == ATTACK_KERN_BF)
3045 {
3046 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3047 + device_param->kernel_params_mp_l_buf32[5];
3048 }
3049
3050 // iteration type
3051
3052 uint innerloop_step = 0;
3053 uint innerloop_cnt = 0;
3054
3055 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3056 else innerloop_step = 1;
3057
3058 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3059 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3060 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3061
3062 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3063
3064 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3065 {
3066 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3067
3068 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3069
3070 if (data.devices_status == STATUS_CRACKED) break;
3071 if (data.devices_status == STATUS_ABORTED) break;
3072 if (data.devices_status == STATUS_QUIT) break;
3073 if (data.devices_status == STATUS_BYPASS) break;
3074
3075 salt_t *salt_buf = &data.salts_buf[salt_pos];
3076
3077 device_param->kernel_params_buf32[24] = salt_pos;
3078 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3079 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3080
3081 FILE *combs_fp = device_param->combs_fp;
3082
3083 if (data.attack_mode == ATTACK_MODE_COMBI)
3084 {
3085 rewind (combs_fp);
3086 }
3087
3088 // innerloops
3089
3090 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3091 {
3092 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3093
3094 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3095
3096 if (data.devices_status == STATUS_CRACKED) break;
3097 if (data.devices_status == STATUS_ABORTED) break;
3098 if (data.devices_status == STATUS_QUIT) break;
3099 if (data.devices_status == STATUS_BYPASS) break;
3100
3101 uint innerloop_left = innerloop_cnt - innerloop_pos;
3102
3103 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3104
3105 device_param->innerloop_pos = innerloop_pos;
3106 device_param->innerloop_left = innerloop_left;
3107
3108 device_param->kernel_params_buf32[27] = innerloop_left;
3109
3110 // i think we can get rid of this
3111 if (innerloop_left == 0)
3112 {
3113 puts ("bug, how should this happen????\n");
3114
3115 continue;
3116 }
3117
3118 if (data.salts_shown[salt_pos] == 1)
3119 {
3120 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3121
3122 continue;
3123 }
3124
3125 // initialize amplifiers
3126
3127 if (data.attack_mode == ATTACK_MODE_COMBI)
3128 {
3129 uint i = 0;
3130
3131 while (i < innerloop_left)
3132 {
3133 if (feof (combs_fp)) break;
3134
3135 int line_len = fgetl (combs_fp, line_buf);
3136
3137 if (line_len >= PW_MAX1) continue;
3138
3139 line_len = convert_from_hex (line_buf, line_len);
3140
3141 char *line_buf_new = line_buf;
3142
3143 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3144 {
3145 char rule_buf_out[BLOCK_SIZE] = { 0 };
3146
3147 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3148
3149 if (rule_len_out < 0)
3150 {
3151 data.words_progress_rejected[salt_pos] += pws_cnt;
3152
3153 continue;
3154 }
3155
3156 line_len = rule_len_out;
3157
3158 line_buf_new = rule_buf_out;
3159 }
3160
3161 line_len = MIN (line_len, PW_DICTMAX);
3162
3163 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3164
3165 memcpy (ptr, line_buf_new, line_len);
3166
3167 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3168
3169 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3170 {
3171 uppercase (ptr, line_len);
3172 }
3173
3174 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3175 {
3176 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3177 {
3178 ptr[line_len] = 0x80;
3179 }
3180
3181 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3182 {
3183 ptr[line_len] = 0x01;
3184 }
3185 }
3186
3187 device_param->combs_buf[i].pw_len = line_len;
3188
3189 i++;
3190 }
3191
3192 for (uint j = i; j < innerloop_left; j++)
3193 {
3194 device_param->combs_buf[j].i[0] = 0;
3195 device_param->combs_buf[j].i[1] = 0;
3196 device_param->combs_buf[j].i[2] = 0;
3197 device_param->combs_buf[j].i[3] = 0;
3198 device_param->combs_buf[j].i[4] = 0;
3199 device_param->combs_buf[j].i[5] = 0;
3200 device_param->combs_buf[j].i[6] = 0;
3201 device_param->combs_buf[j].i[7] = 0;
3202
3203 device_param->combs_buf[j].pw_len = 0;
3204 }
3205
3206 innerloop_left = i;
3207 }
3208 else if (data.attack_mode == ATTACK_MODE_BF)
3209 {
3210 u64 off = innerloop_pos;
3211
3212 device_param->kernel_params_mp_r_buf64[3] = off;
3213
3214 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3215 }
3216 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3217 {
3218 u64 off = innerloop_pos;
3219
3220 device_param->kernel_params_mp_buf64[3] = off;
3221
3222 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3223 }
3224 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3225 {
3226 u64 off = innerloop_pos;
3227
3228 device_param->kernel_params_mp_buf64[3] = off;
3229
3230 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3231 }
3232
3233 // copy amplifiers
3234
3235 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3236 {
3237 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, innerloop_pos * sizeof (kernel_rule_t), 0, innerloop_left * sizeof (kernel_rule_t), 0, NULL, NULL);
3238 }
3239 else if (data.attack_mode == ATTACK_MODE_COMBI)
3240 {
3241 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_combs_c, CL_TRUE, 0, innerloop_left * sizeof (comb_t), device_param->combs_buf, 0, NULL, NULL);
3242 }
3243 else if (data.attack_mode == ATTACK_MODE_BF)
3244 {
3245 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_bfs, device_param->d_bfs_c, 0, 0, innerloop_left * sizeof (bf_t), 0, NULL, NULL);
3246 }
3247 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3248 {
3249 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3250 }
3251 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3252 {
3253 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3254 }
3255
3256 if (data.benchmark == 1)
3257 {
3258 hc_timer_set (&device_param->timer_speed);
3259 }
3260
3261 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3262
3263 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3264
3265 if (data.devices_status == STATUS_CRACKED) break;
3266 if (data.devices_status == STATUS_ABORTED) break;
3267 if (data.devices_status == STATUS_QUIT) break;
3268
3269 /**
3270 * result
3271 */
3272
3273 hc_thread_mutex_lock (mux_display);
3274
3275 check_cracked (device_param, salt_pos);
3276
3277 hc_thread_mutex_unlock (mux_display);
3278
3279 /**
3280 * progress
3281 */
3282
3283 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3284
3285 hc_thread_mutex_lock (mux_counter);
3286
3287 data.words_progress_done[salt_pos] += perf_sum_all;
3288
3289 hc_thread_mutex_unlock (mux_counter);
3290
3291 /**
3292 * speed
3293 */
3294
3295 double speed_ms;
3296
3297 hc_timer_get (device_param->timer_speed, speed_ms);
3298
3299 hc_timer_set (&device_param->timer_speed);
3300
3301 hc_thread_mutex_lock (mux_display);
3302
3303 // current speed
3304
3305 device_param->speed_cnt[speed_pos] = perf_sum_all;
3306
3307 device_param->speed_ms[speed_pos] = speed_ms;
3308
3309 hc_thread_mutex_unlock (mux_display);
3310
3311 speed_pos++;
3312
3313 if (speed_pos == SPEED_CACHE)
3314 {
3315 speed_pos = 0;
3316 }
3317
3318 /**
3319 * benchmark
3320 */
3321
3322 if (data.benchmark == 1) break;
3323 }
3324 }
3325
3326 device_param->speed_pos = speed_pos;
3327
3328 myfree (line_buf);
3329 }
3330
3331 static void load_segment (wl_data_t *wl_data, FILE *fd)
3332 {
3333 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3334
3335 wl_data->pos = 0;
3336
3337 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3338
3339 wl_data->buf[wl_data->cnt] = 0;
3340
3341 if (wl_data->cnt == 0) return;
3342
3343 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3344
3345 while (!feof (fd))
3346 {
3347 if (wl_data->cnt == wl_data->avail)
3348 {
3349 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3350
3351 wl_data->avail += wl_data->incr;
3352 }
3353
3354 const int c = fgetc (fd);
3355
3356 if (c == EOF) break;
3357
3358 wl_data->buf[wl_data->cnt] = (char) c;
3359
3360 wl_data->cnt++;
3361
3362 if (c == '\n') break;
3363 }
3364
3365 // ensure stream ends with a newline
3366
3367 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3368 {
3369 wl_data->cnt++;
3370
3371 wl_data->buf[wl_data->cnt - 1] = '\n';
3372 }
3373
3374 return;
3375 }
3376
3377 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3378 {
3379 char *ptr = buf;
3380
3381 for (u32 i = 0; i < sz; i++, ptr++)
3382 {
3383 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3384
3385 if (i == 7)
3386 {
3387 *off = i;
3388 *len = i;
3389
3390 return;
3391 }
3392
3393 if (*ptr != '\n') continue;
3394
3395 *off = i + 1;
3396
3397 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3398
3399 *len = i;
3400
3401 return;
3402 }
3403
3404 *off = sz;
3405 *len = sz;
3406 }
3407
3408 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3409 {
3410 char *ptr = buf;
3411
3412 for (u32 i = 0; i < sz; i++, ptr++)
3413 {
3414 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3415
3416 if (*ptr != '\n') continue;
3417
3418 *off = i + 1;
3419
3420 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3421
3422 *len = i;
3423
3424 return;
3425 }
3426
3427 *off = sz;
3428 *len = sz;
3429 }
3430
3431 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3432 {
3433 char *ptr = buf;
3434
3435 for (u32 i = 0; i < sz; i++, ptr++)
3436 {
3437 if (*ptr != '\n') continue;
3438
3439 *off = i + 1;
3440
3441 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3442
3443 *len = i;
3444
3445 return;
3446 }
3447
3448 *off = sz;
3449 *len = sz;
3450 }
3451
3452 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3453 {
3454 while (wl_data->pos < wl_data->cnt)
3455 {
3456 uint off;
3457 uint len;
3458
3459 char *ptr = wl_data->buf + wl_data->pos;
3460
3461 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3462
3463 wl_data->pos += off;
3464
3465 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3466 {
3467 char rule_buf_out[BLOCK_SIZE] = { 0 };
3468
3469 int rule_len_out = -1;
3470
3471 if (len < BLOCK_SIZE)
3472 {
3473 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3474 }
3475
3476 if (rule_len_out < 0)
3477 {
3478 continue;
3479 }
3480
3481 if (rule_len_out > PW_MAX)
3482 {
3483 continue;
3484 }
3485 }
3486 else
3487 {
3488 if (len > PW_MAX)
3489 {
3490 continue;
3491 }
3492 }
3493
3494 *out_buf = ptr;
3495 *out_len = len;
3496
3497 return;
3498 }
3499
3500 if (feof (fd))
3501 {
3502 fprintf (stderr, "BUG feof()!!\n");
3503
3504 return;
3505 }
3506
3507 load_segment (wl_data, fd);
3508
3509 get_next_word (wl_data, fd, out_buf, out_len);
3510 }
3511
3512 #ifdef _POSIX
3513 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3514 #endif
3515
3516 #ifdef _WIN
3517 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3518 #endif
3519 {
3520 hc_signal (NULL);
3521
3522 dictstat_t d;
3523
3524 d.cnt = 0;
3525
3526 #ifdef _POSIX
3527 fstat (fileno (fd), &d.stat);
3528 #endif
3529
3530 #ifdef _WIN
3531 _fstat64 (fileno (fd), &d.stat);
3532 #endif
3533
3534 d.stat.st_mode = 0;
3535 d.stat.st_nlink = 0;
3536 d.stat.st_uid = 0;
3537 d.stat.st_gid = 0;
3538 d.stat.st_rdev = 0;
3539 d.stat.st_atime = 0;
3540
3541 #ifdef _POSIX
3542 d.stat.st_blksize = 0;
3543 d.stat.st_blocks = 0;
3544 #endif
3545
3546 if (d.stat.st_size == 0) return 0;
3547
3548 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3549
3550 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3551 {
3552 if (d_cache)
3553 {
3554 u64 cnt = d_cache->cnt;
3555
3556 u64 keyspace = cnt;
3557
3558 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3559 {
3560 keyspace *= data.kernel_rules_cnt;
3561 }
3562 else if (data.attack_kern == ATTACK_KERN_COMBI)
3563 {
3564 keyspace *= data.combs_cnt;
3565 }
3566
3567 if (data.quiet == 0) log_info ("Cache-hit dictionary stats %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) d.stat.st_size, (unsigned long long int) cnt, (unsigned long long int) keyspace);
3568 if (data.quiet == 0) log_info ("");
3569
3570 hc_signal (sigHandler_default);
3571
3572 return (keyspace);
3573 }
3574 }
3575
3576 time_t now = 0;
3577 time_t prev = 0;
3578
3579 u64 comp = 0;
3580 u64 cnt = 0;
3581 u64 cnt2 = 0;
3582
3583 while (!feof (fd))
3584 {
3585 load_segment (wl_data, fd);
3586
3587 comp += wl_data->cnt;
3588
3589 u32 i = 0;
3590
3591 while (i < wl_data->cnt)
3592 {
3593 u32 len;
3594 u32 off;
3595
3596 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3597
3598 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3599 {
3600 char rule_buf_out[BLOCK_SIZE] = { 0 };
3601
3602 int rule_len_out = -1;
3603
3604 if (len < BLOCK_SIZE)
3605 {
3606 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3607 }
3608
3609 if (rule_len_out < 0)
3610 {
3611 len = PW_MAX1;
3612 }
3613 else
3614 {
3615 len = rule_len_out;
3616 }
3617 }
3618
3619 if (len < PW_MAX1)
3620 {
3621 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3622 {
3623 cnt += data.kernel_rules_cnt;
3624 }
3625 else if (data.attack_kern == ATTACK_KERN_COMBI)
3626 {
3627 cnt += data.combs_cnt;
3628 }
3629
3630 d.cnt++;
3631 }
3632
3633 i += off;
3634
3635 cnt2++;
3636 }
3637
3638 time (&now);
3639
3640 if ((now - prev) == 0) continue;
3641
3642 float percent = (float) comp / (float) d.stat.st_size;
3643
3644 if (data.quiet == 0) log_info_nn ("Generating dictionary stats for %s: %llu bytes (%.2f%%), %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, percent * 100, (unsigned long long int) cnt2, (unsigned long long int) cnt);
3645
3646 time (&prev);
3647 }
3648
3649 if (data.quiet == 0) log_info ("Generated dictionary stats for %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, (unsigned long long int) cnt2, (unsigned long long int) cnt);
3650 if (data.quiet == 0) log_info ("");
3651
3652 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3653
3654 hc_signal (sigHandler_default);
3655
3656 return (cnt);
3657 }
3658
3659 static void *thread_monitor (void *p)
3660 {
3661 uint runtime_check = 0;
3662 uint remove_check = 0;
3663 uint status_check = 0;
3664 uint restore_check = 0;
3665
3666 uint restore_left = data.restore_timer;
3667 uint remove_left = data.remove_timer;
3668 uint status_left = data.status_timer;
3669
3670 #ifdef HAVE_HWMON
3671 uint hwmon_check = 0;
3672
3673 // these variables are mainly used for fan control (AMD only)
3674
3675 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3676
3677 // temperature controller "loopback" values
3678
3679 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3680 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3681
3682 #ifdef HAVE_ADL
3683 int temp_threshold = 1; // degrees celcius
3684
3685 int fan_speed_min = 15; // in percentage
3686 int fan_speed_max = 100;
3687 #endif // HAVE_ADL
3688
3689 time_t last_temp_check_time;
3690 #endif // HAVE_HWMON
3691
3692 uint sleep_time = 1;
3693
3694 if (data.runtime)
3695 {
3696 runtime_check = 1;
3697 }
3698
3699 if (data.restore_timer)
3700 {
3701 restore_check = 1;
3702 }
3703
3704 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3705 {
3706 remove_check = 1;
3707 }
3708
3709 if (data.status == 1)
3710 {
3711 status_check = 1;
3712 }
3713
3714 #ifdef HAVE_HWMON
3715 if (data.gpu_temp_disable == 0)
3716 {
3717 time (&last_temp_check_time);
3718
3719 hwmon_check = 1;
3720 }
3721 #endif
3722
3723 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3724 {
3725 #ifdef HAVE_HWMON
3726 if (hwmon_check == 0)
3727 #endif
3728 return (p);
3729 }
3730
3731 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3732 {
3733 hc_sleep (sleep_time);
3734
3735 if (data.devices_status != STATUS_RUNNING) continue;
3736
3737 #ifdef HAVE_HWMON
3738 if (hwmon_check == 1)
3739 {
3740 hc_thread_mutex_lock (mux_adl);
3741
3742 time_t temp_check_time;
3743
3744 time (&temp_check_time);
3745
3746 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3747
3748 if (Ta == 0) Ta = 1;
3749
3750 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3751 {
3752 hc_device_param_t *device_param = &data.devices_param[device_id];
3753
3754 if (device_param->skipped) continue;
3755
3756 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3757
3758 const int temperature = hm_get_temperature_with_device_id (device_id);
3759
3760 if (temperature > (int) data.gpu_temp_abort)
3761 {
3762 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3763
3764 if (data.devices_status != STATUS_QUIT) myabort ();
3765
3766 break;
3767 }
3768
3769 #ifdef HAVE_ADL
3770 const int gpu_temp_retain = data.gpu_temp_retain;
3771
3772 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3773 {
3774 if (data.hm_device[device_id].fan_supported == 1)
3775 {
3776 int temp_cur = temperature;
3777
3778 int temp_diff_new = gpu_temp_retain - temp_cur;
3779
3780 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3781
3782 // calculate Ta value (time difference in seconds between the last check and this check)
3783
3784 last_temp_check_time = temp_check_time;
3785
3786 float Kp = 1.8;
3787 float Ki = 0.005;
3788 float Kd = 6;
3789
3790 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3791
3792 int fan_diff_required = (int) (Kp * (float)temp_diff_new + Ki * Ta * (float)temp_diff_sum[device_id] + Kd * ((float)(temp_diff_new - temp_diff_old[device_id])) / Ta);
3793
3794 if (abs (fan_diff_required) >= temp_threshold)
3795 {
3796 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3797
3798 int fan_speed_level = fan_speed_cur;
3799
3800 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3801
3802 int fan_speed_new = fan_speed_level - fan_diff_required;
3803
3804 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3805 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3806
3807 if (fan_speed_new != fan_speed_cur)
3808 {
3809 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3810 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3811
3812 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3813 {
3814 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3815
3816 fan_speed_chgd[device_id] = 1;
3817 }
3818
3819 temp_diff_old[device_id] = temp_diff_new;
3820 }
3821 }
3822 }
3823 }
3824 #endif // HAVE_ADL
3825 }
3826
3827 hc_thread_mutex_unlock (mux_adl);
3828 }
3829 #endif // HAVE_HWMON
3830
3831 if (restore_check == 1)
3832 {
3833 restore_left--;
3834
3835 if (restore_left == 0)
3836 {
3837 if (data.restore_disable == 0) cycle_restore ();
3838
3839 restore_left = data.restore_timer;
3840 }
3841 }
3842
3843 if ((runtime_check == 1) && (data.runtime_start > 0))
3844 {
3845 time_t runtime_cur;
3846
3847 time (&runtime_cur);
3848
3849 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3850
3851 if (runtime_left <= 0)
3852 {
3853 if (data.benchmark == 0)
3854 {
3855 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3856 }
3857
3858 if (data.devices_status != STATUS_QUIT) myabort ();
3859 }
3860 }
3861
3862 if (remove_check == 1)
3863 {
3864 remove_left--;
3865
3866 if (remove_left == 0)
3867 {
3868 if (data.digests_saved != data.digests_done)
3869 {
3870 data.digests_saved = data.digests_done;
3871
3872 save_hash ();
3873 }
3874
3875 remove_left = data.remove_timer;
3876 }
3877 }
3878
3879 if (status_check == 1)
3880 {
3881 status_left--;
3882
3883 if (status_left == 0)
3884 {
3885 hc_thread_mutex_lock (mux_display);
3886
3887 if (data.quiet == 0) clear_prompt ();
3888
3889 if (data.quiet == 0) log_info ("");
3890
3891 status_display ();
3892
3893 if (data.quiet == 0) log_info ("");
3894
3895 hc_thread_mutex_unlock (mux_display);
3896
3897 status_left = data.status_timer;
3898 }
3899 }
3900 }
3901
3902 #ifdef HAVE_HWMON
3903 myfree (fan_speed_chgd);
3904
3905 myfree (temp_diff_old);
3906 myfree (temp_diff_sum);
3907 #endif
3908
3909 p = NULL;
3910
3911 return (p);
3912 }
3913
3914 static void *thread_outfile_remove (void *p)
3915 {
3916 // some hash-dependent constants
3917 char *outfile_dir = data.outfile_check_directory;
3918 uint dgst_size = data.dgst_size;
3919 uint isSalted = data.isSalted;
3920 uint esalt_size = data.esalt_size;
3921 uint hash_mode = data.hash_mode;
3922
3923 uint outfile_check_timer = data.outfile_check_timer;
3924
3925 char separator = data.separator;
3926
3927 // some hash-dependent functions
3928 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3929 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3930
3931 // buffers
3932 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3933
3934 hash_buf.digest = mymalloc (dgst_size);
3935
3936 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3937
3938 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3939
3940 uint digest_buf[64] = { 0 };
3941
3942 outfile_data_t *out_info = NULL;
3943
3944 char **out_files = NULL;
3945
3946 time_t folder_mtime = 0;
3947
3948 int out_cnt = 0;
3949
3950 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3951
3952 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3953 {
3954 hc_sleep (1);
3955
3956 if (data.devices_status != STATUS_RUNNING) continue;
3957
3958 check_left--;
3959
3960 if (check_left == 0)
3961 {
3962 struct stat outfile_check_stat;
3963
3964 if (stat (outfile_dir, &outfile_check_stat) == 0)
3965 {
3966 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3967
3968 if (is_dir == 1)
3969 {
3970 if (outfile_check_stat.st_mtime > folder_mtime)
3971 {
3972 char **out_files_new = scan_directory (outfile_dir);
3973
3974 int out_cnt_new = count_dictionaries (out_files_new);
3975
3976 outfile_data_t *out_info_new = NULL;
3977
3978 if (out_cnt_new > 0)
3979 {
3980 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3981
3982 for (int i = 0; i < out_cnt_new; i++)
3983 {
3984 out_info_new[i].file_name = out_files_new[i];
3985
3986 // check if there are files that we have seen/checked before (and not changed)
3987
3988 for (int j = 0; j < out_cnt; j++)
3989 {
3990 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3991 {
3992 struct stat outfile_stat;
3993
3994 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3995 {
3996 if (outfile_stat.st_ctime == out_info[j].ctime)
3997 {
3998 out_info_new[i].ctime = out_info[j].ctime;
3999 out_info_new[i].seek = out_info[j].seek;
4000 }
4001 }
4002 }
4003 }
4004 }
4005 }
4006
4007 local_free (out_info);
4008 local_free (out_files);
4009
4010 out_files = out_files_new;
4011 out_cnt = out_cnt_new;
4012 out_info = out_info_new;
4013
4014 folder_mtime = outfile_check_stat.st_mtime;
4015 }
4016
4017 for (int j = 0; j < out_cnt; j++)
4018 {
4019 FILE *fp = fopen (out_info[j].file_name, "rb");
4020
4021 if (fp != NULL)
4022 {
4023 //hc_thread_mutex_lock (mux_display);
4024
4025 #ifdef _POSIX
4026 struct stat outfile_stat;
4027
4028 fstat (fileno (fp), &outfile_stat);
4029 #endif
4030
4031 #ifdef _WIN
4032 struct stat64 outfile_stat;
4033
4034 _fstat64 (fileno (fp), &outfile_stat);
4035 #endif
4036
4037 if (outfile_stat.st_ctime > out_info[j].ctime)
4038 {
4039 out_info[j].ctime = outfile_stat.st_ctime;
4040 out_info[j].seek = 0;
4041 }
4042
4043 fseek (fp, out_info[j].seek, SEEK_SET);
4044
4045 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4046
4047 while (!feof (fp))
4048 {
4049 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4050
4051 if (ptr == NULL) break;
4052
4053 int line_len = strlen (line_buf);
4054
4055 if (line_len <= 0) continue;
4056
4057 int iter = MAX_CUT_TRIES;
4058
4059 for (uint i = line_len - 1; i && iter; i--, line_len--)
4060 {
4061 if (line_buf[i] != separator) continue;
4062
4063 int parser_status = PARSER_OK;
4064
4065 if ((hash_mode != 2500) && (hash_mode != 6800))
4066 {
4067 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4068 }
4069
4070 uint found = 0;
4071
4072 if (parser_status == PARSER_OK)
4073 {
4074 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4075 {
4076 if (data.salts_shown[salt_pos] == 1) continue;
4077
4078 salt_t *salt_buf = &data.salts_buf[salt_pos];
4079
4080 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4081 {
4082 uint idx = salt_buf->digests_offset + digest_pos;
4083
4084 if (data.digests_shown[idx] == 1) continue;
4085
4086 uint cracked = 0;
4087
4088 if (hash_mode == 6800)
4089 {
4090 if (i == salt_buf->salt_len)
4091 {
4092 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4093 }
4094 }
4095 else if (hash_mode == 2500)
4096 {
4097 // BSSID : MAC1 : MAC2 (:plain)
4098 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4099 {
4100 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4101
4102 if (!cracked) continue;
4103
4104 // now compare MAC1 and MAC2 too, since we have this additional info
4105 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4106 char *mac2_pos = mac1_pos + 12 + 1;
4107
4108 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4109 wpa_t *wpa = &wpas[salt_pos];
4110
4111 // compare hex string(s) vs binary MAC address(es)
4112
4113 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4114 {
4115 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4116 {
4117 cracked = 0;
4118
4119 break;
4120 }
4121 }
4122
4123 // early skip ;)
4124 if (!cracked) continue;
4125
4126 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4127 {
4128 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4129 {
4130 cracked = 0;
4131
4132 break;
4133 }
4134 }
4135 }
4136 }
4137 else
4138 {
4139 char *digests_buf_ptr = (char *) data.digests_buf;
4140
4141 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4142
4143 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4144 }
4145
4146 if (cracked == 1)
4147 {
4148 found = 1;
4149
4150 data.digests_shown[idx] = 1;
4151
4152 data.digests_done++;
4153
4154 salt_buf->digests_done++;
4155
4156 if (salt_buf->digests_done == salt_buf->digests_cnt)
4157 {
4158 data.salts_shown[salt_pos] = 1;
4159
4160 data.salts_done++;
4161
4162 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4163 }
4164 }
4165 }
4166
4167 if (data.devices_status == STATUS_CRACKED) break;
4168 }
4169 }
4170
4171 if (found) break;
4172
4173 if (data.devices_status == STATUS_CRACKED) break;
4174
4175 iter--;
4176 }
4177
4178 if (data.devices_status == STATUS_CRACKED) break;
4179 }
4180
4181 myfree (line_buf);
4182
4183 out_info[j].seek = ftell (fp);
4184
4185 //hc_thread_mutex_unlock (mux_display);
4186
4187 fclose (fp);
4188 }
4189 }
4190 }
4191 }
4192
4193 check_left = outfile_check_timer;
4194 }
4195 }
4196
4197 if (esalt_size) local_free (hash_buf.esalt);
4198
4199 if (isSalted) local_free (hash_buf.salt);
4200
4201 local_free (hash_buf.digest);
4202
4203 local_free (out_info);
4204
4205 local_free (out_files);
4206
4207 p = NULL;
4208
4209 return (p);
4210 }
4211
4212 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4213 {
4214 if (device_param->pws_cnt < device_param->kernel_power)
4215 {
4216 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4217
4218 u8 *ptr = (u8 *) pw->i;
4219
4220 memcpy (ptr, pw_buf, pw_len);
4221
4222 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4223
4224 pw->pw_len = pw_len;
4225
4226 device_param->pws_cnt++;
4227 }
4228 else
4229 {
4230 fprintf (stderr, "BUG pw_add()!!\n");
4231
4232 return;
4233 }
4234 }
4235
4236 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4237 {
4238 hc_thread_mutex_lock (mux_dispatcher);
4239
4240 const u64 words_cur = data.words_cur;
4241 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4242
4243 device_param->words_off = words_cur;
4244
4245 const u64 words_left = words_base - words_cur;
4246
4247 if (allow_div)
4248 {
4249 if (data.kernel_power_all > words_left)
4250 {
4251 if (data.kernel_power_div == 0)
4252 {
4253 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4254 }
4255 }
4256
4257 if (data.kernel_power_div)
4258 {
4259 if (device_param->kernel_power == device_param->kernel_power_user)
4260 {
4261 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4262
4263 if (kernel_power_new < device_param->kernel_power)
4264 {
4265 device_param->kernel_power = kernel_power_new;
4266 }
4267 }
4268 }
4269 }
4270
4271 const uint kernel_power = device_param->kernel_power;
4272
4273 uint work = MIN (words_left, kernel_power);
4274
4275 work = MIN (work, max);
4276
4277 data.words_cur += work;
4278
4279 hc_thread_mutex_unlock (mux_dispatcher);
4280
4281 return work;
4282 }
4283
4284 static void *thread_calc_stdin (void *p)
4285 {
4286 hc_device_param_t *device_param = (hc_device_param_t *) p;
4287
4288 if (device_param->skipped) return NULL;
4289
4290 autotune (device_param);
4291
4292 char *buf = (char *) mymalloc (HCBUFSIZ);
4293
4294 const uint attack_kern = data.attack_kern;
4295
4296 const uint kernel_power = device_param->kernel_power;
4297
4298 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4299 {
4300 hc_thread_mutex_lock (mux_dispatcher);
4301
4302 if (feof (stdin) != 0)
4303 {
4304 hc_thread_mutex_unlock (mux_dispatcher);
4305
4306 break;
4307 }
4308
4309 uint words_cur = 0;
4310
4311 while (words_cur < kernel_power)
4312 {
4313 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4314
4315 if (line_buf == NULL) break;
4316
4317 uint line_len = in_superchop (line_buf);
4318
4319 line_len = convert_from_hex (line_buf, line_len);
4320
4321 // post-process rule engine
4322
4323 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4324 {
4325 char rule_buf_out[BLOCK_SIZE] = { 0 };
4326
4327 int rule_len_out = -1;
4328
4329 if (line_len < BLOCK_SIZE)
4330 {
4331 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4332 }
4333
4334 if (rule_len_out < 0) continue;
4335
4336 line_buf = rule_buf_out;
4337 line_len = rule_len_out;
4338 }
4339
4340 if (line_len > PW_MAX)
4341 {
4342 continue;
4343 }
4344
4345 if (attack_kern == ATTACK_KERN_STRAIGHT)
4346 {
4347 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4348 {
4349 hc_thread_mutex_lock (mux_counter);
4350
4351 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4352 {
4353 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4354 }
4355
4356 hc_thread_mutex_unlock (mux_counter);
4357
4358 continue;
4359 }
4360 }
4361 else if (attack_kern == ATTACK_KERN_COMBI)
4362 {
4363 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4364 // since we still need to combine the plains
4365
4366 if (line_len > data.pw_max)
4367 {
4368 hc_thread_mutex_lock (mux_counter);
4369
4370 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4371 {
4372 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4373 }
4374
4375 hc_thread_mutex_unlock (mux_counter);
4376
4377 continue;
4378 }
4379 }
4380
4381 pw_add (device_param, (u8 *) line_buf, line_len);
4382
4383 words_cur++;
4384
4385 if (data.devices_status == STATUS_CRACKED) break;
4386 if (data.devices_status == STATUS_ABORTED) break;
4387 if (data.devices_status == STATUS_QUIT) break;
4388 if (data.devices_status == STATUS_BYPASS) break;
4389 }
4390
4391 hc_thread_mutex_unlock (mux_dispatcher);
4392
4393 if (data.devices_status == STATUS_CRACKED) break;
4394 if (data.devices_status == STATUS_ABORTED) break;
4395 if (data.devices_status == STATUS_QUIT) break;
4396 if (data.devices_status == STATUS_BYPASS) break;
4397
4398 // flush
4399
4400 const uint pws_cnt = device_param->pws_cnt;
4401
4402 if (pws_cnt)
4403 {
4404 run_copy (device_param, pws_cnt);
4405
4406 run_cracker (device_param, pws_cnt);
4407
4408 device_param->pws_cnt = 0;
4409
4410 if (attack_kern == ATTACK_KERN_STRAIGHT)
4411 {
4412 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4413 }
4414 else if (attack_kern == ATTACK_KERN_COMBI)
4415 {
4416 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4417 }
4418 }
4419 }
4420
4421 device_param->kernel_accel = 0;
4422 device_param->kernel_loops = 0;
4423
4424 myfree (buf);
4425
4426 return NULL;
4427 }
4428
4429 static void *thread_calc (void *p)
4430 {
4431 hc_device_param_t *device_param = (hc_device_param_t *) p;
4432
4433 if (device_param->skipped) return NULL;
4434
4435 autotune (device_param);
4436
4437 const uint attack_mode = data.attack_mode;
4438 const uint attack_kern = data.attack_kern;
4439
4440 if (attack_mode == ATTACK_MODE_BF)
4441 {
4442 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4443 {
4444 const uint work = get_work (device_param, -1, true);
4445
4446 if (work == 0) break;
4447
4448 const u64 words_off = device_param->words_off;
4449 const u64 words_fin = words_off + work;
4450
4451 const uint pws_cnt = work;
4452
4453 device_param->pws_cnt = pws_cnt;
4454
4455 if (pws_cnt)
4456 {
4457 run_copy (device_param, pws_cnt);
4458
4459 run_cracker (device_param, pws_cnt);
4460
4461 device_param->pws_cnt = 0;
4462
4463 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4464 }
4465
4466 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4467
4468 if (data.devices_status == STATUS_CRACKED) break;
4469 if (data.devices_status == STATUS_ABORTED) break;
4470 if (data.devices_status == STATUS_QUIT) break;
4471 if (data.devices_status == STATUS_BYPASS) break;
4472
4473 if (data.benchmark == 1) break;
4474
4475 device_param->words_done = words_fin;
4476 }
4477 }
4478 else
4479 {
4480 const uint segment_size = data.segment_size;
4481
4482 char *dictfile = data.dictfile;
4483
4484 if (attack_mode == ATTACK_MODE_COMBI)
4485 {
4486 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4487 {
4488 dictfile = data.dictfile2;
4489 }
4490 }
4491
4492 FILE *fd = fopen (dictfile, "rb");
4493
4494 if (fd == NULL)
4495 {
4496 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4497
4498 return NULL;
4499 }
4500
4501 if (attack_mode == ATTACK_MODE_COMBI)
4502 {
4503 const uint combs_mode = data.combs_mode;
4504
4505 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4506 {
4507 const char *dictfilec = data.dictfile2;
4508
4509 FILE *combs_fp = fopen (dictfilec, "rb");
4510
4511 if (combs_fp == NULL)
4512 {
4513 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4514
4515 fclose (fd);
4516
4517 return NULL;
4518 }
4519
4520 device_param->combs_fp = combs_fp;
4521 }
4522 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4523 {
4524 const char *dictfilec = data.dictfile;
4525
4526 FILE *combs_fp = fopen (dictfilec, "rb");
4527
4528 if (combs_fp == NULL)
4529 {
4530 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4531
4532 fclose (fd);
4533
4534 return NULL;
4535 }
4536
4537 device_param->combs_fp = combs_fp;
4538 }
4539 }
4540
4541 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4542
4543 wl_data->buf = (char *) mymalloc (segment_size);
4544 wl_data->avail = segment_size;
4545 wl_data->incr = segment_size;
4546 wl_data->cnt = 0;
4547 wl_data->pos = 0;
4548
4549 u64 words_cur = 0;
4550
4551 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4552 {
4553 u64 words_off = 0;
4554 u64 words_fin = 0;
4555
4556 bool allow_div = true;
4557
4558 u64 max = -1;
4559
4560 while (max)
4561 {
4562 const uint work = get_work (device_param, max, allow_div);
4563
4564 allow_div = false;
4565
4566 if (work == 0) break;
4567
4568 words_off = device_param->words_off;
4569 words_fin = words_off + work;
4570
4571 char *line_buf;
4572 uint line_len;
4573
4574 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4575
4576 max = 0;
4577
4578 for ( ; words_cur < words_fin; words_cur++)
4579 {
4580 get_next_word (wl_data, fd, &line_buf, &line_len);
4581
4582 line_len = convert_from_hex (line_buf, line_len);
4583
4584 // post-process rule engine
4585
4586 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4587 {
4588 char rule_buf_out[BLOCK_SIZE] = { 0 };
4589
4590 int rule_len_out = -1;
4591
4592 if (line_len < BLOCK_SIZE)
4593 {
4594 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4595 }
4596
4597 if (rule_len_out < 0) continue;
4598
4599 line_buf = rule_buf_out;
4600 line_len = rule_len_out;
4601 }
4602
4603 if (attack_kern == ATTACK_KERN_STRAIGHT)
4604 {
4605 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4606 {
4607 max++;
4608
4609 hc_thread_mutex_lock (mux_counter);
4610
4611 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4612 {
4613 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4614 }
4615
4616 hc_thread_mutex_unlock (mux_counter);
4617
4618 continue;
4619 }
4620 }
4621 else if (attack_kern == ATTACK_KERN_COMBI)
4622 {
4623 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4624 // since we still need to combine the plains
4625
4626 if (line_len > data.pw_max)
4627 {
4628 max++;
4629
4630 hc_thread_mutex_lock (mux_counter);
4631
4632 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4633 {
4634 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4635 }
4636
4637 hc_thread_mutex_unlock (mux_counter);
4638
4639 continue;
4640 }
4641 }
4642
4643 pw_add (device_param, (u8 *) line_buf, line_len);
4644
4645 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4646
4647 if (data.devices_status == STATUS_CRACKED) break;
4648 if (data.devices_status == STATUS_ABORTED) break;
4649 if (data.devices_status == STATUS_QUIT) break;
4650 if (data.devices_status == STATUS_BYPASS) break;
4651 }
4652
4653 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4654
4655 if (data.devices_status == STATUS_CRACKED) break;
4656 if (data.devices_status == STATUS_ABORTED) break;
4657 if (data.devices_status == STATUS_QUIT) break;
4658 if (data.devices_status == STATUS_BYPASS) break;
4659 }
4660
4661 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4662
4663 if (data.devices_status == STATUS_CRACKED) break;
4664 if (data.devices_status == STATUS_ABORTED) break;
4665 if (data.devices_status == STATUS_QUIT) break;
4666 if (data.devices_status == STATUS_BYPASS) break;
4667
4668 //
4669 // flush
4670 //
4671
4672 const uint pws_cnt = device_param->pws_cnt;
4673
4674 if (pws_cnt)
4675 {
4676 run_copy (device_param, pws_cnt);
4677
4678 run_cracker (device_param, pws_cnt);
4679
4680 device_param->pws_cnt = 0;
4681
4682 if (attack_kern == ATTACK_KERN_STRAIGHT)
4683 {
4684 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4685 }
4686 else if (attack_kern == ATTACK_KERN_COMBI)
4687 {
4688 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4689 }
4690 }
4691
4692 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4693
4694 if (data.devices_status == STATUS_CRACKED) break;
4695 if (data.devices_status == STATUS_ABORTED) break;
4696 if (data.devices_status == STATUS_QUIT) break;
4697 if (data.devices_status == STATUS_BYPASS) break;
4698
4699 if (words_fin == 0) break;
4700
4701 device_param->words_done = words_fin;
4702 }
4703
4704 if (attack_mode == ATTACK_MODE_COMBI)
4705 {
4706 fclose (device_param->combs_fp);
4707 }
4708
4709 free (wl_data->buf);
4710 free (wl_data);
4711
4712 fclose (fd);
4713 }
4714
4715 device_param->kernel_accel = 0;
4716 device_param->kernel_loops = 0;
4717
4718 return NULL;
4719 }
4720
4721 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4722 {
4723 if (!device_param)
4724 {
4725 log_error ("ERROR: %s : Invalid argument", __func__);
4726
4727 exit (-1);
4728 }
4729
4730 salt_t *salt_buf = &data.salts_buf[salt_pos];
4731
4732 device_param->kernel_params_buf32[24] = salt_pos;
4733 device_param->kernel_params_buf32[27] = 1;
4734 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4735 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4736 device_param->kernel_params_buf32[30] = 0;
4737 device_param->kernel_params_buf32[31] = 1;
4738
4739 char *dictfile_old = data.dictfile;
4740
4741 const char *weak_hash_check = "weak-hash-check";
4742
4743 data.dictfile = (char *) weak_hash_check;
4744
4745 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4746
4747 data.kernel_rules_buf[0].cmds[0] = 0;
4748
4749 /**
4750 * run the kernel
4751 */
4752
4753 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4754 {
4755 run_kernel (KERN_RUN_1, device_param, 1, false);
4756 }
4757 else
4758 {
4759 run_kernel (KERN_RUN_1, device_param, 1, false);
4760
4761 uint loop_step = 16;
4762
4763 const uint iter = salt_buf->salt_iter;
4764
4765 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4766 {
4767 uint loop_left = iter - loop_pos;
4768
4769 loop_left = MIN (loop_left, loop_step);
4770
4771 device_param->kernel_params_buf32[25] = loop_pos;
4772 device_param->kernel_params_buf32[26] = loop_left;
4773
4774 run_kernel (KERN_RUN_2, device_param, 1, false);
4775 }
4776
4777 run_kernel (KERN_RUN_3, device_param, 1, false);
4778 }
4779
4780 /**
4781 * result
4782 */
4783
4784 check_cracked (device_param, salt_pos);
4785
4786 /**
4787 * cleanup
4788 */
4789
4790 device_param->kernel_params_buf32[24] = 0;
4791 device_param->kernel_params_buf32[25] = 0;
4792 device_param->kernel_params_buf32[26] = 0;
4793 device_param->kernel_params_buf32[27] = 0;
4794 device_param->kernel_params_buf32[28] = 0;
4795 device_param->kernel_params_buf32[29] = 0;
4796 device_param->kernel_params_buf32[30] = 0;
4797 device_param->kernel_params_buf32[31] = 0;
4798
4799 data.dictfile = dictfile_old;
4800
4801 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4802 }
4803
4804 // hlfmt hashcat
4805
4806 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4807 {
4808 if (data.username == 0)
4809 {
4810 *hashbuf_pos = line_buf;
4811 *hashbuf_len = line_len;
4812 }
4813 else
4814 {
4815 char *pos = line_buf;
4816 int len = line_len;
4817
4818 for (int i = 0; i < line_len; i++, pos++, len--)
4819 {
4820 if (line_buf[i] == data.separator)
4821 {
4822 pos++;
4823
4824 len--;
4825
4826 break;
4827 }
4828 }
4829
4830 *hashbuf_pos = pos;
4831 *hashbuf_len = len;
4832 }
4833 }
4834
4835 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4836 {
4837 char *pos = NULL;
4838 int len = 0;
4839
4840 int sep_cnt = 0;
4841
4842 for (int i = 0; i < line_len; i++)
4843 {
4844 if (line_buf[i] == data.separator)
4845 {
4846 sep_cnt++;
4847
4848 continue;
4849 }
4850
4851 if (sep_cnt == 0)
4852 {
4853 if (pos == NULL) pos = line_buf + i;
4854
4855 len++;
4856 }
4857 }
4858
4859 *userbuf_pos = pos;
4860 *userbuf_len = len;
4861 }
4862
4863 // hlfmt pwdump
4864
4865 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4866 {
4867 int sep_cnt = 0;
4868
4869 int sep2_len = 0;
4870 int sep3_len = 0;
4871
4872 for (int i = 0; i < line_len; i++)
4873 {
4874 if (line_buf[i] == ':')
4875 {
4876 sep_cnt++;
4877
4878 continue;
4879 }
4880
4881 if (sep_cnt == 2) sep2_len++;
4882 if (sep_cnt == 3) sep3_len++;
4883 }
4884
4885 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4886
4887 return 0;
4888 }
4889
4890 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4891 {
4892 char *pos = NULL;
4893 int len = 0;
4894
4895 int sep_cnt = 0;
4896
4897 for (int i = 0; i < line_len; i++)
4898 {
4899 if (line_buf[i] == ':')
4900 {
4901 sep_cnt++;
4902
4903 continue;
4904 }
4905
4906 if (data.hash_mode == 1000)
4907 {
4908 if (sep_cnt == 3)
4909 {
4910 if (pos == NULL) pos = line_buf + i;
4911
4912 len++;
4913 }
4914 }
4915 else if (data.hash_mode == 3000)
4916 {
4917 if (sep_cnt == 2)
4918 {
4919 if (pos == NULL) pos = line_buf + i;
4920
4921 len++;
4922 }
4923 }
4924 }
4925
4926 *hashbuf_pos = pos;
4927 *hashbuf_len = len;
4928 }
4929
4930 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4931 {
4932 char *pos = NULL;
4933 int len = 0;
4934
4935 int sep_cnt = 0;
4936
4937 for (int i = 0; i < line_len; i++)
4938 {
4939 if (line_buf[i] == ':')
4940 {
4941 sep_cnt++;
4942
4943 continue;
4944 }
4945
4946 if (sep_cnt == 0)
4947 {
4948 if (pos == NULL) pos = line_buf + i;
4949
4950 len++;
4951 }
4952 }
4953
4954 *userbuf_pos = pos;
4955 *userbuf_len = len;
4956 }
4957
4958 // hlfmt passwd
4959
4960 static int hlfmt_detect_passwd (char *line_buf, int line_len)
4961 {
4962 int sep_cnt = 0;
4963
4964 char sep5_first = 0;
4965 char sep6_first = 0;
4966
4967 for (int i = 0; i < line_len; i++)
4968 {
4969 if (line_buf[i] == ':')
4970 {
4971 sep_cnt++;
4972
4973 continue;
4974 }
4975
4976 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4977 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4978 }
4979
4980 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4981
4982 return 0;
4983 }
4984
4985 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4986 {
4987 char *pos = NULL;
4988 int len = 0;
4989
4990 int sep_cnt = 0;
4991
4992 for (int i = 0; i < line_len; i++)
4993 {
4994 if (line_buf[i] == ':')
4995 {
4996 sep_cnt++;
4997
4998 continue;
4999 }
5000
5001 if (sep_cnt == 1)
5002 {
5003 if (pos == NULL) pos = line_buf + i;
5004
5005 len++;
5006 }
5007 }
5008
5009 *hashbuf_pos = pos;
5010 *hashbuf_len = len;
5011 }
5012
5013 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5014 {
5015 char *pos = NULL;
5016 int len = 0;
5017
5018 int sep_cnt = 0;
5019
5020 for (int i = 0; i < line_len; i++)
5021 {
5022 if (line_buf[i] == ':')
5023 {
5024 sep_cnt++;
5025
5026 continue;
5027 }
5028
5029 if (sep_cnt == 0)
5030 {
5031 if (pos == NULL) pos = line_buf + i;
5032
5033 len++;
5034 }
5035 }
5036
5037 *userbuf_pos = pos;
5038 *userbuf_len = len;
5039 }
5040
5041 // hlfmt shadow
5042
5043 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5044 {
5045 int sep_cnt = 0;
5046
5047 for (int i = 0; i < line_len; i++)
5048 {
5049 if (line_buf[i] == ':') sep_cnt++;
5050 }
5051
5052 if (sep_cnt == 8) return 1;
5053
5054 return 0;
5055 }
5056
5057 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5058 {
5059 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5060 }
5061
5062 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5063 {
5064 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5065 }
5066
5067 // hlfmt main
5068
5069 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5070 {
5071 switch (hashfile_format)
5072 {
5073 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5074 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5075 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5076 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5077 }
5078 }
5079
5080 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5081 {
5082 switch (hashfile_format)
5083 {
5084 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5085 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5086 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5087 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5088 }
5089 }
5090
5091 char *strhlfmt (const uint hashfile_format)
5092 {
5093 switch (hashfile_format)
5094 {
5095 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5096 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5097 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5098 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5099 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5100 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5101 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5102 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5103 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5104 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5105 }
5106
5107 return ((char *) "Unknown");
5108 }
5109
5110 static uint hlfmt_detect (FILE *fp, uint max_check)
5111 {
5112 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5113
5114 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5115 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5116
5117 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5118
5119 uint num_check = 0;
5120
5121 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5122
5123 while (!feof (fp))
5124 {
5125 int line_len = fgetl (fp, line_buf);
5126
5127 if (line_len == 0) continue;
5128
5129 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5130 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5131 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5132
5133 if (num_check == max_check) break;
5134
5135 num_check++;
5136 }
5137
5138 myfree (line_buf);
5139
5140 uint hashlist_format = HLFMT_HASHCAT;
5141
5142 for (int i = 1; i < HLFMTS_CNT; i++)
5143 {
5144 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5145
5146 hashlist_format = i;
5147 }
5148
5149 free (formats_cnt);
5150
5151 return hashlist_format;
5152 }
5153
5154 /**
5155 * some further helper function
5156 */
5157
5158 // wrapper around mymalloc for ADL
5159
5160 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5161 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5162 {
5163 return mymalloc (iSize);
5164 }
5165 #endif
5166
5167 static uint generate_bitmaps (const uint digests_cnt, const uint dgst_size, const uint dgst_shifts, char *digests_buf_ptr, const uint bitmap_mask, const uint bitmap_size, uint *bitmap_a, uint *bitmap_b, uint *bitmap_c, uint *bitmap_d, const u64 collisions_max)
5168 {
5169 u64 collisions = 0;
5170
5171 const uint dgst_pos0 = data.dgst_pos0;
5172 const uint dgst_pos1 = data.dgst_pos1;
5173 const uint dgst_pos2 = data.dgst_pos2;
5174 const uint dgst_pos3 = data.dgst_pos3;
5175
5176 memset (bitmap_a, 0, bitmap_size);
5177 memset (bitmap_b, 0, bitmap_size);
5178 memset (bitmap_c, 0, bitmap_size);
5179 memset (bitmap_d, 0, bitmap_size);
5180
5181 for (uint i = 0; i < digests_cnt; i++)
5182 {
5183 uint *digest_ptr = (uint *) digests_buf_ptr;
5184
5185 digests_buf_ptr += dgst_size;
5186
5187 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5188 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5189 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5190 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5191
5192 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5193 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5194 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5195 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5196
5197 if (bitmap_a[idx0] & val0) collisions++;
5198 if (bitmap_b[idx1] & val1) collisions++;
5199 if (bitmap_c[idx2] & val2) collisions++;
5200 if (bitmap_d[idx3] & val3) collisions++;
5201
5202 bitmap_a[idx0] |= val0;
5203 bitmap_b[idx1] |= val1;
5204 bitmap_c[idx2] |= val2;
5205 bitmap_d[idx3] |= val3;
5206
5207 if (collisions >= collisions_max) return 0x7fffffff;
5208 }
5209
5210 return collisions;
5211 }
5212
5213 /**
5214 * main
5215 */
5216
5217 int main (int argc, char **argv)
5218 {
5219 /**
5220 * To help users a bit
5221 */
5222
5223 char *compute = getenv ("COMPUTE");
5224
5225 if (compute)
5226 {
5227 static char display[100];
5228
5229 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5230
5231 putenv (display);
5232 }
5233 else
5234 {
5235 if (getenv ("DISPLAY") == NULL)
5236 putenv ((char *) "DISPLAY=:0");
5237 }
5238
5239 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5240 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5241
5242 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5243 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5244
5245 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5246 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5247
5248 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5249 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5250
5251 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5252 putenv ((char *) "POCL_KERNEL_CACHE=0");
5253
5254 /**
5255 * Real init
5256 */
5257
5258 memset (&data, 0, sizeof (hc_global_data_t));
5259
5260 time_t proc_start;
5261
5262 time (&proc_start);
5263
5264 data.proc_start = proc_start;
5265
5266 int myargc = argc;
5267 char **myargv = argv;
5268
5269 hc_thread_mutex_init (mux_dispatcher);
5270 hc_thread_mutex_init (mux_counter);
5271 hc_thread_mutex_init (mux_display);
5272 hc_thread_mutex_init (mux_adl);
5273
5274 /**
5275 * commandline parameters
5276 */
5277
5278 uint usage = USAGE;
5279 uint version = VERSION;
5280 uint quiet = QUIET;
5281 uint benchmark = BENCHMARK;
5282 uint show = SHOW;
5283 uint left = LEFT;
5284 uint username = USERNAME;
5285 uint remove = REMOVE;
5286 uint remove_timer = REMOVE_TIMER;
5287 u64 skip = SKIP;
5288 u64 limit = LIMIT;
5289 uint keyspace = KEYSPACE;
5290 uint potfile_disable = POTFILE_DISABLE;
5291 char *potfile_path = NULL;
5292 uint debug_mode = DEBUG_MODE;
5293 char *debug_file = NULL;
5294 char *induction_dir = NULL;
5295 char *outfile_check_dir = NULL;
5296 uint force = FORCE;
5297 uint runtime = RUNTIME;
5298 uint hash_mode = HASH_MODE;
5299 uint attack_mode = ATTACK_MODE;
5300 uint markov_disable = MARKOV_DISABLE;
5301 uint markov_classic = MARKOV_CLASSIC;
5302 uint markov_threshold = MARKOV_THRESHOLD;
5303 char *markov_hcstat = NULL;
5304 char *outfile = NULL;
5305 uint outfile_format = OUTFILE_FORMAT;
5306 uint outfile_autohex = OUTFILE_AUTOHEX;
5307 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5308 uint restore = RESTORE;
5309 uint restore_timer = RESTORE_TIMER;
5310 uint restore_disable = RESTORE_DISABLE;
5311 uint status = STATUS;
5312 uint status_timer = STATUS_TIMER;
5313 uint status_automat = STATUS_AUTOMAT;
5314 uint loopback = LOOPBACK;
5315 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5316 char *session = NULL;
5317 uint hex_charset = HEX_CHARSET;
5318 uint hex_salt = HEX_SALT;
5319 uint hex_wordlist = HEX_WORDLIST;
5320 uint rp_gen = RP_GEN;
5321 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5322 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5323 uint rp_gen_seed = RP_GEN_SEED;
5324 char *rule_buf_l = (char *) RULE_BUF_L;
5325 char *rule_buf_r = (char *) RULE_BUF_R;
5326 uint increment = INCREMENT;
5327 uint increment_min = INCREMENT_MIN;
5328 uint increment_max = INCREMENT_MAX;
5329 char *cpu_affinity = NULL;
5330 OCL_PTR *ocl = NULL;
5331 char *opencl_devices = NULL;
5332 char *opencl_platforms = NULL;
5333 char *opencl_device_types = NULL;
5334 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5335 char *truecrypt_keyfiles = NULL;
5336 uint workload_profile = WORKLOAD_PROFILE;
5337 uint kernel_accel = KERNEL_ACCEL;
5338 uint kernel_loops = KERNEL_LOOPS;
5339 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5340 #ifdef HAVE_HWMON
5341 uint gpu_temp_abort = GPU_TEMP_ABORT;
5342 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5343 #ifdef HAVE_ADL
5344 uint powertune_enable = POWERTUNE_ENABLE;
5345 #endif
5346 #endif
5347 uint logfile_disable = LOGFILE_DISABLE;
5348 uint segment_size = SEGMENT_SIZE;
5349 uint scrypt_tmto = SCRYPT_TMTO;
5350 char separator = SEPARATOR;
5351 uint bitmap_min = BITMAP_MIN;
5352 uint bitmap_max = BITMAP_MAX;
5353 char *custom_charset_1 = NULL;
5354 char *custom_charset_2 = NULL;
5355 char *custom_charset_3 = NULL;
5356 char *custom_charset_4 = NULL;
5357
5358 #define IDX_HELP 'h'
5359 #define IDX_VERSION 'V'
5360 #define IDX_VERSION_LOWER 'v'
5361 #define IDX_QUIET 0xff02
5362 #define IDX_SHOW 0xff03
5363 #define IDX_LEFT 0xff04
5364 #define IDX_REMOVE 0xff05
5365 #define IDX_REMOVE_TIMER 0xff37
5366 #define IDX_SKIP 's'
5367 #define IDX_LIMIT 'l'
5368 #define IDX_KEYSPACE 0xff35
5369 #define IDX_POTFILE_DISABLE 0xff06
5370 #define IDX_POTFILE_PATH 0xffe0
5371 #define IDX_DEBUG_MODE 0xff43
5372 #define IDX_DEBUG_FILE 0xff44
5373 #define IDX_INDUCTION_DIR 0xff46
5374 #define IDX_OUTFILE_CHECK_DIR 0xff47
5375 #define IDX_USERNAME 0xff07
5376 #define IDX_FORCE 0xff08
5377 #define IDX_RUNTIME 0xff09
5378 #define IDX_BENCHMARK 'b'
5379 #define IDX_HASH_MODE 'm'
5380 #define IDX_ATTACK_MODE 'a'
5381 #define IDX_RP_FILE 'r'
5382 #define IDX_RP_GEN 'g'
5383 #define IDX_RP_GEN_FUNC_MIN 0xff10
5384 #define IDX_RP_GEN_FUNC_MAX 0xff11
5385 #define IDX_RP_GEN_SEED 0xff34
5386 #define IDX_RULE_BUF_L 'j'
5387 #define IDX_RULE_BUF_R 'k'
5388 #define IDX_INCREMENT 'i'
5389 #define IDX_INCREMENT_MIN 0xff12
5390 #define IDX_INCREMENT_MAX 0xff13
5391 #define IDX_OUTFILE 'o'
5392 #define IDX_OUTFILE_FORMAT 0xff14
5393 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5394 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5395 #define IDX_RESTORE 0xff15
5396 #define IDX_RESTORE_DISABLE 0xff27
5397 #define IDX_STATUS 0xff17
5398 #define IDX_STATUS_TIMER 0xff18
5399 #define IDX_STATUS_AUTOMAT 0xff50
5400 #define IDX_LOOPBACK 0xff38
5401 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5402 #define IDX_SESSION 0xff19
5403 #define IDX_HEX_CHARSET 0xff20
5404 #define IDX_HEX_SALT 0xff21
5405 #define IDX_HEX_WORDLIST 0xff40
5406 #define IDX_MARKOV_DISABLE 0xff22
5407 #define IDX_MARKOV_CLASSIC 0xff23
5408 #define IDX_MARKOV_THRESHOLD 't'
5409 #define IDX_MARKOV_HCSTAT 0xff24
5410 #define IDX_CPU_AFFINITY 0xff25
5411 #define IDX_OPENCL_DEVICES 'd'
5412 #define IDX_OPENCL_PLATFORMS 0xff72
5413 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5414 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5415 #define IDX_WORKLOAD_PROFILE 'w'
5416 #define IDX_KERNEL_ACCEL 'n'
5417 #define IDX_KERNEL_LOOPS 'u'
5418 #define IDX_GPU_TEMP_DISABLE 0xff29
5419 #define IDX_GPU_TEMP_ABORT 0xff30
5420 #define IDX_GPU_TEMP_RETAIN 0xff31
5421 #define IDX_POWERTUNE_ENABLE 0xff41
5422 #define IDX_LOGFILE_DISABLE 0xff51
5423 #define IDX_TRUECRYPT_KEYFILES 0xff52
5424 #define IDX_SCRYPT_TMTO 0xff61
5425 #define IDX_SEGMENT_SIZE 'c'
5426 #define IDX_SEPARATOR 'p'
5427 #define IDX_BITMAP_MIN 0xff70
5428 #define IDX_BITMAP_MAX 0xff71
5429 #define IDX_CUSTOM_CHARSET_1 '1'
5430 #define IDX_CUSTOM_CHARSET_2 '2'
5431 #define IDX_CUSTOM_CHARSET_3 '3'
5432 #define IDX_CUSTOM_CHARSET_4 '4'
5433
5434 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5435
5436 struct option long_options[] =
5437 {
5438 {"help", no_argument, 0, IDX_HELP},
5439 {"version", no_argument, 0, IDX_VERSION},
5440 {"quiet", no_argument, 0, IDX_QUIET},
5441 {"show", no_argument, 0, IDX_SHOW},
5442 {"left", no_argument, 0, IDX_LEFT},
5443 {"username", no_argument, 0, IDX_USERNAME},
5444 {"remove", no_argument, 0, IDX_REMOVE},
5445 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5446 {"skip", required_argument, 0, IDX_SKIP},
5447 {"limit", required_argument, 0, IDX_LIMIT},
5448 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5449 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5450 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5451 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5452 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5453 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5454 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5455 {"force", no_argument, 0, IDX_FORCE},
5456 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5457 {"restore", no_argument, 0, IDX_RESTORE},
5458 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5459 {"status", no_argument, 0, IDX_STATUS},
5460 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5461 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5462 {"loopback", no_argument, 0, IDX_LOOPBACK},
5463 {"weak-hash-threshold",
5464 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5465 {"session", required_argument, 0, IDX_SESSION},
5466 {"runtime", required_argument, 0, IDX_RUNTIME},
5467 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5468 {"generate-rules-func-min",
5469 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5470 {"generate-rules-func-max",
5471 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5472 {"generate-rules-seed",
5473 required_argument, 0, IDX_RP_GEN_SEED},
5474 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5475 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5476 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5477 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5478 {"rules-file", required_argument, 0, IDX_RP_FILE},
5479 {"outfile", required_argument, 0, IDX_OUTFILE},
5480 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5481 {"outfile-autohex-disable",
5482 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5483 {"outfile-check-timer",
5484 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5485 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5486 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5487 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5488 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5489 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5490 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5491 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5492 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5493 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5494 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5495 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5496 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5497 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5498 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5499 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5500 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5501 #ifdef HAVE_HWMON
5502 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5503 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5504 #ifdef HAVE_ADL
5505 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5506 #endif
5507 #endif // HAVE_HWMON
5508 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5509 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5510 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5511 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5512 // deprecated
5513 {"seperator", required_argument, 0, IDX_SEPARATOR},
5514 {"separator", required_argument, 0, IDX_SEPARATOR},
5515 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5516 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5517 {"increment", no_argument, 0, IDX_INCREMENT},
5518 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5519 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5520 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5521 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5522 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5523 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5524
5525 {0, 0, 0, 0}
5526 };
5527
5528 uint rp_files_cnt = 0;
5529
5530 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5531
5532 int option_index = 0;
5533 int c = -1;
5534
5535 optind = 1;
5536 optopt = 0;
5537
5538 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5539 {
5540 switch (c)
5541 {
5542 case IDX_HELP: usage = 1; break;
5543 case IDX_VERSION:
5544 case IDX_VERSION_LOWER: version = 1; break;
5545 case IDX_RESTORE: restore = 1; break;
5546 case IDX_SESSION: session = optarg; break;
5547 case IDX_SHOW: show = 1; break;
5548 case IDX_LEFT: left = 1; break;
5549 case '?': return (-1);
5550 }
5551 }
5552
5553 if (optopt != 0)
5554 {
5555 log_error ("ERROR: Invalid argument specified");
5556
5557 return (-1);
5558 }
5559
5560 /**
5561 * exit functions
5562 */
5563
5564 if (version)
5565 {
5566 log_info ("%s", VERSION_TAG);
5567
5568 return (0);
5569 }
5570
5571 if (usage)
5572 {
5573 usage_big_print (PROGNAME);
5574
5575 return (0);
5576 }
5577
5578 /**
5579 * session needs to be set, always!
5580 */
5581
5582 if (session == NULL) session = (char *) PROGNAME;
5583
5584 /**
5585 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5586 */
5587
5588 char *exec_path = get_exec_path ();
5589
5590 #ifdef LINUX
5591
5592 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5593 char *resolved_exec_path = realpath (exec_path, NULL);
5594
5595 char *install_dir = get_install_dir (resolved_exec_path);
5596 char *profile_dir = NULL;
5597 char *session_dir = NULL;
5598 char *shared_dir = NULL;
5599
5600 if (strcmp (install_dir, resolved_install_folder) == 0)
5601 {
5602 struct passwd *pw = getpwuid (getuid ());
5603
5604 const char *homedir = pw->pw_dir;
5605
5606 profile_dir = get_profile_dir (homedir);
5607 session_dir = get_session_dir (profile_dir);
5608 shared_dir = strdup (SHARED_FOLDER);
5609
5610 mkdir (profile_dir, 0700);
5611 mkdir (session_dir, 0700);
5612 }
5613 else
5614 {
5615 profile_dir = install_dir;
5616 session_dir = install_dir;
5617 shared_dir = install_dir;
5618 }
5619
5620 myfree (resolved_install_folder);
5621 myfree (resolved_exec_path);
5622
5623 #else
5624
5625 char *install_dir = get_install_dir (exec_path);
5626 char *profile_dir = install_dir;
5627 char *session_dir = install_dir;
5628 char *shared_dir = install_dir;
5629
5630 #endif
5631
5632 data.install_dir = install_dir;
5633 data.profile_dir = profile_dir;
5634 data.session_dir = session_dir;
5635 data.shared_dir = shared_dir;
5636
5637 myfree (exec_path);
5638
5639 /**
5640 * kernel cache, we need to make sure folder exist
5641 */
5642
5643 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5644
5645 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5646
5647 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5648
5649 mkdir (kernels_folder, 0700);
5650
5651 myfree (kernels_folder);
5652
5653 /**
5654 * session
5655 */
5656
5657 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5658
5659 data.session = session;
5660
5661 char *eff_restore_file = (char *) mymalloc (session_size);
5662 char *new_restore_file = (char *) mymalloc (session_size);
5663
5664 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5665 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5666
5667 data.eff_restore_file = eff_restore_file;
5668 data.new_restore_file = new_restore_file;
5669
5670 if (((show == 1) || (left == 1)) && (restore == 1))
5671 {
5672 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5673 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5674
5675 return (-1);
5676 }
5677
5678 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5679 if ((show == 1) || (left == 1))
5680 {
5681 restore_disable = 1;
5682
5683 restore = 0;
5684 }
5685
5686 data.restore_disable = restore_disable;
5687
5688 restore_data_t *rd = init_restore (argc, argv);
5689
5690 data.rd = rd;
5691
5692 /**
5693 * restore file
5694 */
5695
5696 if (restore == 1)
5697 {
5698 read_restore (eff_restore_file, rd);
5699
5700 if (rd->version_bin < RESTORE_MIN)
5701 {
5702 log_error ("ERROR: Incompatible restore-file version");
5703
5704 return (-1);
5705 }
5706
5707 myargc = rd->argc;
5708 myargv = rd->argv;
5709
5710 #ifdef _POSIX
5711 rd->pid = getpid ();
5712 #elif _WIN
5713 rd->pid = GetCurrentProcessId ();
5714 #endif
5715 }
5716
5717 uint hash_mode_chgd = 0;
5718 uint runtime_chgd = 0;
5719 uint kernel_loops_chgd = 0;
5720 uint kernel_accel_chgd = 0;
5721 uint attack_mode_chgd = 0;
5722 uint outfile_format_chgd = 0;
5723 uint rp_gen_seed_chgd = 0;
5724 uint remove_timer_chgd = 0;
5725 uint increment_min_chgd = 0;
5726 uint increment_max_chgd = 0;
5727 uint workload_profile_chgd = 0;
5728 uint opencl_vector_width_chgd = 0;
5729
5730 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5731 uint gpu_temp_retain_chgd = 0;
5732 uint gpu_temp_abort_chgd = 0;
5733 #endif
5734
5735 optind = 1;
5736 optopt = 0;
5737 option_index = 0;
5738
5739 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5740 {
5741 switch (c)
5742 {
5743 //case IDX_HELP: usage = 1; break;
5744 //case IDX_VERSION: version = 1; break;
5745 //case IDX_RESTORE: restore = 1; break;
5746 case IDX_QUIET: quiet = 1; break;
5747 //case IDX_SHOW: show = 1; break;
5748 case IDX_SHOW: break;
5749 //case IDX_LEFT: left = 1; break;
5750 case IDX_LEFT: break;
5751 case IDX_USERNAME: username = 1; break;
5752 case IDX_REMOVE: remove = 1; break;
5753 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5754 remove_timer_chgd = 1; break;
5755 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5756 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5757 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5758 case IDX_DEBUG_FILE: debug_file = optarg; break;
5759 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5760 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5761 case IDX_FORCE: force = 1; break;
5762 case IDX_SKIP: skip = atoll (optarg); break;
5763 case IDX_LIMIT: limit = atoll (optarg); break;
5764 case IDX_KEYSPACE: keyspace = 1; break;
5765 case IDX_BENCHMARK: benchmark = 1; break;
5766 case IDX_RESTORE: break;
5767 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5768 case IDX_STATUS: status = 1; break;
5769 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5770 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5771 case IDX_LOOPBACK: loopback = 1; break;
5772 case IDX_WEAK_HASH_THRESHOLD:
5773 weak_hash_threshold = atoi (optarg); break;
5774 //case IDX_SESSION: session = optarg; break;
5775 case IDX_SESSION: break;
5776 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5777 hash_mode_chgd = 1; break;
5778 case IDX_RUNTIME: runtime = atoi (optarg);
5779 runtime_chgd = 1; break;
5780 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5781 attack_mode_chgd = 1; break;
5782 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5783 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5784 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5785 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5786 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5787 rp_gen_seed_chgd = 1; break;
5788 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5789 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5790 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5791 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5792 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5793 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5794 case IDX_OUTFILE: outfile = optarg; break;
5795 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5796 outfile_format_chgd = 1; break;
5797 case IDX_OUTFILE_AUTOHEX_DISABLE:
5798 outfile_autohex = 0; break;
5799 case IDX_OUTFILE_CHECK_TIMER:
5800 outfile_check_timer = atoi (optarg); break;
5801 case IDX_HEX_CHARSET: hex_charset = 1; break;
5802 case IDX_HEX_SALT: hex_salt = 1; break;
5803 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5804 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5805 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5806 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5807 case IDX_OPENCL_DEVICE_TYPES:
5808 opencl_device_types = optarg; break;
5809 case IDX_OPENCL_VECTOR_WIDTH:
5810 opencl_vector_width = atoi (optarg);
5811 opencl_vector_width_chgd = 1; break;
5812 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5813 workload_profile_chgd = 1; break;
5814 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5815 kernel_accel_chgd = 1; break;
5816 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5817 kernel_loops_chgd = 1; break;
5818 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5819 #ifdef HAVE_HWMON
5820 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5821 #ifdef HAVE_ADL
5822 gpu_temp_abort_chgd = 1;
5823 #endif
5824 break;
5825 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5826 #ifdef HAVE_ADL
5827 gpu_temp_retain_chgd = 1;
5828 #endif
5829 break;
5830 #ifdef HAVE_ADL
5831 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5832 #endif
5833 #endif // HAVE_HWMON
5834 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5835 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5836 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5837 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5838 case IDX_SEPARATOR: separator = optarg[0]; break;
5839 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5840 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5841 case IDX_INCREMENT: increment = 1; break;
5842 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5843 increment_min_chgd = 1; break;
5844 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5845 increment_max_chgd = 1; break;
5846 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5847 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5848 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5849 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5850
5851 default:
5852 log_error ("ERROR: Invalid argument specified");
5853 return (-1);
5854 }
5855 }
5856
5857 if (optopt != 0)
5858 {
5859 log_error ("ERROR: Invalid argument specified");
5860
5861 return (-1);
5862 }
5863
5864 /**
5865 * Inform user things getting started,
5866 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5867 * - we do not need to check algorithm_pos
5868 */
5869
5870 if (quiet == 0)
5871 {
5872 if (benchmark == 1)
5873 {
5874 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
5875 log_info ("");
5876 }
5877 else if (restore == 1)
5878 {
5879 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
5880 log_info ("");
5881 }
5882 else
5883 {
5884 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
5885 log_info ("");
5886 }
5887 }
5888
5889 /**
5890 * sanity check
5891 */
5892
5893 if (attack_mode > 7)
5894 {
5895 log_error ("ERROR: Invalid attack-mode specified");
5896
5897 return (-1);
5898 }
5899
5900 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5901 {
5902 log_error ("ERROR: Invalid runtime specified");
5903
5904 return (-1);
5905 }
5906
5907 if (hash_mode_chgd && hash_mode > 13600) // just added to remove compiler warnings for hash_mode_chgd
5908 {
5909 log_error ("ERROR: Invalid hash-type specified");
5910
5911 return (-1);
5912 }
5913
5914 // renamed hash modes
5915
5916 if (hash_mode_chgd)
5917 {
5918 int n = -1;
5919
5920 switch (hash_mode)
5921 {
5922 case 123: n = 124;
5923 break;
5924 }
5925
5926 if (n >= 0)
5927 {
5928 log_error ("Old -m specified, use -m %d instead", n);
5929
5930 return (-1);
5931 }
5932 }
5933
5934 if (username == 1)
5935 {
5936 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5937 {
5938 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5939
5940 return (-1);
5941 }
5942 }
5943
5944 if (outfile_format > 16)
5945 {
5946 log_error ("ERROR: Invalid outfile-format specified");
5947
5948 return (-1);
5949 }
5950
5951 if (left == 1)
5952 {
5953 if (outfile_format_chgd == 1)
5954 {
5955 if (outfile_format > 1)
5956 {
5957 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5958
5959 return (-1);
5960 }
5961 }
5962 else
5963 {
5964 outfile_format = OUTFILE_FMT_HASH;
5965 }
5966 }
5967
5968 if (show == 1)
5969 {
5970 if (outfile_format_chgd == 1)
5971 {
5972 if ((outfile_format > 7) && (outfile_format < 16))
5973 {
5974 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5975
5976 return (-1);
5977 }
5978 }
5979 }
5980
5981 if (increment_min < INCREMENT_MIN)
5982 {
5983 log_error ("ERROR: Invalid increment-min specified");
5984
5985 return (-1);
5986 }
5987
5988 if (increment_max > INCREMENT_MAX)
5989 {
5990 log_error ("ERROR: Invalid increment-max specified");
5991
5992 return (-1);
5993 }
5994
5995 if (increment_min > increment_max)
5996 {
5997 log_error ("ERROR: Invalid increment-min specified");
5998
5999 return (-1);
6000 }
6001
6002 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6003 {
6004 log_error ("ERROR: increment is not allowed in attack-mode 0");
6005
6006 return (-1);
6007 }
6008
6009 if ((increment == 0) && (increment_min_chgd == 1))
6010 {
6011 log_error ("ERROR: increment-min is only supported together with increment switch");
6012
6013 return (-1);
6014 }
6015
6016 if ((increment == 0) && (increment_max_chgd == 1))
6017 {
6018 log_error ("ERROR: increment-max is only supported together with increment switch");
6019
6020 return (-1);
6021 }
6022
6023 if (rp_files_cnt && rp_gen)
6024 {
6025 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6026
6027 return (-1);
6028 }
6029
6030 if (rp_files_cnt || rp_gen)
6031 {
6032 if (attack_mode != ATTACK_MODE_STRAIGHT)
6033 {
6034 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6035
6036 return (-1);
6037 }
6038 }
6039
6040 if (rp_gen_func_min > rp_gen_func_max)
6041 {
6042 log_error ("ERROR: Invalid rp-gen-func-min specified");
6043
6044 return (-1);
6045 }
6046
6047 if (kernel_accel_chgd == 1)
6048 {
6049 if (kernel_accel < 1)
6050 {
6051 log_error ("ERROR: Invalid kernel-accel specified");
6052
6053 return (-1);
6054 }
6055
6056 if (kernel_accel > 1024)
6057 {
6058 log_error ("ERROR: Invalid kernel-accel specified");
6059
6060 return (-1);
6061 }
6062 }
6063
6064 if (kernel_loops_chgd == 1)
6065 {
6066 if (kernel_loops < 1)
6067 {
6068 log_error ("ERROR: Invalid kernel-loops specified");
6069
6070 return (-1);
6071 }
6072
6073 if (kernel_loops > 1024)
6074 {
6075 log_error ("ERROR: Invalid kernel-loops specified");
6076
6077 return (-1);
6078 }
6079 }
6080
6081 if ((workload_profile < 1) || (workload_profile > 3))
6082 {
6083 log_error ("ERROR: workload-profile %i not available", workload_profile);
6084
6085 return (-1);
6086 }
6087
6088 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6089 {
6090 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6091
6092 return (-1);
6093 }
6094
6095 if (show == 1 || left == 1)
6096 {
6097 attack_mode = ATTACK_MODE_NONE;
6098
6099 if (remove == 1)
6100 {
6101 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6102
6103 return (-1);
6104 }
6105
6106 if (potfile_disable == 1)
6107 {
6108 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6109
6110 return (-1);
6111 }
6112 }
6113
6114 uint attack_kern = ATTACK_KERN_NONE;
6115
6116 switch (attack_mode)
6117 {
6118 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6119 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6120 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6121 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6122 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6123 }
6124
6125 if (benchmark == 0)
6126 {
6127 if (keyspace == 1)
6128 {
6129 int num_additional_params = 1;
6130
6131 if (attack_kern == ATTACK_KERN_COMBI)
6132 {
6133 num_additional_params = 2;
6134 }
6135
6136 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6137
6138 if (keyspace_wordlist_specified == 0) optind--;
6139 }
6140
6141 if (attack_kern == ATTACK_KERN_NONE)
6142 {
6143 if ((optind + 1) != myargc)
6144 {
6145 usage_mini_print (myargv[0]);
6146
6147 return (-1);
6148 }
6149 }
6150 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6151 {
6152 if ((optind + 1) > myargc)
6153 {
6154 usage_mini_print (myargv[0]);
6155
6156 return (-1);
6157 }
6158 }
6159 else if (attack_kern == ATTACK_KERN_COMBI)
6160 {
6161 if ((optind + 3) != myargc)
6162 {
6163 usage_mini_print (myargv[0]);
6164
6165 return (-1);
6166 }
6167 }
6168 else if (attack_kern == ATTACK_KERN_BF)
6169 {
6170 if ((optind + 1) > myargc)
6171 {
6172 usage_mini_print (myargv[0]);
6173
6174 return (-1);
6175 }
6176 }
6177 else
6178 {
6179 usage_mini_print (myargv[0]);
6180
6181 return (-1);
6182 }
6183 }
6184 else
6185 {
6186 if (myargv[optind] != 0)
6187 {
6188 log_error ("ERROR: Invalid argument for benchmark mode specified");
6189
6190 return (-1);
6191 }
6192
6193 if (attack_mode_chgd == 1)
6194 {
6195 if (attack_mode != ATTACK_MODE_BF)
6196 {
6197 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6198
6199 return (-1);
6200 }
6201 }
6202 }
6203
6204 if (skip != 0 && limit != 0)
6205 {
6206 limit += skip;
6207 }
6208
6209 if (keyspace == 1)
6210 {
6211 if (show == 1)
6212 {
6213 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6214
6215 return (-1);
6216 }
6217 else if (left == 1)
6218 {
6219 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6220
6221 return (-1);
6222 }
6223
6224 potfile_disable = 1;
6225
6226 restore_disable = 1;
6227
6228 restore = 0;
6229
6230 weak_hash_threshold = 0;
6231
6232 quiet = 1;
6233 }
6234
6235 if (remove_timer_chgd == 1)
6236 {
6237 if (remove == 0)
6238 {
6239 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6240
6241 return (-1);
6242 }
6243
6244 if (remove_timer < 1)
6245 {
6246 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6247
6248 return (-1);
6249 }
6250 }
6251
6252 if (loopback == 1)
6253 {
6254 if (attack_mode == ATTACK_MODE_STRAIGHT)
6255 {
6256 if ((rp_files_cnt == 0) && (rp_gen == 0))
6257 {
6258 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6259
6260 return (-1);
6261 }
6262 }
6263 else
6264 {
6265 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6266
6267 return (-1);
6268 }
6269 }
6270
6271 if (debug_mode > 0)
6272 {
6273 if (attack_mode != ATTACK_MODE_STRAIGHT)
6274 {
6275 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6276
6277 return (-1);
6278 }
6279
6280 if ((rp_files_cnt == 0) && (rp_gen == 0))
6281 {
6282 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6283
6284 return (-1);
6285 }
6286 }
6287
6288 if (debug_mode > 4)
6289 {
6290 log_error ("ERROR: Invalid debug-mode specified");
6291
6292 return (-1);
6293 }
6294
6295 if (debug_file != NULL)
6296 {
6297 if (debug_mode < 1)
6298 {
6299 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6300
6301 return (-1);
6302 }
6303 }
6304
6305 if (induction_dir != NULL)
6306 {
6307 if (attack_mode == ATTACK_MODE_BF)
6308 {
6309 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6310
6311 return (-1);
6312 }
6313 }
6314
6315 if (attack_mode != ATTACK_MODE_STRAIGHT)
6316 {
6317 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6318 {
6319 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6320
6321 return (-1);
6322 }
6323
6324 weak_hash_threshold = 0;
6325 }
6326
6327 /**
6328 * induction directory
6329 */
6330
6331 char *induction_directory = NULL;
6332
6333 if (attack_mode != ATTACK_MODE_BF)
6334 {
6335 if (induction_dir == NULL)
6336 {
6337 induction_directory = (char *) mymalloc (session_size);
6338
6339 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6340
6341 // create induction folder if it does not already exist
6342
6343 if (keyspace == 0)
6344 {
6345 if (rmdir (induction_directory) == -1)
6346 {
6347 if (errno == ENOENT)
6348 {
6349 // good, we can ignore
6350 }
6351 else if (errno == ENOTEMPTY)
6352 {
6353 char *induction_directory_mv = (char *) mymalloc (session_size);
6354
6355 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6356
6357 if (rename (induction_directory, induction_directory_mv) != 0)
6358 {
6359 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6360
6361 return (-1);
6362 }
6363 }
6364 else
6365 {
6366 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6367
6368 return (-1);
6369 }
6370 }
6371
6372 if (mkdir (induction_directory, 0700) == -1)
6373 {
6374 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6375
6376 return (-1);
6377 }
6378 }
6379 }
6380 else
6381 {
6382 induction_directory = induction_dir;
6383 }
6384 }
6385
6386 data.induction_directory = induction_directory;
6387
6388 /**
6389 * loopback
6390 */
6391
6392 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6393
6394 char *loopback_file = (char *) mymalloc (loopback_size);
6395
6396 /**
6397 * tuning db
6398 */
6399
6400 char tuning_db_file[256] = { 0 };
6401
6402 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6403
6404 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6405
6406 /**
6407 * outfile-check directory
6408 */
6409
6410 char *outfile_check_directory = NULL;
6411
6412 if (outfile_check_dir == NULL)
6413 {
6414 outfile_check_directory = (char *) mymalloc (session_size);
6415
6416 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6417 }
6418 else
6419 {
6420 outfile_check_directory = outfile_check_dir;
6421 }
6422
6423 data.outfile_check_directory = outfile_check_directory;
6424
6425 if (keyspace == 0)
6426 {
6427 struct stat outfile_check_stat;
6428
6429 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6430 {
6431 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6432
6433 if (is_dir == 0)
6434 {
6435 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6436
6437 return (-1);
6438 }
6439 }
6440 else if (outfile_check_dir == NULL)
6441 {
6442 if (mkdir (outfile_check_directory, 0700) == -1)
6443 {
6444 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6445
6446 return (-1);
6447 }
6448 }
6449 }
6450
6451 /**
6452 * special other stuff
6453 */
6454
6455 if (hash_mode == 9710)
6456 {
6457 outfile_format = 5;
6458 outfile_format_chgd = 1;
6459 }
6460
6461 if (hash_mode == 9810)
6462 {
6463 outfile_format = 5;
6464 outfile_format_chgd = 1;
6465 }
6466
6467 if (hash_mode == 10410)
6468 {
6469 outfile_format = 5;
6470 outfile_format_chgd = 1;
6471 }
6472
6473 /**
6474 * store stuff
6475 */
6476
6477 data.hash_mode = hash_mode;
6478 data.restore = restore;
6479 data.restore_timer = restore_timer;
6480 data.restore_disable = restore_disable;
6481 data.status = status;
6482 data.status_timer = status_timer;
6483 data.status_automat = status_automat;
6484 data.loopback = loopback;
6485 data.runtime = runtime;
6486 data.remove = remove;
6487 data.remove_timer = remove_timer;
6488 data.debug_mode = debug_mode;
6489 data.debug_file = debug_file;
6490 data.username = username;
6491 data.quiet = quiet;
6492 data.outfile = outfile;
6493 data.outfile_format = outfile_format;
6494 data.outfile_autohex = outfile_autohex;
6495 data.hex_charset = hex_charset;
6496 data.hex_salt = hex_salt;
6497 data.hex_wordlist = hex_wordlist;
6498 data.separator = separator;
6499 data.rp_files = rp_files;
6500 data.rp_files_cnt = rp_files_cnt;
6501 data.rp_gen = rp_gen;
6502 data.rp_gen_seed = rp_gen_seed;
6503 data.force = force;
6504 data.benchmark = benchmark;
6505 data.skip = skip;
6506 data.limit = limit;
6507 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6508 data.powertune_enable = powertune_enable;
6509 #endif
6510 data.logfile_disable = logfile_disable;
6511 data.truecrypt_keyfiles = truecrypt_keyfiles;
6512 data.scrypt_tmto = scrypt_tmto;
6513 data.workload_profile = workload_profile;
6514
6515 /**
6516 * cpu affinity
6517 */
6518
6519 if (cpu_affinity)
6520 {
6521 set_cpu_affinity (cpu_affinity);
6522 }
6523
6524 if (rp_gen_seed_chgd == 0)
6525 {
6526 srand (proc_start);
6527 }
6528 else
6529 {
6530 srand (rp_gen_seed);
6531 }
6532
6533 /**
6534 * logfile init
6535 */
6536
6537 if (logfile_disable == 0)
6538 {
6539 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6540
6541 char *logfile = (char *) mymalloc (logfile_size);
6542
6543 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6544
6545 data.logfile = logfile;
6546
6547 char *topid = logfile_generate_topid ();
6548
6549 data.topid = topid;
6550 }
6551
6552 // logfile_append() checks for logfile_disable internally to make it easier from here
6553
6554 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6555 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6556 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6557 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6558 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6559 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6560 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6561 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6562 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6563 #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));
6564
6565 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6566 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6567 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6568 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6569 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6570 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6571 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6572 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6573
6574 logfile_top_msg ("START");
6575
6576 logfile_top_uint (attack_mode);
6577 logfile_top_uint (attack_kern);
6578 logfile_top_uint (benchmark);
6579 logfile_top_uint (bitmap_min);
6580 logfile_top_uint (bitmap_max);
6581 logfile_top_uint (debug_mode);
6582 logfile_top_uint (force);
6583 logfile_top_uint (kernel_accel);
6584 logfile_top_uint (kernel_loops);
6585 logfile_top_uint (gpu_temp_disable);
6586 #ifdef HAVE_HWMON
6587 logfile_top_uint (gpu_temp_abort);
6588 logfile_top_uint (gpu_temp_retain);
6589 #endif
6590 logfile_top_uint (hash_mode);
6591 logfile_top_uint (hex_charset);
6592 logfile_top_uint (hex_salt);
6593 logfile_top_uint (hex_wordlist);
6594 logfile_top_uint (increment);
6595 logfile_top_uint (increment_max);
6596 logfile_top_uint (increment_min);
6597 logfile_top_uint (keyspace);
6598 logfile_top_uint (left);
6599 logfile_top_uint (logfile_disable);
6600 logfile_top_uint (loopback);
6601 logfile_top_uint (markov_classic);
6602 logfile_top_uint (markov_disable);
6603 logfile_top_uint (markov_threshold);
6604 logfile_top_uint (outfile_autohex);
6605 logfile_top_uint (outfile_check_timer);
6606 logfile_top_uint (outfile_format);
6607 logfile_top_uint (potfile_disable);
6608 logfile_top_string (potfile_path);
6609 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6610 logfile_top_uint (powertune_enable);
6611 #endif
6612 logfile_top_uint (scrypt_tmto);
6613 logfile_top_uint (quiet);
6614 logfile_top_uint (remove);
6615 logfile_top_uint (remove_timer);
6616 logfile_top_uint (restore);
6617 logfile_top_uint (restore_disable);
6618 logfile_top_uint (restore_timer);
6619 logfile_top_uint (rp_gen);
6620 logfile_top_uint (rp_gen_func_max);
6621 logfile_top_uint (rp_gen_func_min);
6622 logfile_top_uint (rp_gen_seed);
6623 logfile_top_uint (runtime);
6624 logfile_top_uint (segment_size);
6625 logfile_top_uint (show);
6626 logfile_top_uint (status);
6627 logfile_top_uint (status_automat);
6628 logfile_top_uint (status_timer);
6629 logfile_top_uint (usage);
6630 logfile_top_uint (username);
6631 logfile_top_uint (version);
6632 logfile_top_uint (weak_hash_threshold);
6633 logfile_top_uint (workload_profile);
6634 logfile_top_uint64 (limit);
6635 logfile_top_uint64 (skip);
6636 logfile_top_char (separator);
6637 logfile_top_string (cpu_affinity);
6638 logfile_top_string (custom_charset_1);
6639 logfile_top_string (custom_charset_2);
6640 logfile_top_string (custom_charset_3);
6641 logfile_top_string (custom_charset_4);
6642 logfile_top_string (debug_file);
6643 logfile_top_string (opencl_devices);
6644 logfile_top_string (opencl_platforms);
6645 logfile_top_string (opencl_device_types);
6646 logfile_top_uint (opencl_vector_width);
6647 logfile_top_string (induction_dir);
6648 logfile_top_string (markov_hcstat);
6649 logfile_top_string (outfile);
6650 logfile_top_string (outfile_check_dir);
6651 logfile_top_string (rule_buf_l);
6652 logfile_top_string (rule_buf_r);
6653 logfile_top_string (session);
6654 logfile_top_string (truecrypt_keyfiles);
6655
6656 /**
6657 * Init OpenCL library loader
6658 */
6659
6660 if (keyspace == 0)
6661 {
6662 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6663
6664 ocl_init (ocl);
6665
6666 data.ocl = ocl;
6667 }
6668
6669 /**
6670 * OpenCL platform selection
6671 */
6672
6673 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6674
6675 /**
6676 * OpenCL device selection
6677 */
6678
6679 u32 devices_filter = setup_devices_filter (opencl_devices);
6680
6681 /**
6682 * OpenCL device type selection
6683 */
6684
6685 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6686
6687 /**
6688 * benchmark
6689 */
6690
6691 if (benchmark == 1)
6692 {
6693 /**
6694 * disable useless stuff for benchmark
6695 */
6696
6697 status_timer = 0;
6698 restore_timer = 0;
6699 restore_disable = 1;
6700 potfile_disable = 1;
6701 weak_hash_threshold = 0;
6702 gpu_temp_disable = 1;
6703
6704 data.status_timer = status_timer;
6705 data.restore_timer = restore_timer;
6706 data.restore_disable = restore_disable;
6707
6708 /**
6709 * force attack mode to be bruteforce
6710 */
6711
6712 attack_mode = ATTACK_MODE_BF;
6713 attack_kern = ATTACK_KERN_BF;
6714
6715 if (workload_profile_chgd == 0)
6716 {
6717 workload_profile = 3;
6718
6719 data.workload_profile = workload_profile;
6720 }
6721 }
6722
6723 /**
6724 * config
6725 */
6726
6727 uint hash_type = 0;
6728 uint salt_type = 0;
6729 uint attack_exec = 0;
6730 uint opts_type = 0;
6731 uint kern_type = 0;
6732 uint dgst_size = 0;
6733 uint esalt_size = 0;
6734 uint opti_type = 0;
6735 uint dgst_pos0 = -1;
6736 uint dgst_pos1 = -1;
6737 uint dgst_pos2 = -1;
6738 uint dgst_pos3 = -1;
6739
6740 int (*parse_func) (char *, uint, hash_t *);
6741 int (*sort_by_digest) (const void *, const void *);
6742
6743 uint algorithm_pos = 0;
6744 uint algorithm_max = 1;
6745
6746 uint *algorithms = default_benchmark_algorithms;
6747
6748 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6749
6750 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6751 {
6752 /*
6753 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6754 * the following algos are skipped entirely
6755 */
6756
6757 if (algorithm_pos > 0)
6758 {
6759 local_free (rd);
6760
6761 rd = init_restore (argc, argv);
6762
6763 data.rd = rd;
6764 }
6765
6766 /**
6767 * update hash_mode in case of multihash benchmark
6768 */
6769
6770 if (benchmark == 1)
6771 {
6772 if (hash_mode_chgd == 0)
6773 {
6774 hash_mode = algorithms[algorithm_pos];
6775
6776 data.hash_mode = hash_mode;
6777 }
6778
6779 quiet = 1;
6780
6781 data.quiet = quiet;
6782 }
6783
6784 switch (hash_mode)
6785 {
6786 case 0: hash_type = HASH_TYPE_MD5;
6787 salt_type = SALT_TYPE_NONE;
6788 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6789 opts_type = OPTS_TYPE_PT_GENERATE_LE
6790 | OPTS_TYPE_PT_ADD80
6791 | OPTS_TYPE_PT_ADDBITS14;
6792 kern_type = KERN_TYPE_MD5;
6793 dgst_size = DGST_SIZE_4_4;
6794 parse_func = md5_parse_hash;
6795 sort_by_digest = sort_by_digest_4_4;
6796 opti_type = OPTI_TYPE_ZERO_BYTE
6797 | OPTI_TYPE_PRECOMPUTE_INIT
6798 | OPTI_TYPE_PRECOMPUTE_MERKLE
6799 | OPTI_TYPE_MEET_IN_MIDDLE
6800 | OPTI_TYPE_EARLY_SKIP
6801 | OPTI_TYPE_NOT_ITERATED
6802 | OPTI_TYPE_NOT_SALTED
6803 | OPTI_TYPE_RAW_HASH;
6804 dgst_pos0 = 0;
6805 dgst_pos1 = 3;
6806 dgst_pos2 = 2;
6807 dgst_pos3 = 1;
6808 break;
6809
6810 case 10: hash_type = HASH_TYPE_MD5;
6811 salt_type = SALT_TYPE_INTERN;
6812 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6813 opts_type = OPTS_TYPE_PT_GENERATE_LE
6814 | OPTS_TYPE_ST_ADD80
6815 | OPTS_TYPE_ST_ADDBITS14;
6816 kern_type = KERN_TYPE_MD5_PWSLT;
6817 dgst_size = DGST_SIZE_4_4;
6818 parse_func = md5s_parse_hash;
6819 sort_by_digest = sort_by_digest_4_4;
6820 opti_type = OPTI_TYPE_ZERO_BYTE
6821 | OPTI_TYPE_PRECOMPUTE_INIT
6822 | OPTI_TYPE_PRECOMPUTE_MERKLE
6823 | OPTI_TYPE_MEET_IN_MIDDLE
6824 | OPTI_TYPE_EARLY_SKIP
6825 | OPTI_TYPE_NOT_ITERATED
6826 | OPTI_TYPE_APPENDED_SALT
6827 | OPTI_TYPE_RAW_HASH;
6828 dgst_pos0 = 0;
6829 dgst_pos1 = 3;
6830 dgst_pos2 = 2;
6831 dgst_pos3 = 1;
6832 break;
6833
6834 case 11: hash_type = HASH_TYPE_MD5;
6835 salt_type = SALT_TYPE_INTERN;
6836 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6837 opts_type = OPTS_TYPE_PT_GENERATE_LE
6838 | OPTS_TYPE_ST_ADD80
6839 | OPTS_TYPE_ST_ADDBITS14;
6840 kern_type = KERN_TYPE_MD5_PWSLT;
6841 dgst_size = DGST_SIZE_4_4;
6842 parse_func = joomla_parse_hash;
6843 sort_by_digest = sort_by_digest_4_4;
6844 opti_type = OPTI_TYPE_ZERO_BYTE
6845 | OPTI_TYPE_PRECOMPUTE_INIT
6846 | OPTI_TYPE_PRECOMPUTE_MERKLE
6847 | OPTI_TYPE_MEET_IN_MIDDLE
6848 | OPTI_TYPE_EARLY_SKIP
6849 | OPTI_TYPE_NOT_ITERATED
6850 | OPTI_TYPE_APPENDED_SALT
6851 | OPTI_TYPE_RAW_HASH;
6852 dgst_pos0 = 0;
6853 dgst_pos1 = 3;
6854 dgst_pos2 = 2;
6855 dgst_pos3 = 1;
6856 break;
6857
6858 case 12: hash_type = HASH_TYPE_MD5;
6859 salt_type = SALT_TYPE_INTERN;
6860 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6861 opts_type = OPTS_TYPE_PT_GENERATE_LE
6862 | OPTS_TYPE_ST_ADD80
6863 | OPTS_TYPE_ST_ADDBITS14;
6864 kern_type = KERN_TYPE_MD5_PWSLT;
6865 dgst_size = DGST_SIZE_4_4;
6866 parse_func = postgresql_parse_hash;
6867 sort_by_digest = sort_by_digest_4_4;
6868 opti_type = OPTI_TYPE_ZERO_BYTE
6869 | OPTI_TYPE_PRECOMPUTE_INIT
6870 | OPTI_TYPE_PRECOMPUTE_MERKLE
6871 | OPTI_TYPE_MEET_IN_MIDDLE
6872 | OPTI_TYPE_EARLY_SKIP
6873 | OPTI_TYPE_NOT_ITERATED
6874 | OPTI_TYPE_APPENDED_SALT
6875 | OPTI_TYPE_RAW_HASH;
6876 dgst_pos0 = 0;
6877 dgst_pos1 = 3;
6878 dgst_pos2 = 2;
6879 dgst_pos3 = 1;
6880 break;
6881
6882 case 20: hash_type = HASH_TYPE_MD5;
6883 salt_type = SALT_TYPE_INTERN;
6884 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6885 opts_type = OPTS_TYPE_PT_GENERATE_LE
6886 | OPTS_TYPE_PT_ADD80
6887 | OPTS_TYPE_PT_ADDBITS14;
6888 kern_type = KERN_TYPE_MD5_SLTPW;
6889 dgst_size = DGST_SIZE_4_4;
6890 parse_func = md5s_parse_hash;
6891 sort_by_digest = sort_by_digest_4_4;
6892 opti_type = OPTI_TYPE_ZERO_BYTE
6893 | OPTI_TYPE_PRECOMPUTE_INIT
6894 | OPTI_TYPE_PRECOMPUTE_MERKLE
6895 | OPTI_TYPE_EARLY_SKIP
6896 | OPTI_TYPE_NOT_ITERATED
6897 | OPTI_TYPE_PREPENDED_SALT
6898 | OPTI_TYPE_RAW_HASH;
6899 dgst_pos0 = 0;
6900 dgst_pos1 = 3;
6901 dgst_pos2 = 2;
6902 dgst_pos3 = 1;
6903 break;
6904
6905 case 21: hash_type = HASH_TYPE_MD5;
6906 salt_type = SALT_TYPE_INTERN;
6907 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6908 opts_type = OPTS_TYPE_PT_GENERATE_LE
6909 | OPTS_TYPE_PT_ADD80
6910 | OPTS_TYPE_PT_ADDBITS14;
6911 kern_type = KERN_TYPE_MD5_SLTPW;
6912 dgst_size = DGST_SIZE_4_4;
6913 parse_func = osc_parse_hash;
6914 sort_by_digest = sort_by_digest_4_4;
6915 opti_type = OPTI_TYPE_ZERO_BYTE
6916 | OPTI_TYPE_PRECOMPUTE_INIT
6917 | OPTI_TYPE_PRECOMPUTE_MERKLE
6918 | OPTI_TYPE_EARLY_SKIP
6919 | OPTI_TYPE_NOT_ITERATED
6920 | OPTI_TYPE_PREPENDED_SALT
6921 | OPTI_TYPE_RAW_HASH;
6922 dgst_pos0 = 0;
6923 dgst_pos1 = 3;
6924 dgst_pos2 = 2;
6925 dgst_pos3 = 1;
6926 break;
6927
6928 case 22: hash_type = HASH_TYPE_MD5;
6929 salt_type = SALT_TYPE_EMBEDDED;
6930 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6931 opts_type = OPTS_TYPE_PT_GENERATE_LE
6932 | OPTS_TYPE_PT_ADD80
6933 | OPTS_TYPE_PT_ADDBITS14;
6934 kern_type = KERN_TYPE_MD5_SLTPW;
6935 dgst_size = DGST_SIZE_4_4;
6936 parse_func = netscreen_parse_hash;
6937 sort_by_digest = sort_by_digest_4_4;
6938 opti_type = OPTI_TYPE_ZERO_BYTE
6939 | OPTI_TYPE_PRECOMPUTE_INIT
6940 | OPTI_TYPE_PRECOMPUTE_MERKLE
6941 | OPTI_TYPE_EARLY_SKIP
6942 | OPTI_TYPE_NOT_ITERATED
6943 | OPTI_TYPE_PREPENDED_SALT
6944 | OPTI_TYPE_RAW_HASH;
6945 dgst_pos0 = 0;
6946 dgst_pos1 = 3;
6947 dgst_pos2 = 2;
6948 dgst_pos3 = 1;
6949 break;
6950
6951 case 23: hash_type = HASH_TYPE_MD5;
6952 salt_type = SALT_TYPE_EMBEDDED;
6953 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6954 opts_type = OPTS_TYPE_PT_GENERATE_LE
6955 | OPTS_TYPE_PT_ADD80
6956 | OPTS_TYPE_PT_ADDBITS14;
6957 kern_type = KERN_TYPE_MD5_SLTPW;
6958 dgst_size = DGST_SIZE_4_4;
6959 parse_func = skype_parse_hash;
6960 sort_by_digest = sort_by_digest_4_4;
6961 opti_type = OPTI_TYPE_ZERO_BYTE
6962 | OPTI_TYPE_PRECOMPUTE_INIT
6963 | OPTI_TYPE_PRECOMPUTE_MERKLE
6964 | OPTI_TYPE_EARLY_SKIP
6965 | OPTI_TYPE_NOT_ITERATED
6966 | OPTI_TYPE_PREPENDED_SALT
6967 | OPTI_TYPE_RAW_HASH;
6968 dgst_pos0 = 0;
6969 dgst_pos1 = 3;
6970 dgst_pos2 = 2;
6971 dgst_pos3 = 1;
6972 break;
6973
6974 case 30: hash_type = HASH_TYPE_MD5;
6975 salt_type = SALT_TYPE_INTERN;
6976 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6977 opts_type = OPTS_TYPE_PT_GENERATE_LE
6978 | OPTS_TYPE_PT_UNICODE
6979 | OPTS_TYPE_ST_ADD80
6980 | OPTS_TYPE_ST_ADDBITS14;
6981 kern_type = KERN_TYPE_MD5_PWUSLT;
6982 dgst_size = DGST_SIZE_4_4;
6983 parse_func = md5s_parse_hash;
6984 sort_by_digest = sort_by_digest_4_4;
6985 opti_type = OPTI_TYPE_ZERO_BYTE
6986 | OPTI_TYPE_PRECOMPUTE_INIT
6987 | OPTI_TYPE_PRECOMPUTE_MERKLE
6988 | OPTI_TYPE_MEET_IN_MIDDLE
6989 | OPTI_TYPE_EARLY_SKIP
6990 | OPTI_TYPE_NOT_ITERATED
6991 | OPTI_TYPE_APPENDED_SALT
6992 | OPTI_TYPE_RAW_HASH;
6993 dgst_pos0 = 0;
6994 dgst_pos1 = 3;
6995 dgst_pos2 = 2;
6996 dgst_pos3 = 1;
6997 break;
6998
6999 case 40: hash_type = HASH_TYPE_MD5;
7000 salt_type = SALT_TYPE_INTERN;
7001 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7002 opts_type = OPTS_TYPE_PT_GENERATE_LE
7003 | OPTS_TYPE_PT_ADD80
7004 | OPTS_TYPE_PT_ADDBITS14
7005 | OPTS_TYPE_PT_UNICODE;
7006 kern_type = KERN_TYPE_MD5_SLTPWU;
7007 dgst_size = DGST_SIZE_4_4;
7008 parse_func = md5s_parse_hash;
7009 sort_by_digest = sort_by_digest_4_4;
7010 opti_type = OPTI_TYPE_ZERO_BYTE
7011 | OPTI_TYPE_PRECOMPUTE_INIT
7012 | OPTI_TYPE_PRECOMPUTE_MERKLE
7013 | OPTI_TYPE_EARLY_SKIP
7014 | OPTI_TYPE_NOT_ITERATED
7015 | OPTI_TYPE_PREPENDED_SALT
7016 | OPTI_TYPE_RAW_HASH;
7017 dgst_pos0 = 0;
7018 dgst_pos1 = 3;
7019 dgst_pos2 = 2;
7020 dgst_pos3 = 1;
7021 break;
7022
7023 case 50: hash_type = HASH_TYPE_MD5;
7024 salt_type = SALT_TYPE_INTERN;
7025 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7026 opts_type = OPTS_TYPE_PT_GENERATE_LE
7027 | OPTS_TYPE_ST_ADD80
7028 | OPTS_TYPE_ST_ADDBITS14;
7029 kern_type = KERN_TYPE_HMACMD5_PW;
7030 dgst_size = DGST_SIZE_4_4;
7031 parse_func = hmacmd5_parse_hash;
7032 sort_by_digest = sort_by_digest_4_4;
7033 opti_type = OPTI_TYPE_ZERO_BYTE
7034 | OPTI_TYPE_NOT_ITERATED;
7035 dgst_pos0 = 0;
7036 dgst_pos1 = 3;
7037 dgst_pos2 = 2;
7038 dgst_pos3 = 1;
7039 break;
7040
7041 case 60: hash_type = HASH_TYPE_MD5;
7042 salt_type = SALT_TYPE_INTERN;
7043 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7044 opts_type = OPTS_TYPE_PT_GENERATE_LE
7045 | OPTS_TYPE_PT_ADD80
7046 | OPTS_TYPE_PT_ADDBITS14;
7047 kern_type = KERN_TYPE_HMACMD5_SLT;
7048 dgst_size = DGST_SIZE_4_4;
7049 parse_func = hmacmd5_parse_hash;
7050 sort_by_digest = sort_by_digest_4_4;
7051 opti_type = OPTI_TYPE_ZERO_BYTE
7052 | OPTI_TYPE_NOT_ITERATED;
7053 dgst_pos0 = 0;
7054 dgst_pos1 = 3;
7055 dgst_pos2 = 2;
7056 dgst_pos3 = 1;
7057 break;
7058
7059 case 100: hash_type = HASH_TYPE_SHA1;
7060 salt_type = SALT_TYPE_NONE;
7061 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7062 opts_type = OPTS_TYPE_PT_GENERATE_BE
7063 | OPTS_TYPE_PT_ADD80
7064 | OPTS_TYPE_PT_ADDBITS15;
7065 kern_type = KERN_TYPE_SHA1;
7066 dgst_size = DGST_SIZE_4_5;
7067 parse_func = sha1_parse_hash;
7068 sort_by_digest = sort_by_digest_4_5;
7069 opti_type = OPTI_TYPE_ZERO_BYTE
7070 | OPTI_TYPE_PRECOMPUTE_INIT
7071 | OPTI_TYPE_PRECOMPUTE_MERKLE
7072 | OPTI_TYPE_EARLY_SKIP
7073 | OPTI_TYPE_NOT_ITERATED
7074 | OPTI_TYPE_NOT_SALTED
7075 | OPTI_TYPE_RAW_HASH;
7076 dgst_pos0 = 3;
7077 dgst_pos1 = 4;
7078 dgst_pos2 = 2;
7079 dgst_pos3 = 1;
7080 break;
7081
7082 case 101: hash_type = HASH_TYPE_SHA1;
7083 salt_type = SALT_TYPE_NONE;
7084 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7085 opts_type = OPTS_TYPE_PT_GENERATE_BE
7086 | OPTS_TYPE_PT_ADD80
7087 | OPTS_TYPE_PT_ADDBITS15;
7088 kern_type = KERN_TYPE_SHA1;
7089 dgst_size = DGST_SIZE_4_5;
7090 parse_func = sha1b64_parse_hash;
7091 sort_by_digest = sort_by_digest_4_5;
7092 opti_type = OPTI_TYPE_ZERO_BYTE
7093 | OPTI_TYPE_PRECOMPUTE_INIT
7094 | OPTI_TYPE_PRECOMPUTE_MERKLE
7095 | OPTI_TYPE_EARLY_SKIP
7096 | OPTI_TYPE_NOT_ITERATED
7097 | OPTI_TYPE_NOT_SALTED
7098 | OPTI_TYPE_RAW_HASH;
7099 dgst_pos0 = 3;
7100 dgst_pos1 = 4;
7101 dgst_pos2 = 2;
7102 dgst_pos3 = 1;
7103 break;
7104
7105 case 110: hash_type = HASH_TYPE_SHA1;
7106 salt_type = SALT_TYPE_INTERN;
7107 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7108 opts_type = OPTS_TYPE_PT_GENERATE_BE
7109 | OPTS_TYPE_ST_ADD80
7110 | OPTS_TYPE_ST_ADDBITS15;
7111 kern_type = KERN_TYPE_SHA1_PWSLT;
7112 dgst_size = DGST_SIZE_4_5;
7113 parse_func = sha1s_parse_hash;
7114 sort_by_digest = sort_by_digest_4_5;
7115 opti_type = OPTI_TYPE_ZERO_BYTE
7116 | OPTI_TYPE_PRECOMPUTE_INIT
7117 | OPTI_TYPE_PRECOMPUTE_MERKLE
7118 | OPTI_TYPE_EARLY_SKIP
7119 | OPTI_TYPE_NOT_ITERATED
7120 | OPTI_TYPE_APPENDED_SALT
7121 | OPTI_TYPE_RAW_HASH;
7122 dgst_pos0 = 3;
7123 dgst_pos1 = 4;
7124 dgst_pos2 = 2;
7125 dgst_pos3 = 1;
7126 break;
7127
7128 case 111: hash_type = HASH_TYPE_SHA1;
7129 salt_type = SALT_TYPE_EMBEDDED;
7130 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7131 opts_type = OPTS_TYPE_PT_GENERATE_BE
7132 | OPTS_TYPE_ST_ADD80
7133 | OPTS_TYPE_ST_ADDBITS15;
7134 kern_type = KERN_TYPE_SHA1_PWSLT;
7135 dgst_size = DGST_SIZE_4_5;
7136 parse_func = sha1b64s_parse_hash;
7137 sort_by_digest = sort_by_digest_4_5;
7138 opti_type = OPTI_TYPE_ZERO_BYTE
7139 | OPTI_TYPE_PRECOMPUTE_INIT
7140 | OPTI_TYPE_PRECOMPUTE_MERKLE
7141 | OPTI_TYPE_EARLY_SKIP
7142 | OPTI_TYPE_NOT_ITERATED
7143 | OPTI_TYPE_APPENDED_SALT
7144 | OPTI_TYPE_RAW_HASH;
7145 dgst_pos0 = 3;
7146 dgst_pos1 = 4;
7147 dgst_pos2 = 2;
7148 dgst_pos3 = 1;
7149 break;
7150
7151 case 112: hash_type = HASH_TYPE_SHA1;
7152 salt_type = SALT_TYPE_INTERN;
7153 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7154 opts_type = OPTS_TYPE_PT_GENERATE_BE
7155 | OPTS_TYPE_ST_ADD80
7156 | OPTS_TYPE_ST_ADDBITS15
7157 | OPTS_TYPE_ST_HEX;
7158 kern_type = KERN_TYPE_SHA1_PWSLT;
7159 dgst_size = DGST_SIZE_4_5;
7160 parse_func = oracles_parse_hash;
7161 sort_by_digest = sort_by_digest_4_5;
7162 opti_type = OPTI_TYPE_ZERO_BYTE
7163 | OPTI_TYPE_PRECOMPUTE_INIT
7164 | OPTI_TYPE_PRECOMPUTE_MERKLE
7165 | OPTI_TYPE_EARLY_SKIP
7166 | OPTI_TYPE_NOT_ITERATED
7167 | OPTI_TYPE_APPENDED_SALT
7168 | OPTI_TYPE_RAW_HASH;
7169 dgst_pos0 = 3;
7170 dgst_pos1 = 4;
7171 dgst_pos2 = 2;
7172 dgst_pos3 = 1;
7173 break;
7174
7175 case 120: hash_type = HASH_TYPE_SHA1;
7176 salt_type = SALT_TYPE_INTERN;
7177 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7178 opts_type = OPTS_TYPE_PT_GENERATE_BE
7179 | OPTS_TYPE_PT_ADD80
7180 | OPTS_TYPE_PT_ADDBITS15;
7181 kern_type = KERN_TYPE_SHA1_SLTPW;
7182 dgst_size = DGST_SIZE_4_5;
7183 parse_func = sha1s_parse_hash;
7184 sort_by_digest = sort_by_digest_4_5;
7185 opti_type = OPTI_TYPE_ZERO_BYTE
7186 | OPTI_TYPE_PRECOMPUTE_INIT
7187 | OPTI_TYPE_PRECOMPUTE_MERKLE
7188 | OPTI_TYPE_EARLY_SKIP
7189 | OPTI_TYPE_NOT_ITERATED
7190 | OPTI_TYPE_PREPENDED_SALT
7191 | OPTI_TYPE_RAW_HASH;
7192 dgst_pos0 = 3;
7193 dgst_pos1 = 4;
7194 dgst_pos2 = 2;
7195 dgst_pos3 = 1;
7196 break;
7197
7198 case 121: hash_type = HASH_TYPE_SHA1;
7199 salt_type = SALT_TYPE_INTERN;
7200 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7201 opts_type = OPTS_TYPE_PT_GENERATE_BE
7202 | OPTS_TYPE_PT_ADD80
7203 | OPTS_TYPE_PT_ADDBITS15
7204 | OPTS_TYPE_ST_LOWER;
7205 kern_type = KERN_TYPE_SHA1_SLTPW;
7206 dgst_size = DGST_SIZE_4_5;
7207 parse_func = smf_parse_hash;
7208 sort_by_digest = sort_by_digest_4_5;
7209 opti_type = OPTI_TYPE_ZERO_BYTE
7210 | OPTI_TYPE_PRECOMPUTE_INIT
7211 | OPTI_TYPE_PRECOMPUTE_MERKLE
7212 | OPTI_TYPE_EARLY_SKIP
7213 | OPTI_TYPE_NOT_ITERATED
7214 | OPTI_TYPE_PREPENDED_SALT
7215 | OPTI_TYPE_RAW_HASH;
7216 dgst_pos0 = 3;
7217 dgst_pos1 = 4;
7218 dgst_pos2 = 2;
7219 dgst_pos3 = 1;
7220 break;
7221
7222 case 122: hash_type = HASH_TYPE_SHA1;
7223 salt_type = SALT_TYPE_EMBEDDED;
7224 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7225 opts_type = OPTS_TYPE_PT_GENERATE_BE
7226 | OPTS_TYPE_PT_ADD80
7227 | OPTS_TYPE_PT_ADDBITS15
7228 | OPTS_TYPE_ST_HEX;
7229 kern_type = KERN_TYPE_SHA1_SLTPW;
7230 dgst_size = DGST_SIZE_4_5;
7231 parse_func = osx1_parse_hash;
7232 sort_by_digest = sort_by_digest_4_5;
7233 opti_type = OPTI_TYPE_ZERO_BYTE
7234 | OPTI_TYPE_PRECOMPUTE_INIT
7235 | OPTI_TYPE_PRECOMPUTE_MERKLE
7236 | OPTI_TYPE_EARLY_SKIP
7237 | OPTI_TYPE_NOT_ITERATED
7238 | OPTI_TYPE_PREPENDED_SALT
7239 | OPTI_TYPE_RAW_HASH;
7240 dgst_pos0 = 3;
7241 dgst_pos1 = 4;
7242 dgst_pos2 = 2;
7243 dgst_pos3 = 1;
7244 break;
7245
7246 case 124: hash_type = HASH_TYPE_SHA1;
7247 salt_type = SALT_TYPE_EMBEDDED;
7248 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7249 opts_type = OPTS_TYPE_PT_GENERATE_BE
7250 | OPTS_TYPE_PT_ADD80
7251 | OPTS_TYPE_PT_ADDBITS15;
7252 kern_type = KERN_TYPE_SHA1_SLTPW;
7253 dgst_size = DGST_SIZE_4_5;
7254 parse_func = djangosha1_parse_hash;
7255 sort_by_digest = sort_by_digest_4_5;
7256 opti_type = OPTI_TYPE_ZERO_BYTE
7257 | OPTI_TYPE_PRECOMPUTE_INIT
7258 | OPTI_TYPE_PRECOMPUTE_MERKLE
7259 | OPTI_TYPE_EARLY_SKIP
7260 | OPTI_TYPE_NOT_ITERATED
7261 | OPTI_TYPE_PREPENDED_SALT
7262 | OPTI_TYPE_RAW_HASH;
7263 dgst_pos0 = 3;
7264 dgst_pos1 = 4;
7265 dgst_pos2 = 2;
7266 dgst_pos3 = 1;
7267 break;
7268
7269 case 125: hash_type = HASH_TYPE_SHA1;
7270 salt_type = SALT_TYPE_EMBEDDED;
7271 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7272 opts_type = OPTS_TYPE_PT_GENERATE_BE
7273 | OPTS_TYPE_PT_ADD80
7274 | OPTS_TYPE_PT_ADDBITS15
7275 | OPTS_TYPE_ST_HEX;
7276 kern_type = KERN_TYPE_SHA1_SLTPW;
7277 dgst_size = DGST_SIZE_4_5;
7278 parse_func = arubaos_parse_hash;
7279 sort_by_digest = sort_by_digest_4_5;
7280 opti_type = OPTI_TYPE_ZERO_BYTE
7281 | OPTI_TYPE_PRECOMPUTE_INIT
7282 | OPTI_TYPE_PRECOMPUTE_MERKLE
7283 | OPTI_TYPE_EARLY_SKIP
7284 | OPTI_TYPE_NOT_ITERATED
7285 | OPTI_TYPE_PREPENDED_SALT
7286 | OPTI_TYPE_RAW_HASH;
7287 dgst_pos0 = 3;
7288 dgst_pos1 = 4;
7289 dgst_pos2 = 2;
7290 dgst_pos3 = 1;
7291 break;
7292
7293 case 130: hash_type = HASH_TYPE_SHA1;
7294 salt_type = SALT_TYPE_INTERN;
7295 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7296 opts_type = OPTS_TYPE_PT_GENERATE_BE
7297 | OPTS_TYPE_PT_UNICODE
7298 | OPTS_TYPE_ST_ADD80
7299 | OPTS_TYPE_ST_ADDBITS15;
7300 kern_type = KERN_TYPE_SHA1_PWUSLT;
7301 dgst_size = DGST_SIZE_4_5;
7302 parse_func = sha1s_parse_hash;
7303 sort_by_digest = sort_by_digest_4_5;
7304 opti_type = OPTI_TYPE_ZERO_BYTE
7305 | OPTI_TYPE_PRECOMPUTE_INIT
7306 | OPTI_TYPE_PRECOMPUTE_MERKLE
7307 | OPTI_TYPE_EARLY_SKIP
7308 | OPTI_TYPE_NOT_ITERATED
7309 | OPTI_TYPE_APPENDED_SALT
7310 | OPTI_TYPE_RAW_HASH;
7311 dgst_pos0 = 3;
7312 dgst_pos1 = 4;
7313 dgst_pos2 = 2;
7314 dgst_pos3 = 1;
7315 break;
7316
7317 case 131: hash_type = HASH_TYPE_SHA1;
7318 salt_type = SALT_TYPE_EMBEDDED;
7319 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7320 opts_type = OPTS_TYPE_PT_GENERATE_BE
7321 | OPTS_TYPE_PT_UNICODE
7322 | OPTS_TYPE_PT_UPPER
7323 | OPTS_TYPE_ST_ADD80
7324 | OPTS_TYPE_ST_ADDBITS15
7325 | OPTS_TYPE_ST_HEX;
7326 kern_type = KERN_TYPE_SHA1_PWUSLT;
7327 dgst_size = DGST_SIZE_4_5;
7328 parse_func = mssql2000_parse_hash;
7329 sort_by_digest = sort_by_digest_4_5;
7330 opti_type = OPTI_TYPE_ZERO_BYTE
7331 | OPTI_TYPE_PRECOMPUTE_INIT
7332 | OPTI_TYPE_PRECOMPUTE_MERKLE
7333 | OPTI_TYPE_EARLY_SKIP
7334 | OPTI_TYPE_NOT_ITERATED
7335 | OPTI_TYPE_APPENDED_SALT
7336 | OPTI_TYPE_RAW_HASH;
7337 dgst_pos0 = 3;
7338 dgst_pos1 = 4;
7339 dgst_pos2 = 2;
7340 dgst_pos3 = 1;
7341 break;
7342
7343 case 132: hash_type = HASH_TYPE_SHA1;
7344 salt_type = SALT_TYPE_EMBEDDED;
7345 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7346 opts_type = OPTS_TYPE_PT_GENERATE_BE
7347 | OPTS_TYPE_PT_UNICODE
7348 | OPTS_TYPE_ST_ADD80
7349 | OPTS_TYPE_ST_ADDBITS15
7350 | OPTS_TYPE_ST_HEX;
7351 kern_type = KERN_TYPE_SHA1_PWUSLT;
7352 dgst_size = DGST_SIZE_4_5;
7353 parse_func = mssql2005_parse_hash;
7354 sort_by_digest = sort_by_digest_4_5;
7355 opti_type = OPTI_TYPE_ZERO_BYTE
7356 | OPTI_TYPE_PRECOMPUTE_INIT
7357 | OPTI_TYPE_PRECOMPUTE_MERKLE
7358 | OPTI_TYPE_EARLY_SKIP
7359 | OPTI_TYPE_NOT_ITERATED
7360 | OPTI_TYPE_APPENDED_SALT
7361 | OPTI_TYPE_RAW_HASH;
7362 dgst_pos0 = 3;
7363 dgst_pos1 = 4;
7364 dgst_pos2 = 2;
7365 dgst_pos3 = 1;
7366 break;
7367
7368 case 133: hash_type = HASH_TYPE_SHA1;
7369 salt_type = SALT_TYPE_EMBEDDED;
7370 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7371 opts_type = OPTS_TYPE_PT_GENERATE_BE
7372 | OPTS_TYPE_PT_UNICODE
7373 | OPTS_TYPE_ST_ADD80
7374 | OPTS_TYPE_ST_ADDBITS15;
7375 kern_type = KERN_TYPE_SHA1_PWUSLT;
7376 dgst_size = DGST_SIZE_4_5;
7377 parse_func = peoplesoft_parse_hash;
7378 sort_by_digest = sort_by_digest_4_5;
7379 opti_type = OPTI_TYPE_ZERO_BYTE
7380 | OPTI_TYPE_PRECOMPUTE_INIT
7381 | OPTI_TYPE_PRECOMPUTE_MERKLE
7382 | OPTI_TYPE_EARLY_SKIP
7383 | OPTI_TYPE_NOT_ITERATED
7384 | OPTI_TYPE_APPENDED_SALT
7385 | OPTI_TYPE_RAW_HASH;
7386 dgst_pos0 = 3;
7387 dgst_pos1 = 4;
7388 dgst_pos2 = 2;
7389 dgst_pos3 = 1;
7390 break;
7391
7392 case 140: hash_type = HASH_TYPE_SHA1;
7393 salt_type = SALT_TYPE_INTERN;
7394 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7395 opts_type = OPTS_TYPE_PT_GENERATE_BE
7396 | OPTS_TYPE_PT_ADD80
7397 | OPTS_TYPE_PT_ADDBITS15
7398 | OPTS_TYPE_PT_UNICODE;
7399 kern_type = KERN_TYPE_SHA1_SLTPWU;
7400 dgst_size = DGST_SIZE_4_5;
7401 parse_func = sha1s_parse_hash;
7402 sort_by_digest = sort_by_digest_4_5;
7403 opti_type = OPTI_TYPE_ZERO_BYTE
7404 | OPTI_TYPE_PRECOMPUTE_INIT
7405 | OPTI_TYPE_PRECOMPUTE_MERKLE
7406 | OPTI_TYPE_EARLY_SKIP
7407 | OPTI_TYPE_NOT_ITERATED
7408 | OPTI_TYPE_PREPENDED_SALT
7409 | OPTI_TYPE_RAW_HASH;
7410 dgst_pos0 = 3;
7411 dgst_pos1 = 4;
7412 dgst_pos2 = 2;
7413 dgst_pos3 = 1;
7414 break;
7415
7416 case 141: hash_type = HASH_TYPE_SHA1;
7417 salt_type = SALT_TYPE_EMBEDDED;
7418 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7419 opts_type = OPTS_TYPE_PT_GENERATE_BE
7420 | OPTS_TYPE_PT_ADD80
7421 | OPTS_TYPE_PT_ADDBITS15
7422 | OPTS_TYPE_PT_UNICODE
7423 | OPTS_TYPE_ST_BASE64;
7424 kern_type = KERN_TYPE_SHA1_SLTPWU;
7425 dgst_size = DGST_SIZE_4_5;
7426 parse_func = episerver_parse_hash;
7427 sort_by_digest = sort_by_digest_4_5;
7428 opti_type = OPTI_TYPE_ZERO_BYTE
7429 | OPTI_TYPE_PRECOMPUTE_INIT
7430 | OPTI_TYPE_PRECOMPUTE_MERKLE
7431 | OPTI_TYPE_EARLY_SKIP
7432 | OPTI_TYPE_NOT_ITERATED
7433 | OPTI_TYPE_PREPENDED_SALT
7434 | OPTI_TYPE_RAW_HASH;
7435 dgst_pos0 = 3;
7436 dgst_pos1 = 4;
7437 dgst_pos2 = 2;
7438 dgst_pos3 = 1;
7439 break;
7440
7441 case 150: hash_type = HASH_TYPE_SHA1;
7442 salt_type = SALT_TYPE_INTERN;
7443 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7444 opts_type = OPTS_TYPE_PT_GENERATE_BE
7445 | OPTS_TYPE_ST_ADD80
7446 | OPTS_TYPE_ST_ADDBITS15;
7447 kern_type = KERN_TYPE_HMACSHA1_PW;
7448 dgst_size = DGST_SIZE_4_5;
7449 parse_func = hmacsha1_parse_hash;
7450 sort_by_digest = sort_by_digest_4_5;
7451 opti_type = OPTI_TYPE_ZERO_BYTE
7452 | OPTI_TYPE_NOT_ITERATED;
7453 dgst_pos0 = 3;
7454 dgst_pos1 = 4;
7455 dgst_pos2 = 2;
7456 dgst_pos3 = 1;
7457 break;
7458
7459 case 160: hash_type = HASH_TYPE_SHA1;
7460 salt_type = SALT_TYPE_INTERN;
7461 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7462 opts_type = OPTS_TYPE_PT_GENERATE_BE
7463 | OPTS_TYPE_PT_ADD80
7464 | OPTS_TYPE_PT_ADDBITS15;
7465 kern_type = KERN_TYPE_HMACSHA1_SLT;
7466 dgst_size = DGST_SIZE_4_5;
7467 parse_func = hmacsha1_parse_hash;
7468 sort_by_digest = sort_by_digest_4_5;
7469 opti_type = OPTI_TYPE_ZERO_BYTE
7470 | OPTI_TYPE_NOT_ITERATED;
7471 dgst_pos0 = 3;
7472 dgst_pos1 = 4;
7473 dgst_pos2 = 2;
7474 dgst_pos3 = 1;
7475 break;
7476
7477 case 190: hash_type = HASH_TYPE_SHA1;
7478 salt_type = SALT_TYPE_NONE;
7479 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7480 opts_type = OPTS_TYPE_PT_GENERATE_BE
7481 | OPTS_TYPE_PT_ADD80
7482 | OPTS_TYPE_PT_ADDBITS15;
7483 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7484 dgst_size = DGST_SIZE_4_5;
7485 parse_func = sha1linkedin_parse_hash;
7486 sort_by_digest = sort_by_digest_4_5;
7487 opti_type = OPTI_TYPE_ZERO_BYTE
7488 | OPTI_TYPE_PRECOMPUTE_INIT
7489 | OPTI_TYPE_EARLY_SKIP
7490 | OPTI_TYPE_NOT_ITERATED
7491 | OPTI_TYPE_NOT_SALTED;
7492 dgst_pos0 = 0;
7493 dgst_pos1 = 4;
7494 dgst_pos2 = 3;
7495 dgst_pos3 = 2;
7496 break;
7497
7498 case 200: hash_type = HASH_TYPE_MYSQL;
7499 salt_type = SALT_TYPE_NONE;
7500 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7501 opts_type = 0;
7502 kern_type = KERN_TYPE_MYSQL;
7503 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7504 parse_func = mysql323_parse_hash;
7505 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7506 opti_type = OPTI_TYPE_ZERO_BYTE;
7507 dgst_pos0 = 0;
7508 dgst_pos1 = 1;
7509 dgst_pos2 = 2;
7510 dgst_pos3 = 3;
7511 break;
7512
7513 case 300: hash_type = HASH_TYPE_SHA1;
7514 salt_type = SALT_TYPE_NONE;
7515 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7516 opts_type = OPTS_TYPE_PT_GENERATE_BE
7517 | OPTS_TYPE_PT_ADD80
7518 | OPTS_TYPE_PT_ADDBITS15;
7519 kern_type = KERN_TYPE_MYSQL41;
7520 dgst_size = DGST_SIZE_4_5;
7521 parse_func = sha1_parse_hash;
7522 sort_by_digest = sort_by_digest_4_5;
7523 opti_type = OPTI_TYPE_ZERO_BYTE
7524 | OPTI_TYPE_PRECOMPUTE_INIT
7525 | OPTI_TYPE_PRECOMPUTE_MERKLE
7526 | OPTI_TYPE_EARLY_SKIP
7527 | OPTI_TYPE_NOT_ITERATED
7528 | OPTI_TYPE_NOT_SALTED;
7529 dgst_pos0 = 3;
7530 dgst_pos1 = 4;
7531 dgst_pos2 = 2;
7532 dgst_pos3 = 1;
7533 break;
7534
7535 case 400: hash_type = HASH_TYPE_MD5;
7536 salt_type = SALT_TYPE_EMBEDDED;
7537 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7538 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7539 kern_type = KERN_TYPE_PHPASS;
7540 dgst_size = DGST_SIZE_4_4;
7541 parse_func = phpass_parse_hash;
7542 sort_by_digest = sort_by_digest_4_4;
7543 opti_type = OPTI_TYPE_ZERO_BYTE
7544 | OPTI_TYPE_SLOW_HASH_SIMD;
7545 dgst_pos0 = 0;
7546 dgst_pos1 = 1;
7547 dgst_pos2 = 2;
7548 dgst_pos3 = 3;
7549 break;
7550
7551 case 500: hash_type = HASH_TYPE_MD5;
7552 salt_type = SALT_TYPE_EMBEDDED;
7553 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7554 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7555 kern_type = KERN_TYPE_MD5CRYPT;
7556 dgst_size = DGST_SIZE_4_4;
7557 parse_func = md5crypt_parse_hash;
7558 sort_by_digest = sort_by_digest_4_4;
7559 opti_type = OPTI_TYPE_ZERO_BYTE;
7560 dgst_pos0 = 0;
7561 dgst_pos1 = 1;
7562 dgst_pos2 = 2;
7563 dgst_pos3 = 3;
7564 break;
7565
7566 case 501: hash_type = HASH_TYPE_MD5;
7567 salt_type = SALT_TYPE_EMBEDDED;
7568 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7569 opts_type = OPTS_TYPE_PT_GENERATE_LE
7570 | OPTS_TYPE_HASH_COPY;
7571 kern_type = KERN_TYPE_MD5CRYPT;
7572 dgst_size = DGST_SIZE_4_4;
7573 parse_func = juniper_parse_hash;
7574 sort_by_digest = sort_by_digest_4_4;
7575 opti_type = OPTI_TYPE_ZERO_BYTE;
7576 dgst_pos0 = 0;
7577 dgst_pos1 = 1;
7578 dgst_pos2 = 2;
7579 dgst_pos3 = 3;
7580 break;
7581
7582 case 900: hash_type = HASH_TYPE_MD4;
7583 salt_type = SALT_TYPE_NONE;
7584 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7585 opts_type = OPTS_TYPE_PT_GENERATE_LE
7586 | OPTS_TYPE_PT_ADD80
7587 | OPTS_TYPE_PT_ADDBITS14;
7588 kern_type = KERN_TYPE_MD4;
7589 dgst_size = DGST_SIZE_4_4;
7590 parse_func = md4_parse_hash;
7591 sort_by_digest = sort_by_digest_4_4;
7592 opti_type = OPTI_TYPE_ZERO_BYTE
7593 | OPTI_TYPE_PRECOMPUTE_INIT
7594 | OPTI_TYPE_PRECOMPUTE_MERKLE
7595 | OPTI_TYPE_MEET_IN_MIDDLE
7596 | OPTI_TYPE_EARLY_SKIP
7597 | OPTI_TYPE_NOT_ITERATED
7598 | OPTI_TYPE_NOT_SALTED
7599 | OPTI_TYPE_RAW_HASH;
7600 dgst_pos0 = 0;
7601 dgst_pos1 = 3;
7602 dgst_pos2 = 2;
7603 dgst_pos3 = 1;
7604 break;
7605
7606 case 1000: hash_type = HASH_TYPE_MD4;
7607 salt_type = SALT_TYPE_NONE;
7608 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7609 opts_type = OPTS_TYPE_PT_GENERATE_LE
7610 | OPTS_TYPE_PT_ADD80
7611 | OPTS_TYPE_PT_ADDBITS14
7612 | OPTS_TYPE_PT_UNICODE;
7613 kern_type = KERN_TYPE_MD4_PWU;
7614 dgst_size = DGST_SIZE_4_4;
7615 parse_func = md4_parse_hash;
7616 sort_by_digest = sort_by_digest_4_4;
7617 opti_type = OPTI_TYPE_ZERO_BYTE
7618 | OPTI_TYPE_PRECOMPUTE_INIT
7619 | OPTI_TYPE_PRECOMPUTE_MERKLE
7620 | OPTI_TYPE_MEET_IN_MIDDLE
7621 | OPTI_TYPE_EARLY_SKIP
7622 | OPTI_TYPE_NOT_ITERATED
7623 | OPTI_TYPE_NOT_SALTED
7624 | OPTI_TYPE_RAW_HASH;
7625 dgst_pos0 = 0;
7626 dgst_pos1 = 3;
7627 dgst_pos2 = 2;
7628 dgst_pos3 = 1;
7629 break;
7630
7631 case 1100: hash_type = HASH_TYPE_MD4;
7632 salt_type = SALT_TYPE_INTERN;
7633 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7634 opts_type = OPTS_TYPE_PT_GENERATE_LE
7635 | OPTS_TYPE_PT_ADD80
7636 | OPTS_TYPE_PT_ADDBITS14
7637 | OPTS_TYPE_PT_UNICODE
7638 | OPTS_TYPE_ST_ADD80
7639 | OPTS_TYPE_ST_UNICODE
7640 | OPTS_TYPE_ST_LOWER;
7641 kern_type = KERN_TYPE_MD44_PWUSLT;
7642 dgst_size = DGST_SIZE_4_4;
7643 parse_func = dcc_parse_hash;
7644 sort_by_digest = sort_by_digest_4_4;
7645 opti_type = OPTI_TYPE_ZERO_BYTE
7646 | OPTI_TYPE_PRECOMPUTE_INIT
7647 | OPTI_TYPE_PRECOMPUTE_MERKLE
7648 | OPTI_TYPE_EARLY_SKIP
7649 | OPTI_TYPE_NOT_ITERATED;
7650 dgst_pos0 = 0;
7651 dgst_pos1 = 3;
7652 dgst_pos2 = 2;
7653 dgst_pos3 = 1;
7654 break;
7655
7656 case 1400: hash_type = HASH_TYPE_SHA256;
7657 salt_type = SALT_TYPE_NONE;
7658 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7659 opts_type = OPTS_TYPE_PT_GENERATE_BE
7660 | OPTS_TYPE_PT_ADD80
7661 | OPTS_TYPE_PT_ADDBITS15;
7662 kern_type = KERN_TYPE_SHA256;
7663 dgst_size = DGST_SIZE_4_8;
7664 parse_func = sha256_parse_hash;
7665 sort_by_digest = sort_by_digest_4_8;
7666 opti_type = OPTI_TYPE_ZERO_BYTE
7667 | OPTI_TYPE_PRECOMPUTE_INIT
7668 | OPTI_TYPE_PRECOMPUTE_MERKLE
7669 | OPTI_TYPE_EARLY_SKIP
7670 | OPTI_TYPE_NOT_ITERATED
7671 | OPTI_TYPE_NOT_SALTED
7672 | OPTI_TYPE_RAW_HASH;
7673 dgst_pos0 = 3;
7674 dgst_pos1 = 7;
7675 dgst_pos2 = 2;
7676 dgst_pos3 = 6;
7677 break;
7678
7679 case 1410: hash_type = HASH_TYPE_SHA256;
7680 salt_type = SALT_TYPE_INTERN;
7681 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7682 opts_type = OPTS_TYPE_PT_GENERATE_BE
7683 | OPTS_TYPE_ST_ADD80
7684 | OPTS_TYPE_ST_ADDBITS15;
7685 kern_type = KERN_TYPE_SHA256_PWSLT;
7686 dgst_size = DGST_SIZE_4_8;
7687 parse_func = sha256s_parse_hash;
7688 sort_by_digest = sort_by_digest_4_8;
7689 opti_type = OPTI_TYPE_ZERO_BYTE
7690 | OPTI_TYPE_PRECOMPUTE_INIT
7691 | OPTI_TYPE_PRECOMPUTE_MERKLE
7692 | OPTI_TYPE_EARLY_SKIP
7693 | OPTI_TYPE_NOT_ITERATED
7694 | OPTI_TYPE_APPENDED_SALT
7695 | OPTI_TYPE_RAW_HASH;
7696 dgst_pos0 = 3;
7697 dgst_pos1 = 7;
7698 dgst_pos2 = 2;
7699 dgst_pos3 = 6;
7700 break;
7701
7702 case 1420: hash_type = HASH_TYPE_SHA256;
7703 salt_type = SALT_TYPE_INTERN;
7704 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7705 opts_type = OPTS_TYPE_PT_GENERATE_BE
7706 | OPTS_TYPE_PT_ADD80
7707 | OPTS_TYPE_PT_ADDBITS15;
7708 kern_type = KERN_TYPE_SHA256_SLTPW;
7709 dgst_size = DGST_SIZE_4_8;
7710 parse_func = sha256s_parse_hash;
7711 sort_by_digest = sort_by_digest_4_8;
7712 opti_type = OPTI_TYPE_ZERO_BYTE
7713 | OPTI_TYPE_PRECOMPUTE_INIT
7714 | OPTI_TYPE_PRECOMPUTE_MERKLE
7715 | OPTI_TYPE_EARLY_SKIP
7716 | OPTI_TYPE_NOT_ITERATED
7717 | OPTI_TYPE_PREPENDED_SALT
7718 | OPTI_TYPE_RAW_HASH;
7719 dgst_pos0 = 3;
7720 dgst_pos1 = 7;
7721 dgst_pos2 = 2;
7722 dgst_pos3 = 6;
7723 break;
7724
7725 case 1421: hash_type = HASH_TYPE_SHA256;
7726 salt_type = SALT_TYPE_EMBEDDED;
7727 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7728 opts_type = OPTS_TYPE_PT_GENERATE_BE
7729 | OPTS_TYPE_PT_ADD80
7730 | OPTS_TYPE_PT_ADDBITS15;
7731 kern_type = KERN_TYPE_SHA256_SLTPW;
7732 dgst_size = DGST_SIZE_4_8;
7733 parse_func = hmailserver_parse_hash;
7734 sort_by_digest = sort_by_digest_4_8;
7735 opti_type = OPTI_TYPE_ZERO_BYTE
7736 | OPTI_TYPE_PRECOMPUTE_INIT
7737 | OPTI_TYPE_PRECOMPUTE_MERKLE
7738 | OPTI_TYPE_EARLY_SKIP
7739 | OPTI_TYPE_NOT_ITERATED
7740 | OPTI_TYPE_PREPENDED_SALT
7741 | OPTI_TYPE_RAW_HASH;
7742 dgst_pos0 = 3;
7743 dgst_pos1 = 7;
7744 dgst_pos2 = 2;
7745 dgst_pos3 = 6;
7746 break;
7747
7748 case 1430: hash_type = HASH_TYPE_SHA256;
7749 salt_type = SALT_TYPE_INTERN;
7750 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7751 opts_type = OPTS_TYPE_PT_GENERATE_BE
7752 | OPTS_TYPE_PT_UNICODE
7753 | OPTS_TYPE_ST_ADD80
7754 | OPTS_TYPE_ST_ADDBITS15;
7755 kern_type = KERN_TYPE_SHA256_PWUSLT;
7756 dgst_size = DGST_SIZE_4_8;
7757 parse_func = sha256s_parse_hash;
7758 sort_by_digest = sort_by_digest_4_8;
7759 opti_type = OPTI_TYPE_ZERO_BYTE
7760 | OPTI_TYPE_PRECOMPUTE_INIT
7761 | OPTI_TYPE_PRECOMPUTE_MERKLE
7762 | OPTI_TYPE_EARLY_SKIP
7763 | OPTI_TYPE_NOT_ITERATED
7764 | OPTI_TYPE_APPENDED_SALT
7765 | OPTI_TYPE_RAW_HASH;
7766 dgst_pos0 = 3;
7767 dgst_pos1 = 7;
7768 dgst_pos2 = 2;
7769 dgst_pos3 = 6;
7770 break;
7771
7772 case 1440: hash_type = HASH_TYPE_SHA256;
7773 salt_type = SALT_TYPE_INTERN;
7774 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7775 opts_type = OPTS_TYPE_PT_GENERATE_BE
7776 | OPTS_TYPE_PT_ADD80
7777 | OPTS_TYPE_PT_ADDBITS15
7778 | OPTS_TYPE_PT_UNICODE;
7779 kern_type = KERN_TYPE_SHA256_SLTPWU;
7780 dgst_size = DGST_SIZE_4_8;
7781 parse_func = sha256s_parse_hash;
7782 sort_by_digest = sort_by_digest_4_8;
7783 opti_type = OPTI_TYPE_ZERO_BYTE
7784 | OPTI_TYPE_PRECOMPUTE_INIT
7785 | OPTI_TYPE_PRECOMPUTE_MERKLE
7786 | OPTI_TYPE_EARLY_SKIP
7787 | OPTI_TYPE_NOT_ITERATED
7788 | OPTI_TYPE_PREPENDED_SALT
7789 | OPTI_TYPE_RAW_HASH;
7790 dgst_pos0 = 3;
7791 dgst_pos1 = 7;
7792 dgst_pos2 = 2;
7793 dgst_pos3 = 6;
7794 break;
7795
7796 case 1441: hash_type = HASH_TYPE_SHA256;
7797 salt_type = SALT_TYPE_EMBEDDED;
7798 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7799 opts_type = OPTS_TYPE_PT_GENERATE_BE
7800 | OPTS_TYPE_PT_ADD80
7801 | OPTS_TYPE_PT_ADDBITS15
7802 | OPTS_TYPE_PT_UNICODE
7803 | OPTS_TYPE_ST_BASE64;
7804 kern_type = KERN_TYPE_SHA256_SLTPWU;
7805 dgst_size = DGST_SIZE_4_8;
7806 parse_func = episerver4_parse_hash;
7807 sort_by_digest = sort_by_digest_4_8;
7808 opti_type = OPTI_TYPE_ZERO_BYTE
7809 | OPTI_TYPE_PRECOMPUTE_INIT
7810 | OPTI_TYPE_PRECOMPUTE_MERKLE
7811 | OPTI_TYPE_EARLY_SKIP
7812 | OPTI_TYPE_NOT_ITERATED
7813 | OPTI_TYPE_PREPENDED_SALT
7814 | OPTI_TYPE_RAW_HASH;
7815 dgst_pos0 = 3;
7816 dgst_pos1 = 7;
7817 dgst_pos2 = 2;
7818 dgst_pos3 = 6;
7819 break;
7820
7821 case 1450: hash_type = HASH_TYPE_SHA256;
7822 salt_type = SALT_TYPE_INTERN;
7823 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7824 opts_type = OPTS_TYPE_PT_GENERATE_BE
7825 | OPTS_TYPE_ST_ADD80;
7826 kern_type = KERN_TYPE_HMACSHA256_PW;
7827 dgst_size = DGST_SIZE_4_8;
7828 parse_func = hmacsha256_parse_hash;
7829 sort_by_digest = sort_by_digest_4_8;
7830 opti_type = OPTI_TYPE_ZERO_BYTE
7831 | OPTI_TYPE_NOT_ITERATED;
7832 dgst_pos0 = 3;
7833 dgst_pos1 = 7;
7834 dgst_pos2 = 2;
7835 dgst_pos3 = 6;
7836 break;
7837
7838 case 1460: hash_type = HASH_TYPE_SHA256;
7839 salt_type = SALT_TYPE_INTERN;
7840 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7841 opts_type = OPTS_TYPE_PT_GENERATE_BE
7842 | OPTS_TYPE_PT_ADD80
7843 | OPTS_TYPE_PT_ADDBITS15;
7844 kern_type = KERN_TYPE_HMACSHA256_SLT;
7845 dgst_size = DGST_SIZE_4_8;
7846 parse_func = hmacsha256_parse_hash;
7847 sort_by_digest = sort_by_digest_4_8;
7848 opti_type = OPTI_TYPE_ZERO_BYTE
7849 | OPTI_TYPE_NOT_ITERATED;
7850 dgst_pos0 = 3;
7851 dgst_pos1 = 7;
7852 dgst_pos2 = 2;
7853 dgst_pos3 = 6;
7854 break;
7855
7856 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7857 salt_type = SALT_TYPE_EMBEDDED;
7858 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7859 opts_type = OPTS_TYPE_PT_GENERATE_LE
7860 | OPTS_TYPE_PT_BITSLICE;
7861 kern_type = KERN_TYPE_DESCRYPT;
7862 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7863 parse_func = descrypt_parse_hash;
7864 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7865 opti_type = OPTI_TYPE_ZERO_BYTE
7866 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7867 dgst_pos0 = 0;
7868 dgst_pos1 = 1;
7869 dgst_pos2 = 2;
7870 dgst_pos3 = 3;
7871 break;
7872
7873 case 1600: hash_type = HASH_TYPE_MD5;
7874 salt_type = SALT_TYPE_EMBEDDED;
7875 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7876 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7877 kern_type = KERN_TYPE_APR1CRYPT;
7878 dgst_size = DGST_SIZE_4_4;
7879 parse_func = md5apr1_parse_hash;
7880 sort_by_digest = sort_by_digest_4_4;
7881 opti_type = OPTI_TYPE_ZERO_BYTE;
7882 dgst_pos0 = 0;
7883 dgst_pos1 = 1;
7884 dgst_pos2 = 2;
7885 dgst_pos3 = 3;
7886 break;
7887
7888 case 1700: hash_type = HASH_TYPE_SHA512;
7889 salt_type = SALT_TYPE_NONE;
7890 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7891 opts_type = OPTS_TYPE_PT_GENERATE_BE
7892 | OPTS_TYPE_PT_ADD80
7893 | OPTS_TYPE_PT_ADDBITS15;
7894 kern_type = KERN_TYPE_SHA512;
7895 dgst_size = DGST_SIZE_8_8;
7896 parse_func = sha512_parse_hash;
7897 sort_by_digest = sort_by_digest_8_8;
7898 opti_type = OPTI_TYPE_ZERO_BYTE
7899 | OPTI_TYPE_PRECOMPUTE_INIT
7900 | OPTI_TYPE_PRECOMPUTE_MERKLE
7901 | OPTI_TYPE_EARLY_SKIP
7902 | OPTI_TYPE_NOT_ITERATED
7903 | OPTI_TYPE_NOT_SALTED
7904 | OPTI_TYPE_USES_BITS_64
7905 | OPTI_TYPE_RAW_HASH;
7906 dgst_pos0 = 14;
7907 dgst_pos1 = 15;
7908 dgst_pos2 = 6;
7909 dgst_pos3 = 7;
7910 break;
7911
7912 case 1710: hash_type = HASH_TYPE_SHA512;
7913 salt_type = SALT_TYPE_INTERN;
7914 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7915 opts_type = OPTS_TYPE_PT_GENERATE_BE
7916 | OPTS_TYPE_ST_ADD80
7917 | OPTS_TYPE_ST_ADDBITS15;
7918 kern_type = KERN_TYPE_SHA512_PWSLT;
7919 dgst_size = DGST_SIZE_8_8;
7920 parse_func = sha512s_parse_hash;
7921 sort_by_digest = sort_by_digest_8_8;
7922 opti_type = OPTI_TYPE_ZERO_BYTE
7923 | OPTI_TYPE_PRECOMPUTE_INIT
7924 | OPTI_TYPE_PRECOMPUTE_MERKLE
7925 | OPTI_TYPE_EARLY_SKIP
7926 | OPTI_TYPE_NOT_ITERATED
7927 | OPTI_TYPE_APPENDED_SALT
7928 | OPTI_TYPE_USES_BITS_64
7929 | OPTI_TYPE_RAW_HASH;
7930 dgst_pos0 = 14;
7931 dgst_pos1 = 15;
7932 dgst_pos2 = 6;
7933 dgst_pos3 = 7;
7934 break;
7935
7936 case 1711: hash_type = HASH_TYPE_SHA512;
7937 salt_type = SALT_TYPE_EMBEDDED;
7938 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7939 opts_type = OPTS_TYPE_PT_GENERATE_BE
7940 | OPTS_TYPE_ST_ADD80
7941 | OPTS_TYPE_ST_ADDBITS15;
7942 kern_type = KERN_TYPE_SHA512_PWSLT;
7943 dgst_size = DGST_SIZE_8_8;
7944 parse_func = sha512b64s_parse_hash;
7945 sort_by_digest = sort_by_digest_8_8;
7946 opti_type = OPTI_TYPE_ZERO_BYTE
7947 | OPTI_TYPE_PRECOMPUTE_INIT
7948 | OPTI_TYPE_PRECOMPUTE_MERKLE
7949 | OPTI_TYPE_EARLY_SKIP
7950 | OPTI_TYPE_NOT_ITERATED
7951 | OPTI_TYPE_APPENDED_SALT
7952 | OPTI_TYPE_USES_BITS_64
7953 | OPTI_TYPE_RAW_HASH;
7954 dgst_pos0 = 14;
7955 dgst_pos1 = 15;
7956 dgst_pos2 = 6;
7957 dgst_pos3 = 7;
7958 break;
7959
7960 case 1720: hash_type = HASH_TYPE_SHA512;
7961 salt_type = SALT_TYPE_INTERN;
7962 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7963 opts_type = OPTS_TYPE_PT_GENERATE_BE
7964 | OPTS_TYPE_PT_ADD80
7965 | OPTS_TYPE_PT_ADDBITS15;
7966 kern_type = KERN_TYPE_SHA512_SLTPW;
7967 dgst_size = DGST_SIZE_8_8;
7968 parse_func = sha512s_parse_hash;
7969 sort_by_digest = sort_by_digest_8_8;
7970 opti_type = OPTI_TYPE_ZERO_BYTE
7971 | OPTI_TYPE_PRECOMPUTE_INIT
7972 | OPTI_TYPE_PRECOMPUTE_MERKLE
7973 | OPTI_TYPE_EARLY_SKIP
7974 | OPTI_TYPE_NOT_ITERATED
7975 | OPTI_TYPE_PREPENDED_SALT
7976 | OPTI_TYPE_USES_BITS_64
7977 | OPTI_TYPE_RAW_HASH;
7978 dgst_pos0 = 14;
7979 dgst_pos1 = 15;
7980 dgst_pos2 = 6;
7981 dgst_pos3 = 7;
7982 break;
7983
7984 case 1722: hash_type = HASH_TYPE_SHA512;
7985 salt_type = SALT_TYPE_EMBEDDED;
7986 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7987 opts_type = OPTS_TYPE_PT_GENERATE_BE
7988 | OPTS_TYPE_PT_ADD80
7989 | OPTS_TYPE_PT_ADDBITS15
7990 | OPTS_TYPE_ST_HEX;
7991 kern_type = KERN_TYPE_SHA512_SLTPW;
7992 dgst_size = DGST_SIZE_8_8;
7993 parse_func = osx512_parse_hash;
7994 sort_by_digest = sort_by_digest_8_8;
7995 opti_type = OPTI_TYPE_ZERO_BYTE
7996 | OPTI_TYPE_PRECOMPUTE_INIT
7997 | OPTI_TYPE_PRECOMPUTE_MERKLE
7998 | OPTI_TYPE_EARLY_SKIP
7999 | OPTI_TYPE_NOT_ITERATED
8000 | OPTI_TYPE_PREPENDED_SALT
8001 | OPTI_TYPE_USES_BITS_64
8002 | OPTI_TYPE_RAW_HASH;
8003 dgst_pos0 = 14;
8004 dgst_pos1 = 15;
8005 dgst_pos2 = 6;
8006 dgst_pos3 = 7;
8007 break;
8008
8009 case 1730: hash_type = HASH_TYPE_SHA512;
8010 salt_type = SALT_TYPE_INTERN;
8011 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8012 opts_type = OPTS_TYPE_PT_GENERATE_BE
8013 | OPTS_TYPE_PT_UNICODE
8014 | OPTS_TYPE_ST_ADD80
8015 | OPTS_TYPE_ST_ADDBITS15;
8016 kern_type = KERN_TYPE_SHA512_PWSLTU;
8017 dgst_size = DGST_SIZE_8_8;
8018 parse_func = sha512s_parse_hash;
8019 sort_by_digest = sort_by_digest_8_8;
8020 opti_type = OPTI_TYPE_ZERO_BYTE
8021 | OPTI_TYPE_PRECOMPUTE_INIT
8022 | OPTI_TYPE_PRECOMPUTE_MERKLE
8023 | OPTI_TYPE_EARLY_SKIP
8024 | OPTI_TYPE_NOT_ITERATED
8025 | OPTI_TYPE_APPENDED_SALT
8026 | OPTI_TYPE_USES_BITS_64
8027 | OPTI_TYPE_RAW_HASH;
8028 dgst_pos0 = 14;
8029 dgst_pos1 = 15;
8030 dgst_pos2 = 6;
8031 dgst_pos3 = 7;
8032 break;
8033
8034 case 1731: hash_type = HASH_TYPE_SHA512;
8035 salt_type = SALT_TYPE_EMBEDDED;
8036 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8037 opts_type = OPTS_TYPE_PT_GENERATE_BE
8038 | OPTS_TYPE_PT_UNICODE
8039 | OPTS_TYPE_ST_ADD80
8040 | OPTS_TYPE_ST_ADDBITS15
8041 | OPTS_TYPE_ST_HEX;
8042 kern_type = KERN_TYPE_SHA512_PWSLTU;
8043 dgst_size = DGST_SIZE_8_8;
8044 parse_func = mssql2012_parse_hash;
8045 sort_by_digest = sort_by_digest_8_8;
8046 opti_type = OPTI_TYPE_ZERO_BYTE
8047 | OPTI_TYPE_PRECOMPUTE_INIT
8048 | OPTI_TYPE_PRECOMPUTE_MERKLE
8049 | OPTI_TYPE_EARLY_SKIP
8050 | OPTI_TYPE_NOT_ITERATED
8051 | OPTI_TYPE_APPENDED_SALT
8052 | OPTI_TYPE_USES_BITS_64
8053 | OPTI_TYPE_RAW_HASH;
8054 dgst_pos0 = 14;
8055 dgst_pos1 = 15;
8056 dgst_pos2 = 6;
8057 dgst_pos3 = 7;
8058 break;
8059
8060 case 1740: hash_type = HASH_TYPE_SHA512;
8061 salt_type = SALT_TYPE_INTERN;
8062 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8063 opts_type = OPTS_TYPE_PT_GENERATE_BE
8064 | OPTS_TYPE_PT_ADD80
8065 | OPTS_TYPE_PT_ADDBITS15
8066 | OPTS_TYPE_PT_UNICODE;
8067 kern_type = KERN_TYPE_SHA512_SLTPWU;
8068 dgst_size = DGST_SIZE_8_8;
8069 parse_func = sha512s_parse_hash;
8070 sort_by_digest = sort_by_digest_8_8;
8071 opti_type = OPTI_TYPE_ZERO_BYTE
8072 | OPTI_TYPE_PRECOMPUTE_INIT
8073 | OPTI_TYPE_PRECOMPUTE_MERKLE
8074 | OPTI_TYPE_EARLY_SKIP
8075 | OPTI_TYPE_NOT_ITERATED
8076 | OPTI_TYPE_PREPENDED_SALT
8077 | OPTI_TYPE_USES_BITS_64
8078 | OPTI_TYPE_RAW_HASH;
8079 dgst_pos0 = 14;
8080 dgst_pos1 = 15;
8081 dgst_pos2 = 6;
8082 dgst_pos3 = 7;
8083 break;
8084
8085 case 1750: hash_type = HASH_TYPE_SHA512;
8086 salt_type = SALT_TYPE_INTERN;
8087 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8088 opts_type = OPTS_TYPE_PT_GENERATE_BE
8089 | OPTS_TYPE_ST_ADD80;
8090 kern_type = KERN_TYPE_HMACSHA512_PW;
8091 dgst_size = DGST_SIZE_8_8;
8092 parse_func = hmacsha512_parse_hash;
8093 sort_by_digest = sort_by_digest_8_8;
8094 opti_type = OPTI_TYPE_ZERO_BYTE
8095 | OPTI_TYPE_USES_BITS_64
8096 | OPTI_TYPE_NOT_ITERATED;
8097 dgst_pos0 = 14;
8098 dgst_pos1 = 15;
8099 dgst_pos2 = 6;
8100 dgst_pos3 = 7;
8101 break;
8102
8103 case 1760: hash_type = HASH_TYPE_SHA512;
8104 salt_type = SALT_TYPE_INTERN;
8105 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8106 opts_type = OPTS_TYPE_PT_GENERATE_BE
8107 | OPTS_TYPE_PT_ADD80
8108 | OPTS_TYPE_PT_ADDBITS15;
8109 kern_type = KERN_TYPE_HMACSHA512_SLT;
8110 dgst_size = DGST_SIZE_8_8;
8111 parse_func = hmacsha512_parse_hash;
8112 sort_by_digest = sort_by_digest_8_8;
8113 opti_type = OPTI_TYPE_ZERO_BYTE
8114 | OPTI_TYPE_USES_BITS_64
8115 | OPTI_TYPE_NOT_ITERATED;
8116 dgst_pos0 = 14;
8117 dgst_pos1 = 15;
8118 dgst_pos2 = 6;
8119 dgst_pos3 = 7;
8120 break;
8121
8122 case 1800: hash_type = HASH_TYPE_SHA512;
8123 salt_type = SALT_TYPE_EMBEDDED;
8124 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8125 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8126 kern_type = KERN_TYPE_SHA512CRYPT;
8127 dgst_size = DGST_SIZE_8_8;
8128 parse_func = sha512crypt_parse_hash;
8129 sort_by_digest = sort_by_digest_8_8;
8130 opti_type = OPTI_TYPE_ZERO_BYTE
8131 | OPTI_TYPE_USES_BITS_64;
8132 dgst_pos0 = 0;
8133 dgst_pos1 = 1;
8134 dgst_pos2 = 2;
8135 dgst_pos3 = 3;
8136 break;
8137
8138 case 2100: hash_type = HASH_TYPE_DCC2;
8139 salt_type = SALT_TYPE_EMBEDDED;
8140 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8141 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8142 | OPTS_TYPE_ST_LOWER
8143 | OPTS_TYPE_ST_UNICODE;
8144 kern_type = KERN_TYPE_DCC2;
8145 dgst_size = DGST_SIZE_4_4;
8146 parse_func = dcc2_parse_hash;
8147 sort_by_digest = sort_by_digest_4_4;
8148 opti_type = OPTI_TYPE_ZERO_BYTE
8149 | OPTI_TYPE_SLOW_HASH_SIMD;
8150 dgst_pos0 = 0;
8151 dgst_pos1 = 1;
8152 dgst_pos2 = 2;
8153 dgst_pos3 = 3;
8154 break;
8155
8156 case 2400: hash_type = HASH_TYPE_MD5;
8157 salt_type = SALT_TYPE_NONE;
8158 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8159 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8160 kern_type = KERN_TYPE_MD5PIX;
8161 dgst_size = DGST_SIZE_4_4;
8162 parse_func = md5pix_parse_hash;
8163 sort_by_digest = sort_by_digest_4_4;
8164 opti_type = OPTI_TYPE_ZERO_BYTE
8165 | OPTI_TYPE_PRECOMPUTE_INIT
8166 | OPTI_TYPE_PRECOMPUTE_MERKLE
8167 | OPTI_TYPE_EARLY_SKIP
8168 | OPTI_TYPE_NOT_ITERATED
8169 | OPTI_TYPE_NOT_SALTED;
8170 dgst_pos0 = 0;
8171 dgst_pos1 = 3;
8172 dgst_pos2 = 2;
8173 dgst_pos3 = 1;
8174 break;
8175
8176 case 2410: hash_type = HASH_TYPE_MD5;
8177 salt_type = SALT_TYPE_INTERN;
8178 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8179 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8180 kern_type = KERN_TYPE_MD5ASA;
8181 dgst_size = DGST_SIZE_4_4;
8182 parse_func = md5asa_parse_hash;
8183 sort_by_digest = sort_by_digest_4_4;
8184 opti_type = OPTI_TYPE_ZERO_BYTE
8185 | OPTI_TYPE_PRECOMPUTE_INIT
8186 | OPTI_TYPE_PRECOMPUTE_MERKLE
8187 | OPTI_TYPE_EARLY_SKIP
8188 | OPTI_TYPE_NOT_ITERATED;
8189 dgst_pos0 = 0;
8190 dgst_pos1 = 3;
8191 dgst_pos2 = 2;
8192 dgst_pos3 = 1;
8193 break;
8194
8195 case 2500: hash_type = HASH_TYPE_WPA;
8196 salt_type = SALT_TYPE_EMBEDDED;
8197 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8198 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8199 kern_type = KERN_TYPE_WPA;
8200 dgst_size = DGST_SIZE_4_4;
8201 parse_func = wpa_parse_hash;
8202 sort_by_digest = sort_by_digest_4_4;
8203 opti_type = OPTI_TYPE_ZERO_BYTE
8204 | OPTI_TYPE_SLOW_HASH_SIMD;
8205 dgst_pos0 = 0;
8206 dgst_pos1 = 1;
8207 dgst_pos2 = 2;
8208 dgst_pos3 = 3;
8209 break;
8210
8211 case 2600: hash_type = HASH_TYPE_MD5;
8212 salt_type = SALT_TYPE_VIRTUAL;
8213 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8214 opts_type = OPTS_TYPE_PT_GENERATE_LE
8215 | OPTS_TYPE_PT_ADD80
8216 | OPTS_TYPE_PT_ADDBITS14
8217 | OPTS_TYPE_ST_ADD80;
8218 kern_type = KERN_TYPE_MD55_PWSLT1;
8219 dgst_size = DGST_SIZE_4_4;
8220 parse_func = md5md5_parse_hash;
8221 sort_by_digest = sort_by_digest_4_4;
8222 opti_type = OPTI_TYPE_ZERO_BYTE
8223 | OPTI_TYPE_PRECOMPUTE_INIT
8224 | OPTI_TYPE_PRECOMPUTE_MERKLE
8225 | OPTI_TYPE_EARLY_SKIP;
8226 dgst_pos0 = 0;
8227 dgst_pos1 = 3;
8228 dgst_pos2 = 2;
8229 dgst_pos3 = 1;
8230 break;
8231
8232 case 2611: hash_type = HASH_TYPE_MD5;
8233 salt_type = SALT_TYPE_INTERN;
8234 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8235 opts_type = OPTS_TYPE_PT_GENERATE_LE
8236 | OPTS_TYPE_PT_ADD80
8237 | OPTS_TYPE_PT_ADDBITS14
8238 | OPTS_TYPE_ST_ADD80;
8239 kern_type = KERN_TYPE_MD55_PWSLT1;
8240 dgst_size = DGST_SIZE_4_4;
8241 parse_func = vb3_parse_hash;
8242 sort_by_digest = sort_by_digest_4_4;
8243 opti_type = OPTI_TYPE_ZERO_BYTE
8244 | OPTI_TYPE_PRECOMPUTE_INIT
8245 | OPTI_TYPE_PRECOMPUTE_MERKLE
8246 | OPTI_TYPE_EARLY_SKIP;
8247 dgst_pos0 = 0;
8248 dgst_pos1 = 3;
8249 dgst_pos2 = 2;
8250 dgst_pos3 = 1;
8251 break;
8252
8253 case 2612: hash_type = HASH_TYPE_MD5;
8254 salt_type = SALT_TYPE_EMBEDDED;
8255 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8256 opts_type = OPTS_TYPE_PT_GENERATE_LE
8257 | OPTS_TYPE_PT_ADD80
8258 | OPTS_TYPE_PT_ADDBITS14
8259 | OPTS_TYPE_ST_ADD80
8260 | OPTS_TYPE_ST_HEX;
8261 kern_type = KERN_TYPE_MD55_PWSLT1;
8262 dgst_size = DGST_SIZE_4_4;
8263 parse_func = phps_parse_hash;
8264 sort_by_digest = sort_by_digest_4_4;
8265 opti_type = OPTI_TYPE_ZERO_BYTE
8266 | OPTI_TYPE_PRECOMPUTE_INIT
8267 | OPTI_TYPE_PRECOMPUTE_MERKLE
8268 | OPTI_TYPE_EARLY_SKIP;
8269 dgst_pos0 = 0;
8270 dgst_pos1 = 3;
8271 dgst_pos2 = 2;
8272 dgst_pos3 = 1;
8273 break;
8274
8275 case 2711: hash_type = HASH_TYPE_MD5;
8276 salt_type = SALT_TYPE_INTERN;
8277 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8278 opts_type = OPTS_TYPE_PT_GENERATE_LE
8279 | OPTS_TYPE_PT_ADD80
8280 | OPTS_TYPE_PT_ADDBITS14
8281 | OPTS_TYPE_ST_ADD80;
8282 kern_type = KERN_TYPE_MD55_PWSLT2;
8283 dgst_size = DGST_SIZE_4_4;
8284 parse_func = vb30_parse_hash;
8285 sort_by_digest = sort_by_digest_4_4;
8286 opti_type = OPTI_TYPE_ZERO_BYTE
8287 | OPTI_TYPE_PRECOMPUTE_INIT
8288 | OPTI_TYPE_EARLY_SKIP;
8289 dgst_pos0 = 0;
8290 dgst_pos1 = 3;
8291 dgst_pos2 = 2;
8292 dgst_pos3 = 1;
8293 break;
8294
8295 case 2811: hash_type = HASH_TYPE_MD5;
8296 salt_type = SALT_TYPE_INTERN;
8297 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8298 opts_type = OPTS_TYPE_PT_GENERATE_LE
8299 | OPTS_TYPE_PT_ADD80
8300 | OPTS_TYPE_PT_ADDBITS14;
8301 kern_type = KERN_TYPE_MD55_SLTPW;
8302 dgst_size = DGST_SIZE_4_4;
8303 parse_func = ipb2_parse_hash;
8304 sort_by_digest = sort_by_digest_4_4;
8305 opti_type = OPTI_TYPE_ZERO_BYTE
8306 | OPTI_TYPE_PRECOMPUTE_INIT
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 3000: hash_type = HASH_TYPE_LM;
8315 salt_type = SALT_TYPE_NONE;
8316 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8317 opts_type = OPTS_TYPE_PT_GENERATE_LE
8318 | OPTS_TYPE_PT_UPPER
8319 | OPTS_TYPE_PT_BITSLICE;
8320 kern_type = KERN_TYPE_LM;
8321 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8322 parse_func = lm_parse_hash;
8323 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8324 opti_type = OPTI_TYPE_ZERO_BYTE
8325 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8326 dgst_pos0 = 0;
8327 dgst_pos1 = 1;
8328 dgst_pos2 = 2;
8329 dgst_pos3 = 3;
8330 break;
8331
8332 case 3100: hash_type = HASH_TYPE_ORACLEH;
8333 salt_type = SALT_TYPE_INTERN;
8334 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8335 opts_type = OPTS_TYPE_PT_GENERATE_LE
8336 | OPTS_TYPE_PT_UPPER
8337 | OPTS_TYPE_ST_UPPER;
8338 kern_type = KERN_TYPE_ORACLEH;
8339 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8340 parse_func = oracleh_parse_hash;
8341 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8342 opti_type = OPTI_TYPE_ZERO_BYTE;
8343 dgst_pos0 = 0;
8344 dgst_pos1 = 1;
8345 dgst_pos2 = 2;
8346 dgst_pos3 = 3;
8347 break;
8348
8349 case 3200: hash_type = HASH_TYPE_BCRYPT;
8350 salt_type = SALT_TYPE_EMBEDDED;
8351 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8352 opts_type = OPTS_TYPE_PT_GENERATE_LE
8353 | OPTS_TYPE_ST_GENERATE_LE;
8354 kern_type = KERN_TYPE_BCRYPT;
8355 dgst_size = DGST_SIZE_4_6;
8356 parse_func = bcrypt_parse_hash;
8357 sort_by_digest = sort_by_digest_4_6;
8358 opti_type = OPTI_TYPE_ZERO_BYTE;
8359 dgst_pos0 = 0;
8360 dgst_pos1 = 1;
8361 dgst_pos2 = 2;
8362 dgst_pos3 = 3;
8363 break;
8364
8365 case 3710: hash_type = HASH_TYPE_MD5;
8366 salt_type = SALT_TYPE_INTERN;
8367 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8368 opts_type = OPTS_TYPE_PT_GENERATE_LE
8369 | OPTS_TYPE_PT_ADD80
8370 | OPTS_TYPE_PT_ADDBITS14;
8371 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8372 dgst_size = DGST_SIZE_4_4;
8373 parse_func = md5s_parse_hash;
8374 sort_by_digest = sort_by_digest_4_4;
8375 opti_type = OPTI_TYPE_ZERO_BYTE
8376 | OPTI_TYPE_PRECOMPUTE_INIT
8377 | OPTI_TYPE_PRECOMPUTE_MERKLE
8378 | OPTI_TYPE_EARLY_SKIP;
8379 dgst_pos0 = 0;
8380 dgst_pos1 = 3;
8381 dgst_pos2 = 2;
8382 dgst_pos3 = 1;
8383 break;
8384
8385 case 3711: hash_type = HASH_TYPE_MD5;
8386 salt_type = SALT_TYPE_EMBEDDED;
8387 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8388 opts_type = OPTS_TYPE_PT_GENERATE_LE
8389 | OPTS_TYPE_PT_ADD80
8390 | OPTS_TYPE_PT_ADDBITS14;
8391 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8392 dgst_size = DGST_SIZE_4_4;
8393 parse_func = mediawiki_b_parse_hash;
8394 sort_by_digest = sort_by_digest_4_4;
8395 opti_type = OPTI_TYPE_ZERO_BYTE
8396 | OPTI_TYPE_PRECOMPUTE_INIT
8397 | OPTI_TYPE_PRECOMPUTE_MERKLE
8398 | OPTI_TYPE_EARLY_SKIP;
8399 dgst_pos0 = 0;
8400 dgst_pos1 = 3;
8401 dgst_pos2 = 2;
8402 dgst_pos3 = 1;
8403 break;
8404
8405 case 3800: hash_type = HASH_TYPE_MD5;
8406 salt_type = SALT_TYPE_INTERN;
8407 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8408 opts_type = OPTS_TYPE_PT_GENERATE_LE
8409 | OPTS_TYPE_ST_ADDBITS14;
8410 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
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 | OPTI_TYPE_NOT_ITERATED
8419 | OPTI_TYPE_RAW_HASH;
8420 dgst_pos0 = 0;
8421 dgst_pos1 = 3;
8422 dgst_pos2 = 2;
8423 dgst_pos3 = 1;
8424 break;
8425
8426 case 4300: hash_type = HASH_TYPE_MD5;
8427 salt_type = SALT_TYPE_VIRTUAL;
8428 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8429 opts_type = OPTS_TYPE_PT_GENERATE_LE
8430 | OPTS_TYPE_PT_ADD80
8431 | OPTS_TYPE_PT_ADDBITS14
8432 | OPTS_TYPE_ST_ADD80;
8433 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8434 dgst_size = DGST_SIZE_4_4;
8435 parse_func = md5md5_parse_hash;
8436 sort_by_digest = sort_by_digest_4_4;
8437 opti_type = OPTI_TYPE_ZERO_BYTE
8438 | OPTI_TYPE_PRECOMPUTE_INIT
8439 | OPTI_TYPE_PRECOMPUTE_MERKLE
8440 | OPTI_TYPE_EARLY_SKIP;
8441 dgst_pos0 = 0;
8442 dgst_pos1 = 3;
8443 dgst_pos2 = 2;
8444 dgst_pos3 = 1;
8445 break;
8446
8447
8448 case 4400: hash_type = HASH_TYPE_MD5;
8449 salt_type = SALT_TYPE_NONE;
8450 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8451 opts_type = OPTS_TYPE_PT_GENERATE_BE
8452 | OPTS_TYPE_PT_ADD80
8453 | OPTS_TYPE_PT_ADDBITS15;
8454 kern_type = KERN_TYPE_MD5_SHA1;
8455 dgst_size = DGST_SIZE_4_4;
8456 parse_func = md5_parse_hash;
8457 sort_by_digest = sort_by_digest_4_4;
8458 opti_type = OPTI_TYPE_ZERO_BYTE
8459 | OPTI_TYPE_PRECOMPUTE_INIT
8460 | OPTI_TYPE_PRECOMPUTE_MERKLE
8461 | OPTI_TYPE_EARLY_SKIP
8462 | OPTI_TYPE_NOT_ITERATED
8463 | OPTI_TYPE_NOT_SALTED
8464 | OPTI_TYPE_RAW_HASH;
8465 dgst_pos0 = 0;
8466 dgst_pos1 = 3;
8467 dgst_pos2 = 2;
8468 dgst_pos3 = 1;
8469 break;
8470
8471 case 4500: hash_type = HASH_TYPE_SHA1;
8472 salt_type = SALT_TYPE_NONE;
8473 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8474 opts_type = OPTS_TYPE_PT_GENERATE_BE
8475 | OPTS_TYPE_PT_ADD80
8476 | OPTS_TYPE_PT_ADDBITS15;
8477 kern_type = KERN_TYPE_SHA11;
8478 dgst_size = DGST_SIZE_4_5;
8479 parse_func = sha1_parse_hash;
8480 sort_by_digest = sort_by_digest_4_5;
8481 opti_type = OPTI_TYPE_ZERO_BYTE
8482 | OPTI_TYPE_PRECOMPUTE_INIT
8483 | OPTI_TYPE_PRECOMPUTE_MERKLE
8484 | OPTI_TYPE_EARLY_SKIP
8485 | OPTI_TYPE_NOT_SALTED;
8486 dgst_pos0 = 3;
8487 dgst_pos1 = 4;
8488 dgst_pos2 = 2;
8489 dgst_pos3 = 1;
8490 break;
8491
8492 case 4700: hash_type = HASH_TYPE_SHA1;
8493 salt_type = SALT_TYPE_NONE;
8494 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8495 opts_type = OPTS_TYPE_PT_GENERATE_LE
8496 | OPTS_TYPE_PT_ADD80
8497 | OPTS_TYPE_PT_ADDBITS14;
8498 kern_type = KERN_TYPE_SHA1_MD5;
8499 dgst_size = DGST_SIZE_4_5;
8500 parse_func = sha1_parse_hash;
8501 sort_by_digest = sort_by_digest_4_5;
8502 opti_type = OPTI_TYPE_ZERO_BYTE
8503 | OPTI_TYPE_PRECOMPUTE_INIT
8504 | OPTI_TYPE_PRECOMPUTE_MERKLE
8505 | OPTI_TYPE_EARLY_SKIP
8506 | OPTI_TYPE_NOT_ITERATED
8507 | OPTI_TYPE_NOT_SALTED
8508 | OPTI_TYPE_RAW_HASH;
8509 dgst_pos0 = 3;
8510 dgst_pos1 = 4;
8511 dgst_pos2 = 2;
8512 dgst_pos3 = 1;
8513 break;
8514
8515 case 4800: hash_type = HASH_TYPE_MD5;
8516 salt_type = SALT_TYPE_EMBEDDED;
8517 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8518 opts_type = OPTS_TYPE_PT_GENERATE_LE
8519 | OPTS_TYPE_PT_ADDBITS14;
8520 kern_type = KERN_TYPE_MD5_CHAP;
8521 dgst_size = DGST_SIZE_4_4;
8522 parse_func = chap_parse_hash;
8523 sort_by_digest = sort_by_digest_4_4;
8524 opti_type = OPTI_TYPE_ZERO_BYTE
8525 | OPTI_TYPE_PRECOMPUTE_INIT
8526 | OPTI_TYPE_PRECOMPUTE_MERKLE
8527 | OPTI_TYPE_MEET_IN_MIDDLE
8528 | OPTI_TYPE_EARLY_SKIP
8529 | OPTI_TYPE_NOT_ITERATED
8530 | OPTI_TYPE_RAW_HASH;
8531 dgst_pos0 = 0;
8532 dgst_pos1 = 3;
8533 dgst_pos2 = 2;
8534 dgst_pos3 = 1;
8535 break;
8536
8537 case 4900: hash_type = HASH_TYPE_SHA1;
8538 salt_type = SALT_TYPE_INTERN;
8539 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8540 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8541 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8542 dgst_size = DGST_SIZE_4_5;
8543 parse_func = sha1s_parse_hash;
8544 sort_by_digest = sort_by_digest_4_5;
8545 opti_type = OPTI_TYPE_ZERO_BYTE
8546 | OPTI_TYPE_PRECOMPUTE_INIT
8547 | OPTI_TYPE_PRECOMPUTE_MERKLE
8548 | OPTI_TYPE_EARLY_SKIP;
8549 dgst_pos0 = 3;
8550 dgst_pos1 = 4;
8551 dgst_pos2 = 2;
8552 dgst_pos3 = 1;
8553 break;
8554
8555 case 5000: hash_type = HASH_TYPE_KECCAK;
8556 salt_type = SALT_TYPE_EMBEDDED;
8557 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8558 opts_type = OPTS_TYPE_PT_GENERATE_LE
8559 | OPTS_TYPE_PT_ADD01;
8560 kern_type = KERN_TYPE_KECCAK;
8561 dgst_size = DGST_SIZE_8_25;
8562 parse_func = keccak_parse_hash;
8563 sort_by_digest = sort_by_digest_8_25;
8564 opti_type = OPTI_TYPE_ZERO_BYTE
8565 | OPTI_TYPE_USES_BITS_64
8566 | OPTI_TYPE_RAW_HASH;
8567 dgst_pos0 = 2;
8568 dgst_pos1 = 3;
8569 dgst_pos2 = 4;
8570 dgst_pos3 = 5;
8571 break;
8572
8573 case 5100: hash_type = HASH_TYPE_MD5H;
8574 salt_type = SALT_TYPE_NONE;
8575 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8576 opts_type = OPTS_TYPE_PT_GENERATE_LE
8577 | OPTS_TYPE_PT_ADD80
8578 | OPTS_TYPE_PT_ADDBITS14;
8579 kern_type = KERN_TYPE_MD5H;
8580 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8581 parse_func = md5half_parse_hash;
8582 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8583 opti_type = OPTI_TYPE_ZERO_BYTE
8584 | OPTI_TYPE_RAW_HASH;
8585 dgst_pos0 = 0;
8586 dgst_pos1 = 1;
8587 dgst_pos2 = 2;
8588 dgst_pos3 = 3;
8589 break;
8590
8591 case 5200: hash_type = HASH_TYPE_SHA256;
8592 salt_type = SALT_TYPE_EMBEDDED;
8593 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8594 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8595 kern_type = KERN_TYPE_PSAFE3;
8596 dgst_size = DGST_SIZE_4_8;
8597 parse_func = psafe3_parse_hash;
8598 sort_by_digest = sort_by_digest_4_8;
8599 opti_type = OPTI_TYPE_ZERO_BYTE;
8600 dgst_pos0 = 0;
8601 dgst_pos1 = 1;
8602 dgst_pos2 = 2;
8603 dgst_pos3 = 3;
8604 break;
8605
8606 case 5300: hash_type = HASH_TYPE_MD5;
8607 salt_type = SALT_TYPE_EMBEDDED;
8608 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8609 opts_type = OPTS_TYPE_PT_GENERATE_LE
8610 | OPTS_TYPE_ST_ADD80;
8611 kern_type = KERN_TYPE_IKEPSK_MD5;
8612 dgst_size = DGST_SIZE_4_4;
8613 parse_func = ikepsk_md5_parse_hash;
8614 sort_by_digest = sort_by_digest_4_4;
8615 opti_type = OPTI_TYPE_ZERO_BYTE;
8616 dgst_pos0 = 0;
8617 dgst_pos1 = 3;
8618 dgst_pos2 = 2;
8619 dgst_pos3 = 1;
8620 break;
8621
8622 case 5400: hash_type = HASH_TYPE_SHA1;
8623 salt_type = SALT_TYPE_EMBEDDED;
8624 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8625 opts_type = OPTS_TYPE_PT_GENERATE_BE
8626 | OPTS_TYPE_ST_ADD80;
8627 kern_type = KERN_TYPE_IKEPSK_SHA1;
8628 dgst_size = DGST_SIZE_4_5;
8629 parse_func = ikepsk_sha1_parse_hash;
8630 sort_by_digest = sort_by_digest_4_5;
8631 opti_type = OPTI_TYPE_ZERO_BYTE;
8632 dgst_pos0 = 3;
8633 dgst_pos1 = 4;
8634 dgst_pos2 = 2;
8635 dgst_pos3 = 1;
8636 break;
8637
8638 case 5500: hash_type = HASH_TYPE_NETNTLM;
8639 salt_type = SALT_TYPE_EMBEDDED;
8640 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8641 opts_type = OPTS_TYPE_PT_GENERATE_LE
8642 | OPTS_TYPE_PT_ADD80
8643 | OPTS_TYPE_PT_ADDBITS14
8644 | OPTS_TYPE_PT_UNICODE
8645 | OPTS_TYPE_ST_HEX;
8646 kern_type = KERN_TYPE_NETNTLMv1;
8647 dgst_size = DGST_SIZE_4_4;
8648 parse_func = netntlmv1_parse_hash;
8649 sort_by_digest = sort_by_digest_4_4;
8650 opti_type = OPTI_TYPE_ZERO_BYTE
8651 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8652 dgst_pos0 = 0;
8653 dgst_pos1 = 1;
8654 dgst_pos2 = 2;
8655 dgst_pos3 = 3;
8656 break;
8657
8658 case 5600: hash_type = HASH_TYPE_MD5;
8659 salt_type = SALT_TYPE_EMBEDDED;
8660 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8661 opts_type = OPTS_TYPE_PT_GENERATE_LE
8662 | OPTS_TYPE_PT_ADD80
8663 | OPTS_TYPE_PT_ADDBITS14
8664 | OPTS_TYPE_PT_UNICODE;
8665 kern_type = KERN_TYPE_NETNTLMv2;
8666 dgst_size = DGST_SIZE_4_4;
8667 parse_func = netntlmv2_parse_hash;
8668 sort_by_digest = sort_by_digest_4_4;
8669 opti_type = OPTI_TYPE_ZERO_BYTE;
8670 dgst_pos0 = 0;
8671 dgst_pos1 = 3;
8672 dgst_pos2 = 2;
8673 dgst_pos3 = 1;
8674 break;
8675
8676 case 5700: hash_type = HASH_TYPE_SHA256;
8677 salt_type = SALT_TYPE_NONE;
8678 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8679 opts_type = OPTS_TYPE_PT_GENERATE_BE
8680 | OPTS_TYPE_PT_ADD80
8681 | OPTS_TYPE_PT_ADDBITS15;
8682 kern_type = KERN_TYPE_SHA256;
8683 dgst_size = DGST_SIZE_4_8;
8684 parse_func = cisco4_parse_hash;
8685 sort_by_digest = sort_by_digest_4_8;
8686 opti_type = OPTI_TYPE_ZERO_BYTE
8687 | OPTI_TYPE_PRECOMPUTE_INIT
8688 | OPTI_TYPE_PRECOMPUTE_MERKLE
8689 | OPTI_TYPE_EARLY_SKIP
8690 | OPTI_TYPE_NOT_ITERATED
8691 | OPTI_TYPE_NOT_SALTED
8692 | OPTI_TYPE_RAW_HASH;
8693 dgst_pos0 = 3;
8694 dgst_pos1 = 7;
8695 dgst_pos2 = 2;
8696 dgst_pos3 = 6;
8697 break;
8698
8699 case 5800: hash_type = HASH_TYPE_SHA1;
8700 salt_type = SALT_TYPE_INTERN;
8701 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8702 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8703 | OPTS_TYPE_ST_ADD80;
8704 kern_type = KERN_TYPE_ANDROIDPIN;
8705 dgst_size = DGST_SIZE_4_5;
8706 parse_func = androidpin_parse_hash;
8707 sort_by_digest = sort_by_digest_4_5;
8708 opti_type = OPTI_TYPE_ZERO_BYTE;
8709 dgst_pos0 = 0;
8710 dgst_pos1 = 1;
8711 dgst_pos2 = 2;
8712 dgst_pos3 = 3;
8713 break;
8714
8715 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8716 salt_type = SALT_TYPE_NONE;
8717 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8718 opts_type = OPTS_TYPE_PT_GENERATE_LE
8719 | OPTS_TYPE_PT_ADD80;
8720 kern_type = KERN_TYPE_RIPEMD160;
8721 dgst_size = DGST_SIZE_4_5;
8722 parse_func = ripemd160_parse_hash;
8723 sort_by_digest = sort_by_digest_4_5;
8724 opti_type = OPTI_TYPE_ZERO_BYTE;
8725 dgst_pos0 = 0;
8726 dgst_pos1 = 1;
8727 dgst_pos2 = 2;
8728 dgst_pos3 = 3;
8729 break;
8730
8731 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8732 salt_type = SALT_TYPE_NONE;
8733 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8734 opts_type = OPTS_TYPE_PT_GENERATE_BE
8735 | OPTS_TYPE_PT_ADD80;
8736 kern_type = KERN_TYPE_WHIRLPOOL;
8737 dgst_size = DGST_SIZE_4_16;
8738 parse_func = whirlpool_parse_hash;
8739 sort_by_digest = sort_by_digest_4_16;
8740 opti_type = OPTI_TYPE_ZERO_BYTE;
8741 dgst_pos0 = 0;
8742 dgst_pos1 = 1;
8743 dgst_pos2 = 2;
8744 dgst_pos3 = 3;
8745 break;
8746
8747 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8748 salt_type = SALT_TYPE_EMBEDDED;
8749 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8750 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8751 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8752 dgst_size = DGST_SIZE_4_5;
8753 parse_func = truecrypt_parse_hash_2k;
8754 sort_by_digest = sort_by_digest_4_5;
8755 opti_type = OPTI_TYPE_ZERO_BYTE;
8756 dgst_pos0 = 0;
8757 dgst_pos1 = 1;
8758 dgst_pos2 = 2;
8759 dgst_pos3 = 3;
8760 break;
8761
8762 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8763 salt_type = SALT_TYPE_EMBEDDED;
8764 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8765 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8766 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8767 dgst_size = DGST_SIZE_4_5;
8768 parse_func = truecrypt_parse_hash_2k;
8769 sort_by_digest = sort_by_digest_4_5;
8770 opti_type = OPTI_TYPE_ZERO_BYTE;
8771 dgst_pos0 = 0;
8772 dgst_pos1 = 1;
8773 dgst_pos2 = 2;
8774 dgst_pos3 = 3;
8775 break;
8776
8777 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8778 salt_type = SALT_TYPE_EMBEDDED;
8779 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8780 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8781 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8782 dgst_size = DGST_SIZE_4_5;
8783 parse_func = truecrypt_parse_hash_2k;
8784 sort_by_digest = sort_by_digest_4_5;
8785 opti_type = OPTI_TYPE_ZERO_BYTE;
8786 dgst_pos0 = 0;
8787 dgst_pos1 = 1;
8788 dgst_pos2 = 2;
8789 dgst_pos3 = 3;
8790 break;
8791
8792 case 6221: hash_type = HASH_TYPE_SHA512;
8793 salt_type = SALT_TYPE_EMBEDDED;
8794 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8795 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8796 kern_type = KERN_TYPE_TCSHA512_XTS512;
8797 dgst_size = DGST_SIZE_8_8;
8798 parse_func = truecrypt_parse_hash_1k;
8799 sort_by_digest = sort_by_digest_8_8;
8800 opti_type = OPTI_TYPE_ZERO_BYTE
8801 | OPTI_TYPE_USES_BITS_64;
8802 dgst_pos0 = 0;
8803 dgst_pos1 = 1;
8804 dgst_pos2 = 2;
8805 dgst_pos3 = 3;
8806 break;
8807
8808 case 6222: hash_type = HASH_TYPE_SHA512;
8809 salt_type = SALT_TYPE_EMBEDDED;
8810 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8811 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8812 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8813 dgst_size = DGST_SIZE_8_8;
8814 parse_func = truecrypt_parse_hash_1k;
8815 sort_by_digest = sort_by_digest_8_8;
8816 opti_type = OPTI_TYPE_ZERO_BYTE
8817 | OPTI_TYPE_USES_BITS_64;
8818 dgst_pos0 = 0;
8819 dgst_pos1 = 1;
8820 dgst_pos2 = 2;
8821 dgst_pos3 = 3;
8822 break;
8823
8824 case 6223: hash_type = HASH_TYPE_SHA512;
8825 salt_type = SALT_TYPE_EMBEDDED;
8826 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8827 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8828 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8829 dgst_size = DGST_SIZE_8_8;
8830 parse_func = truecrypt_parse_hash_1k;
8831 sort_by_digest = sort_by_digest_8_8;
8832 opti_type = OPTI_TYPE_ZERO_BYTE
8833 | OPTI_TYPE_USES_BITS_64;
8834 dgst_pos0 = 0;
8835 dgst_pos1 = 1;
8836 dgst_pos2 = 2;
8837 dgst_pos3 = 3;
8838 break;
8839
8840 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8841 salt_type = SALT_TYPE_EMBEDDED;
8842 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8843 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8844 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8845 dgst_size = DGST_SIZE_4_8;
8846 parse_func = truecrypt_parse_hash_1k;
8847 sort_by_digest = sort_by_digest_4_8;
8848 opti_type = OPTI_TYPE_ZERO_BYTE;
8849 dgst_pos0 = 0;
8850 dgst_pos1 = 1;
8851 dgst_pos2 = 2;
8852 dgst_pos3 = 3;
8853 break;
8854
8855 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8856 salt_type = SALT_TYPE_EMBEDDED;
8857 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8858 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8859 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8860 dgst_size = DGST_SIZE_4_8;
8861 parse_func = truecrypt_parse_hash_1k;
8862 sort_by_digest = sort_by_digest_4_8;
8863 opti_type = OPTI_TYPE_ZERO_BYTE;
8864 dgst_pos0 = 0;
8865 dgst_pos1 = 1;
8866 dgst_pos2 = 2;
8867 dgst_pos3 = 3;
8868 break;
8869
8870 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8871 salt_type = SALT_TYPE_EMBEDDED;
8872 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8873 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8874 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8875 dgst_size = DGST_SIZE_4_8;
8876 parse_func = truecrypt_parse_hash_1k;
8877 sort_by_digest = sort_by_digest_4_8;
8878 opti_type = OPTI_TYPE_ZERO_BYTE;
8879 dgst_pos0 = 0;
8880 dgst_pos1 = 1;
8881 dgst_pos2 = 2;
8882 dgst_pos3 = 3;
8883 break;
8884
8885 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8886 salt_type = SALT_TYPE_EMBEDDED;
8887 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8888 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8889 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8890 dgst_size = DGST_SIZE_4_5;
8891 parse_func = truecrypt_parse_hash_1k;
8892 sort_by_digest = sort_by_digest_4_5;
8893 opti_type = OPTI_TYPE_ZERO_BYTE;
8894 dgst_pos0 = 0;
8895 dgst_pos1 = 1;
8896 dgst_pos2 = 2;
8897 dgst_pos3 = 3;
8898 break;
8899
8900 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8901 salt_type = SALT_TYPE_EMBEDDED;
8902 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8903 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8904 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8905 dgst_size = DGST_SIZE_4_5;
8906 parse_func = truecrypt_parse_hash_1k;
8907 sort_by_digest = sort_by_digest_4_5;
8908 opti_type = OPTI_TYPE_ZERO_BYTE;
8909 dgst_pos0 = 0;
8910 dgst_pos1 = 1;
8911 dgst_pos2 = 2;
8912 dgst_pos3 = 3;
8913 break;
8914
8915 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8916 salt_type = SALT_TYPE_EMBEDDED;
8917 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8918 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8919 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8920 dgst_size = DGST_SIZE_4_5;
8921 parse_func = truecrypt_parse_hash_1k;
8922 sort_by_digest = sort_by_digest_4_5;
8923 opti_type = OPTI_TYPE_ZERO_BYTE;
8924 dgst_pos0 = 0;
8925 dgst_pos1 = 1;
8926 dgst_pos2 = 2;
8927 dgst_pos3 = 3;
8928 break;
8929
8930 case 6300: hash_type = HASH_TYPE_MD5;
8931 salt_type = SALT_TYPE_EMBEDDED;
8932 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8933 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8934 kern_type = KERN_TYPE_MD5AIX;
8935 dgst_size = DGST_SIZE_4_4;
8936 parse_func = md5aix_parse_hash;
8937 sort_by_digest = sort_by_digest_4_4;
8938 opti_type = OPTI_TYPE_ZERO_BYTE;
8939 dgst_pos0 = 0;
8940 dgst_pos1 = 1;
8941 dgst_pos2 = 2;
8942 dgst_pos3 = 3;
8943 break;
8944
8945 case 6400: hash_type = HASH_TYPE_SHA256;
8946 salt_type = SALT_TYPE_EMBEDDED;
8947 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8948 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8949 kern_type = KERN_TYPE_SHA256AIX;
8950 dgst_size = DGST_SIZE_4_8;
8951 parse_func = sha256aix_parse_hash;
8952 sort_by_digest = sort_by_digest_4_8;
8953 opti_type = OPTI_TYPE_ZERO_BYTE;
8954 dgst_pos0 = 0;
8955 dgst_pos1 = 1;
8956 dgst_pos2 = 2;
8957 dgst_pos3 = 3;
8958 break;
8959
8960 case 6500: hash_type = HASH_TYPE_SHA512;
8961 salt_type = SALT_TYPE_EMBEDDED;
8962 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8963 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8964 kern_type = KERN_TYPE_SHA512AIX;
8965 dgst_size = DGST_SIZE_8_8;
8966 parse_func = sha512aix_parse_hash;
8967 sort_by_digest = sort_by_digest_8_8;
8968 opti_type = OPTI_TYPE_ZERO_BYTE
8969 | OPTI_TYPE_USES_BITS_64;
8970 dgst_pos0 = 0;
8971 dgst_pos1 = 1;
8972 dgst_pos2 = 2;
8973 dgst_pos3 = 3;
8974 break;
8975
8976 case 6600: hash_type = HASH_TYPE_AES;
8977 salt_type = SALT_TYPE_EMBEDDED;
8978 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8979 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8980 kern_type = KERN_TYPE_AGILEKEY;
8981 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8982 parse_func = agilekey_parse_hash;
8983 sort_by_digest = sort_by_digest_4_5;
8984 opti_type = OPTI_TYPE_ZERO_BYTE;
8985 dgst_pos0 = 0;
8986 dgst_pos1 = 1;
8987 dgst_pos2 = 2;
8988 dgst_pos3 = 3;
8989 break;
8990
8991 case 6700: hash_type = HASH_TYPE_SHA1;
8992 salt_type = SALT_TYPE_EMBEDDED;
8993 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8994 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8995 kern_type = KERN_TYPE_SHA1AIX;
8996 dgst_size = DGST_SIZE_4_5;
8997 parse_func = sha1aix_parse_hash;
8998 sort_by_digest = sort_by_digest_4_5;
8999 opti_type = OPTI_TYPE_ZERO_BYTE;
9000 dgst_pos0 = 0;
9001 dgst_pos1 = 1;
9002 dgst_pos2 = 2;
9003 dgst_pos3 = 3;
9004 break;
9005
9006 case 6800: hash_type = HASH_TYPE_AES;
9007 salt_type = SALT_TYPE_EMBEDDED;
9008 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9009 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9010 kern_type = KERN_TYPE_LASTPASS;
9011 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9012 parse_func = lastpass_parse_hash;
9013 sort_by_digest = sort_by_digest_4_8;
9014 opti_type = OPTI_TYPE_ZERO_BYTE;
9015 dgst_pos0 = 0;
9016 dgst_pos1 = 1;
9017 dgst_pos2 = 2;
9018 dgst_pos3 = 3;
9019 break;
9020
9021 case 6900: hash_type = HASH_TYPE_GOST;
9022 salt_type = SALT_TYPE_NONE;
9023 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9024 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9025 kern_type = KERN_TYPE_GOST;
9026 dgst_size = DGST_SIZE_4_8;
9027 parse_func = gost_parse_hash;
9028 sort_by_digest = sort_by_digest_4_8;
9029 opti_type = OPTI_TYPE_ZERO_BYTE;
9030 dgst_pos0 = 0;
9031 dgst_pos1 = 1;
9032 dgst_pos2 = 2;
9033 dgst_pos3 = 3;
9034 break;
9035
9036 case 7100: hash_type = HASH_TYPE_SHA512;
9037 salt_type = SALT_TYPE_EMBEDDED;
9038 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9039 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9040 kern_type = KERN_TYPE_PBKDF2_SHA512;
9041 dgst_size = DGST_SIZE_8_16;
9042 parse_func = sha512osx_parse_hash;
9043 sort_by_digest = sort_by_digest_8_16;
9044 opti_type = OPTI_TYPE_ZERO_BYTE
9045 | OPTI_TYPE_USES_BITS_64
9046 | OPTI_TYPE_SLOW_HASH_SIMD;
9047 dgst_pos0 = 0;
9048 dgst_pos1 = 1;
9049 dgst_pos2 = 2;
9050 dgst_pos3 = 3;
9051 break;
9052
9053 case 7200: hash_type = HASH_TYPE_SHA512;
9054 salt_type = SALT_TYPE_EMBEDDED;
9055 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9056 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9057 kern_type = KERN_TYPE_PBKDF2_SHA512;
9058 dgst_size = DGST_SIZE_8_16;
9059 parse_func = sha512grub_parse_hash;
9060 sort_by_digest = sort_by_digest_8_16;
9061 opti_type = OPTI_TYPE_ZERO_BYTE
9062 | OPTI_TYPE_USES_BITS_64
9063 | OPTI_TYPE_SLOW_HASH_SIMD;
9064 dgst_pos0 = 0;
9065 dgst_pos1 = 1;
9066 dgst_pos2 = 2;
9067 dgst_pos3 = 3;
9068 break;
9069
9070 case 7300: hash_type = HASH_TYPE_SHA1;
9071 salt_type = SALT_TYPE_EMBEDDED;
9072 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9073 opts_type = OPTS_TYPE_PT_GENERATE_BE
9074 | OPTS_TYPE_ST_ADD80
9075 | OPTS_TYPE_ST_ADDBITS15;
9076 kern_type = KERN_TYPE_RAKP;
9077 dgst_size = DGST_SIZE_4_5;
9078 parse_func = rakp_parse_hash;
9079 sort_by_digest = sort_by_digest_4_5;
9080 opti_type = OPTI_TYPE_ZERO_BYTE
9081 | OPTI_TYPE_NOT_ITERATED;
9082 dgst_pos0 = 3;
9083 dgst_pos1 = 4;
9084 dgst_pos2 = 2;
9085 dgst_pos3 = 1;
9086 break;
9087
9088 case 7400: hash_type = HASH_TYPE_SHA256;
9089 salt_type = SALT_TYPE_EMBEDDED;
9090 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9091 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9092 kern_type = KERN_TYPE_SHA256CRYPT;
9093 dgst_size = DGST_SIZE_4_8;
9094 parse_func = sha256crypt_parse_hash;
9095 sort_by_digest = sort_by_digest_4_8;
9096 opti_type = OPTI_TYPE_ZERO_BYTE;
9097 dgst_pos0 = 0;
9098 dgst_pos1 = 1;
9099 dgst_pos2 = 2;
9100 dgst_pos3 = 3;
9101 break;
9102
9103 case 7500: hash_type = HASH_TYPE_KRB5PA;
9104 salt_type = SALT_TYPE_EMBEDDED;
9105 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9106 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9107 kern_type = KERN_TYPE_KRB5PA;
9108 dgst_size = DGST_SIZE_4_4;
9109 parse_func = krb5pa_parse_hash;
9110 sort_by_digest = sort_by_digest_4_4;
9111 opti_type = OPTI_TYPE_ZERO_BYTE
9112 | OPTI_TYPE_NOT_ITERATED;
9113 dgst_pos0 = 0;
9114 dgst_pos1 = 1;
9115 dgst_pos2 = 2;
9116 dgst_pos3 = 3;
9117 break;
9118
9119 case 7600: hash_type = HASH_TYPE_SHA1;
9120 salt_type = SALT_TYPE_INTERN;
9121 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9122 opts_type = OPTS_TYPE_PT_GENERATE_BE
9123 | OPTS_TYPE_PT_ADD80
9124 | OPTS_TYPE_PT_ADDBITS15;
9125 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9126 dgst_size = DGST_SIZE_4_5;
9127 parse_func = redmine_parse_hash;
9128 sort_by_digest = sort_by_digest_4_5;
9129 opti_type = OPTI_TYPE_ZERO_BYTE
9130 | OPTI_TYPE_PRECOMPUTE_INIT
9131 | OPTI_TYPE_EARLY_SKIP
9132 | OPTI_TYPE_NOT_ITERATED
9133 | OPTI_TYPE_PREPENDED_SALT;
9134 dgst_pos0 = 3;
9135 dgst_pos1 = 4;
9136 dgst_pos2 = 2;
9137 dgst_pos3 = 1;
9138 break;
9139
9140 case 7700: hash_type = HASH_TYPE_SAPB;
9141 salt_type = SALT_TYPE_EMBEDDED;
9142 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9143 opts_type = OPTS_TYPE_PT_GENERATE_LE
9144 | OPTS_TYPE_PT_UPPER
9145 | OPTS_TYPE_ST_UPPER;
9146 kern_type = KERN_TYPE_SAPB;
9147 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9148 parse_func = sapb_parse_hash;
9149 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9150 opti_type = OPTI_TYPE_ZERO_BYTE
9151 | OPTI_TYPE_PRECOMPUTE_INIT
9152 | OPTI_TYPE_NOT_ITERATED;
9153 dgst_pos0 = 0;
9154 dgst_pos1 = 1;
9155 dgst_pos2 = 2;
9156 dgst_pos3 = 3;
9157 break;
9158
9159 case 7800: hash_type = HASH_TYPE_SAPG;
9160 salt_type = SALT_TYPE_EMBEDDED;
9161 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9162 opts_type = OPTS_TYPE_PT_GENERATE_BE
9163 | OPTS_TYPE_ST_ADD80
9164 | OPTS_TYPE_ST_UPPER;
9165 kern_type = KERN_TYPE_SAPG;
9166 dgst_size = DGST_SIZE_4_5;
9167 parse_func = sapg_parse_hash;
9168 sort_by_digest = sort_by_digest_4_5;
9169 opti_type = OPTI_TYPE_ZERO_BYTE
9170 | OPTI_TYPE_PRECOMPUTE_INIT
9171 | OPTI_TYPE_NOT_ITERATED;
9172 dgst_pos0 = 3;
9173 dgst_pos1 = 4;
9174 dgst_pos2 = 2;
9175 dgst_pos3 = 1;
9176 break;
9177
9178 case 7900: hash_type = HASH_TYPE_SHA512;
9179 salt_type = SALT_TYPE_EMBEDDED;
9180 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9181 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9182 kern_type = KERN_TYPE_DRUPAL7;
9183 dgst_size = DGST_SIZE_8_8;
9184 parse_func = drupal7_parse_hash;
9185 sort_by_digest = sort_by_digest_8_8;
9186 opti_type = OPTI_TYPE_ZERO_BYTE
9187 | OPTI_TYPE_USES_BITS_64;
9188 dgst_pos0 = 0;
9189 dgst_pos1 = 1;
9190 dgst_pos2 = 2;
9191 dgst_pos3 = 3;
9192 break;
9193
9194 case 8000: hash_type = HASH_TYPE_SHA256;
9195 salt_type = SALT_TYPE_EMBEDDED;
9196 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9197 opts_type = OPTS_TYPE_PT_GENERATE_BE
9198 | OPTS_TYPE_PT_UNICODE
9199 | OPTS_TYPE_ST_ADD80
9200 | OPTS_TYPE_ST_HEX;
9201 kern_type = KERN_TYPE_SYBASEASE;
9202 dgst_size = DGST_SIZE_4_8;
9203 parse_func = sybasease_parse_hash;
9204 sort_by_digest = sort_by_digest_4_8;
9205 opti_type = OPTI_TYPE_ZERO_BYTE
9206 | OPTI_TYPE_PRECOMPUTE_INIT
9207 | OPTI_TYPE_EARLY_SKIP
9208 | OPTI_TYPE_NOT_ITERATED
9209 | OPTI_TYPE_RAW_HASH;
9210 dgst_pos0 = 3;
9211 dgst_pos1 = 7;
9212 dgst_pos2 = 2;
9213 dgst_pos3 = 6;
9214 break;
9215
9216 case 8100: hash_type = HASH_TYPE_SHA1;
9217 salt_type = SALT_TYPE_EMBEDDED;
9218 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9219 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9220 kern_type = KERN_TYPE_NETSCALER;
9221 dgst_size = DGST_SIZE_4_5;
9222 parse_func = netscaler_parse_hash;
9223 sort_by_digest = sort_by_digest_4_5;
9224 opti_type = OPTI_TYPE_ZERO_BYTE
9225 | OPTI_TYPE_PRECOMPUTE_INIT
9226 | OPTI_TYPE_PRECOMPUTE_MERKLE
9227 | OPTI_TYPE_EARLY_SKIP
9228 | OPTI_TYPE_NOT_ITERATED
9229 | OPTI_TYPE_PREPENDED_SALT
9230 | OPTI_TYPE_RAW_HASH;
9231 dgst_pos0 = 3;
9232 dgst_pos1 = 4;
9233 dgst_pos2 = 2;
9234 dgst_pos3 = 1;
9235 break;
9236
9237 case 8200: hash_type = HASH_TYPE_SHA256;
9238 salt_type = SALT_TYPE_EMBEDDED;
9239 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9240 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9241 kern_type = KERN_TYPE_CLOUDKEY;
9242 dgst_size = DGST_SIZE_4_8;
9243 parse_func = cloudkey_parse_hash;
9244 sort_by_digest = sort_by_digest_4_8;
9245 opti_type = OPTI_TYPE_ZERO_BYTE;
9246 dgst_pos0 = 0;
9247 dgst_pos1 = 1;
9248 dgst_pos2 = 2;
9249 dgst_pos3 = 3;
9250 break;
9251
9252 case 8300: hash_type = HASH_TYPE_SHA1;
9253 salt_type = SALT_TYPE_EMBEDDED;
9254 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9255 opts_type = OPTS_TYPE_PT_GENERATE_BE
9256 | OPTS_TYPE_ST_HEX
9257 | OPTS_TYPE_ST_ADD80;
9258 kern_type = KERN_TYPE_NSEC3;
9259 dgst_size = DGST_SIZE_4_5;
9260 parse_func = nsec3_parse_hash;
9261 sort_by_digest = sort_by_digest_4_5;
9262 opti_type = OPTI_TYPE_ZERO_BYTE;
9263 dgst_pos0 = 3;
9264 dgst_pos1 = 4;
9265 dgst_pos2 = 2;
9266 dgst_pos3 = 1;
9267 break;
9268
9269 case 8400: hash_type = HASH_TYPE_SHA1;
9270 salt_type = SALT_TYPE_INTERN;
9271 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9272 opts_type = OPTS_TYPE_PT_GENERATE_BE
9273 | OPTS_TYPE_PT_ADD80
9274 | OPTS_TYPE_PT_ADDBITS15;
9275 kern_type = KERN_TYPE_WBB3;
9276 dgst_size = DGST_SIZE_4_5;
9277 parse_func = wbb3_parse_hash;
9278 sort_by_digest = sort_by_digest_4_5;
9279 opti_type = OPTI_TYPE_ZERO_BYTE
9280 | OPTI_TYPE_PRECOMPUTE_INIT
9281 | OPTI_TYPE_NOT_ITERATED;
9282 dgst_pos0 = 3;
9283 dgst_pos1 = 4;
9284 dgst_pos2 = 2;
9285 dgst_pos3 = 1;
9286 break;
9287
9288 case 8500: hash_type = HASH_TYPE_DESRACF;
9289 salt_type = SALT_TYPE_EMBEDDED;
9290 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9291 opts_type = OPTS_TYPE_PT_GENERATE_LE
9292 | OPTS_TYPE_ST_UPPER;
9293 kern_type = KERN_TYPE_RACF;
9294 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9295 parse_func = racf_parse_hash;
9296 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9297 opti_type = OPTI_TYPE_ZERO_BYTE
9298 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9299 dgst_pos0 = 0;
9300 dgst_pos1 = 1;
9301 dgst_pos2 = 2;
9302 dgst_pos3 = 3;
9303 break;
9304
9305 case 8600: hash_type = HASH_TYPE_LOTUS5;
9306 salt_type = SALT_TYPE_NONE;
9307 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9308 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9309 kern_type = KERN_TYPE_LOTUS5;
9310 dgst_size = DGST_SIZE_4_4;
9311 parse_func = lotus5_parse_hash;
9312 sort_by_digest = sort_by_digest_4_4;
9313 opti_type = OPTI_TYPE_EARLY_SKIP
9314 | OPTI_TYPE_NOT_ITERATED
9315 | OPTI_TYPE_NOT_SALTED
9316 | OPTI_TYPE_RAW_HASH;
9317 dgst_pos0 = 0;
9318 dgst_pos1 = 1;
9319 dgst_pos2 = 2;
9320 dgst_pos3 = 3;
9321 break;
9322
9323 case 8700: hash_type = HASH_TYPE_LOTUS6;
9324 salt_type = SALT_TYPE_EMBEDDED;
9325 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9326 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9327 kern_type = KERN_TYPE_LOTUS6;
9328 dgst_size = DGST_SIZE_4_4;
9329 parse_func = lotus6_parse_hash;
9330 sort_by_digest = sort_by_digest_4_4;
9331 opti_type = OPTI_TYPE_EARLY_SKIP
9332 | OPTI_TYPE_NOT_ITERATED
9333 | OPTI_TYPE_RAW_HASH;
9334 dgst_pos0 = 0;
9335 dgst_pos1 = 1;
9336 dgst_pos2 = 2;
9337 dgst_pos3 = 3;
9338 break;
9339
9340 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9341 salt_type = SALT_TYPE_EMBEDDED;
9342 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9343 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9344 kern_type = KERN_TYPE_ANDROIDFDE;
9345 dgst_size = DGST_SIZE_4_4;
9346 parse_func = androidfde_parse_hash;
9347 sort_by_digest = sort_by_digest_4_4;
9348 opti_type = OPTI_TYPE_ZERO_BYTE;
9349 dgst_pos0 = 0;
9350 dgst_pos1 = 1;
9351 dgst_pos2 = 2;
9352 dgst_pos3 = 3;
9353 break;
9354
9355 case 8900: hash_type = HASH_TYPE_SCRYPT;
9356 salt_type = SALT_TYPE_EMBEDDED;
9357 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9358 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9359 kern_type = KERN_TYPE_SCRYPT;
9360 dgst_size = DGST_SIZE_4_8;
9361 parse_func = scrypt_parse_hash;
9362 sort_by_digest = sort_by_digest_4_8;
9363 opti_type = OPTI_TYPE_ZERO_BYTE;
9364 dgst_pos0 = 0;
9365 dgst_pos1 = 1;
9366 dgst_pos2 = 2;
9367 dgst_pos3 = 3;
9368 break;
9369
9370 case 9000: hash_type = HASH_TYPE_SHA1;
9371 salt_type = SALT_TYPE_EMBEDDED;
9372 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9373 opts_type = OPTS_TYPE_PT_GENERATE_LE
9374 | OPTS_TYPE_ST_GENERATE_LE;
9375 kern_type = KERN_TYPE_PSAFE2;
9376 dgst_size = DGST_SIZE_4_5;
9377 parse_func = psafe2_parse_hash;
9378 sort_by_digest = sort_by_digest_4_5;
9379 opti_type = OPTI_TYPE_ZERO_BYTE;
9380 dgst_pos0 = 0;
9381 dgst_pos1 = 1;
9382 dgst_pos2 = 2;
9383 dgst_pos3 = 3;
9384 break;
9385
9386 case 9100: hash_type = HASH_TYPE_LOTUS8;
9387 salt_type = SALT_TYPE_EMBEDDED;
9388 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9389 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9390 kern_type = KERN_TYPE_LOTUS8;
9391 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9392 parse_func = lotus8_parse_hash;
9393 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9394 opti_type = OPTI_TYPE_ZERO_BYTE;
9395 dgst_pos0 = 0;
9396 dgst_pos1 = 1;
9397 dgst_pos2 = 2;
9398 dgst_pos3 = 3;
9399 break;
9400
9401 case 9200: hash_type = HASH_TYPE_SHA256;
9402 salt_type = SALT_TYPE_EMBEDDED;
9403 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9404 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9405 kern_type = KERN_TYPE_PBKDF2_SHA256;
9406 dgst_size = DGST_SIZE_4_32;
9407 parse_func = cisco8_parse_hash;
9408 sort_by_digest = sort_by_digest_4_32;
9409 opti_type = OPTI_TYPE_ZERO_BYTE
9410 | OPTI_TYPE_SLOW_HASH_SIMD;
9411 dgst_pos0 = 0;
9412 dgst_pos1 = 1;
9413 dgst_pos2 = 2;
9414 dgst_pos3 = 3;
9415 break;
9416
9417 case 9300: hash_type = HASH_TYPE_SCRYPT;
9418 salt_type = SALT_TYPE_EMBEDDED;
9419 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9420 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9421 kern_type = KERN_TYPE_SCRYPT;
9422 dgst_size = DGST_SIZE_4_8;
9423 parse_func = cisco9_parse_hash;
9424 sort_by_digest = sort_by_digest_4_8;
9425 opti_type = OPTI_TYPE_ZERO_BYTE;
9426 dgst_pos0 = 0;
9427 dgst_pos1 = 1;
9428 dgst_pos2 = 2;
9429 dgst_pos3 = 3;
9430 break;
9431
9432 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9433 salt_type = SALT_TYPE_EMBEDDED;
9434 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9435 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9436 kern_type = KERN_TYPE_OFFICE2007;
9437 dgst_size = DGST_SIZE_4_4;
9438 parse_func = office2007_parse_hash;
9439 sort_by_digest = sort_by_digest_4_4;
9440 opti_type = OPTI_TYPE_ZERO_BYTE;
9441 dgst_pos0 = 0;
9442 dgst_pos1 = 1;
9443 dgst_pos2 = 2;
9444 dgst_pos3 = 3;
9445 break;
9446
9447 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9448 salt_type = SALT_TYPE_EMBEDDED;
9449 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9450 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9451 kern_type = KERN_TYPE_OFFICE2010;
9452 dgst_size = DGST_SIZE_4_4;
9453 parse_func = office2010_parse_hash;
9454 sort_by_digest = sort_by_digest_4_4;
9455 opti_type = OPTI_TYPE_ZERO_BYTE;
9456 dgst_pos0 = 0;
9457 dgst_pos1 = 1;
9458 dgst_pos2 = 2;
9459 dgst_pos3 = 3;
9460 break;
9461
9462 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9463 salt_type = SALT_TYPE_EMBEDDED;
9464 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9465 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9466 kern_type = KERN_TYPE_OFFICE2013;
9467 dgst_size = DGST_SIZE_4_4;
9468 parse_func = office2013_parse_hash;
9469 sort_by_digest = sort_by_digest_4_4;
9470 opti_type = OPTI_TYPE_ZERO_BYTE;
9471 dgst_pos0 = 0;
9472 dgst_pos1 = 1;
9473 dgst_pos2 = 2;
9474 dgst_pos3 = 3;
9475 break;
9476
9477 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9478 salt_type = SALT_TYPE_EMBEDDED;
9479 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9480 opts_type = OPTS_TYPE_PT_GENERATE_LE
9481 | OPTS_TYPE_PT_ADD80
9482 | OPTS_TYPE_PT_UNICODE;
9483 kern_type = KERN_TYPE_OLDOFFICE01;
9484 dgst_size = DGST_SIZE_4_4;
9485 parse_func = oldoffice01_parse_hash;
9486 sort_by_digest = sort_by_digest_4_4;
9487 opti_type = OPTI_TYPE_ZERO_BYTE
9488 | OPTI_TYPE_PRECOMPUTE_INIT
9489 | OPTI_TYPE_NOT_ITERATED;
9490 dgst_pos0 = 0;
9491 dgst_pos1 = 1;
9492 dgst_pos2 = 2;
9493 dgst_pos3 = 3;
9494 break;
9495
9496 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9497 salt_type = SALT_TYPE_EMBEDDED;
9498 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9499 opts_type = OPTS_TYPE_PT_GENERATE_LE
9500 | OPTS_TYPE_PT_ADD80;
9501 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9502 dgst_size = DGST_SIZE_4_4;
9503 parse_func = oldoffice01cm1_parse_hash;
9504 sort_by_digest = sort_by_digest_4_4;
9505 opti_type = OPTI_TYPE_ZERO_BYTE
9506 | OPTI_TYPE_PRECOMPUTE_INIT
9507 | OPTI_TYPE_NOT_ITERATED;
9508 dgst_pos0 = 0;
9509 dgst_pos1 = 1;
9510 dgst_pos2 = 2;
9511 dgst_pos3 = 3;
9512 break;
9513
9514 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9515 salt_type = SALT_TYPE_EMBEDDED;
9516 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9517 opts_type = OPTS_TYPE_PT_GENERATE_LE
9518 | OPTS_TYPE_PT_ADD80
9519 | OPTS_TYPE_PT_UNICODE
9520 | OPTS_TYPE_PT_NEVERCRACK;
9521 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9522 dgst_size = DGST_SIZE_4_4;
9523 parse_func = oldoffice01cm2_parse_hash;
9524 sort_by_digest = sort_by_digest_4_4;
9525 opti_type = OPTI_TYPE_ZERO_BYTE
9526 | OPTI_TYPE_PRECOMPUTE_INIT
9527 | OPTI_TYPE_NOT_ITERATED;
9528 dgst_pos0 = 0;
9529 dgst_pos1 = 1;
9530 dgst_pos2 = 2;
9531 dgst_pos3 = 3;
9532 break;
9533
9534 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9535 salt_type = SALT_TYPE_EMBEDDED;
9536 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9537 opts_type = OPTS_TYPE_PT_GENERATE_BE
9538 | OPTS_TYPE_PT_ADD80
9539 | OPTS_TYPE_PT_UNICODE;
9540 kern_type = KERN_TYPE_OLDOFFICE34;
9541 dgst_size = DGST_SIZE_4_4;
9542 parse_func = oldoffice34_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 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9554 salt_type = SALT_TYPE_EMBEDDED;
9555 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9556 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9557 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9558 dgst_size = DGST_SIZE_4_4;
9559 parse_func = oldoffice34cm1_parse_hash;
9560 sort_by_digest = sort_by_digest_4_4;
9561 opti_type = OPTI_TYPE_ZERO_BYTE
9562 | OPTI_TYPE_PRECOMPUTE_INIT
9563 | OPTI_TYPE_NOT_ITERATED;
9564 dgst_pos0 = 0;
9565 dgst_pos1 = 1;
9566 dgst_pos2 = 2;
9567 dgst_pos3 = 3;
9568 break;
9569
9570 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9571 salt_type = SALT_TYPE_EMBEDDED;
9572 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9573 opts_type = OPTS_TYPE_PT_GENERATE_BE
9574 | OPTS_TYPE_PT_ADD80
9575 | OPTS_TYPE_PT_UNICODE
9576 | OPTS_TYPE_PT_NEVERCRACK;
9577 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9578 dgst_size = DGST_SIZE_4_4;
9579 parse_func = oldoffice34cm2_parse_hash;
9580 sort_by_digest = sort_by_digest_4_4;
9581 opti_type = OPTI_TYPE_ZERO_BYTE
9582 | OPTI_TYPE_PRECOMPUTE_INIT
9583 | OPTI_TYPE_NOT_ITERATED;
9584 dgst_pos0 = 0;
9585 dgst_pos1 = 1;
9586 dgst_pos2 = 2;
9587 dgst_pos3 = 3;
9588 break;
9589
9590 case 9900: hash_type = HASH_TYPE_MD5;
9591 salt_type = SALT_TYPE_NONE;
9592 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9593 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9594 kern_type = KERN_TYPE_RADMIN2;
9595 dgst_size = DGST_SIZE_4_4;
9596 parse_func = radmin2_parse_hash;
9597 sort_by_digest = sort_by_digest_4_4;
9598 opti_type = OPTI_TYPE_ZERO_BYTE
9599 | OPTI_TYPE_PRECOMPUTE_INIT
9600 | OPTI_TYPE_EARLY_SKIP
9601 | OPTI_TYPE_NOT_ITERATED
9602 | OPTI_TYPE_NOT_SALTED;
9603 dgst_pos0 = 0;
9604 dgst_pos1 = 3;
9605 dgst_pos2 = 2;
9606 dgst_pos3 = 1;
9607 break;
9608
9609 case 10000: hash_type = HASH_TYPE_SHA256;
9610 salt_type = SALT_TYPE_EMBEDDED;
9611 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9612 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9613 kern_type = KERN_TYPE_PBKDF2_SHA256;
9614 dgst_size = DGST_SIZE_4_32;
9615 parse_func = djangopbkdf2_parse_hash;
9616 sort_by_digest = sort_by_digest_4_32;
9617 opti_type = OPTI_TYPE_ZERO_BYTE
9618 | OPTI_TYPE_SLOW_HASH_SIMD;
9619 dgst_pos0 = 0;
9620 dgst_pos1 = 1;
9621 dgst_pos2 = 2;
9622 dgst_pos3 = 3;
9623 break;
9624
9625 case 10100: hash_type = HASH_TYPE_SIPHASH;
9626 salt_type = SALT_TYPE_EMBEDDED;
9627 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9628 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9629 kern_type = KERN_TYPE_SIPHASH;
9630 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9631 parse_func = siphash_parse_hash;
9632 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9633 opti_type = OPTI_TYPE_ZERO_BYTE
9634 | OPTI_TYPE_NOT_ITERATED
9635 | OPTI_TYPE_RAW_HASH;
9636 dgst_pos0 = 0;
9637 dgst_pos1 = 1;
9638 dgst_pos2 = 2;
9639 dgst_pos3 = 3;
9640 break;
9641
9642 case 10200: hash_type = HASH_TYPE_MD5;
9643 salt_type = SALT_TYPE_EMBEDDED;
9644 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9645 opts_type = OPTS_TYPE_PT_GENERATE_LE
9646 | OPTS_TYPE_ST_ADD80
9647 | OPTS_TYPE_ST_ADDBITS14;
9648 kern_type = KERN_TYPE_HMACMD5_PW;
9649 dgst_size = DGST_SIZE_4_4;
9650 parse_func = crammd5_parse_hash;
9651 sort_by_digest = sort_by_digest_4_4;
9652 opti_type = OPTI_TYPE_ZERO_BYTE
9653 | OPTI_TYPE_NOT_ITERATED;
9654 dgst_pos0 = 0;
9655 dgst_pos1 = 3;
9656 dgst_pos2 = 2;
9657 dgst_pos3 = 1;
9658 break;
9659
9660 case 10300: hash_type = HASH_TYPE_SHA1;
9661 salt_type = SALT_TYPE_EMBEDDED;
9662 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9663 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9664 kern_type = KERN_TYPE_SAPH_SHA1;
9665 dgst_size = DGST_SIZE_4_5;
9666 parse_func = saph_sha1_parse_hash;
9667 sort_by_digest = sort_by_digest_4_5;
9668 opti_type = OPTI_TYPE_ZERO_BYTE;
9669 dgst_pos0 = 0;
9670 dgst_pos1 = 1;
9671 dgst_pos2 = 2;
9672 dgst_pos3 = 3;
9673 break;
9674
9675 case 10400: hash_type = HASH_TYPE_PDFU16;
9676 salt_type = SALT_TYPE_EMBEDDED;
9677 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9678 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9679 kern_type = KERN_TYPE_PDF11;
9680 dgst_size = DGST_SIZE_4_4;
9681 parse_func = pdf11_parse_hash;
9682 sort_by_digest = sort_by_digest_4_4;
9683 opti_type = OPTI_TYPE_ZERO_BYTE
9684 | OPTI_TYPE_NOT_ITERATED;
9685 dgst_pos0 = 0;
9686 dgst_pos1 = 1;
9687 dgst_pos2 = 2;
9688 dgst_pos3 = 3;
9689 break;
9690
9691 case 10410: hash_type = HASH_TYPE_PDFU16;
9692 salt_type = SALT_TYPE_EMBEDDED;
9693 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9694 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9695 kern_type = KERN_TYPE_PDF11CM1;
9696 dgst_size = DGST_SIZE_4_4;
9697 parse_func = pdf11cm1_parse_hash;
9698 sort_by_digest = sort_by_digest_4_4;
9699 opti_type = OPTI_TYPE_ZERO_BYTE
9700 | OPTI_TYPE_NOT_ITERATED;
9701 dgst_pos0 = 0;
9702 dgst_pos1 = 1;
9703 dgst_pos2 = 2;
9704 dgst_pos3 = 3;
9705 break;
9706
9707 case 10420: hash_type = HASH_TYPE_PDFU16;
9708 salt_type = SALT_TYPE_EMBEDDED;
9709 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9710 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9711 kern_type = KERN_TYPE_PDF11CM2;
9712 dgst_size = DGST_SIZE_4_4;
9713 parse_func = pdf11cm2_parse_hash;
9714 sort_by_digest = sort_by_digest_4_4;
9715 opti_type = OPTI_TYPE_ZERO_BYTE
9716 | OPTI_TYPE_NOT_ITERATED;
9717 dgst_pos0 = 0;
9718 dgst_pos1 = 1;
9719 dgst_pos2 = 2;
9720 dgst_pos3 = 3;
9721 break;
9722
9723 case 10500: hash_type = HASH_TYPE_PDFU16;
9724 salt_type = SALT_TYPE_EMBEDDED;
9725 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9726 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9727 kern_type = KERN_TYPE_PDF14;
9728 dgst_size = DGST_SIZE_4_4;
9729 parse_func = pdf14_parse_hash;
9730 sort_by_digest = sort_by_digest_4_4;
9731 opti_type = OPTI_TYPE_ZERO_BYTE
9732 | OPTI_TYPE_NOT_ITERATED;
9733 dgst_pos0 = 0;
9734 dgst_pos1 = 1;
9735 dgst_pos2 = 2;
9736 dgst_pos3 = 3;
9737 break;
9738
9739 case 10600: hash_type = HASH_TYPE_SHA256;
9740 salt_type = SALT_TYPE_EMBEDDED;
9741 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9742 opts_type = OPTS_TYPE_PT_GENERATE_BE
9743 | OPTS_TYPE_ST_ADD80
9744 | OPTS_TYPE_ST_ADDBITS15
9745 | OPTS_TYPE_HASH_COPY;
9746 kern_type = KERN_TYPE_SHA256_PWSLT;
9747 dgst_size = DGST_SIZE_4_8;
9748 parse_func = pdf17l3_parse_hash;
9749 sort_by_digest = sort_by_digest_4_8;
9750 opti_type = OPTI_TYPE_ZERO_BYTE
9751 | OPTI_TYPE_PRECOMPUTE_INIT
9752 | OPTI_TYPE_PRECOMPUTE_MERKLE
9753 | OPTI_TYPE_EARLY_SKIP
9754 | OPTI_TYPE_NOT_ITERATED
9755 | OPTI_TYPE_APPENDED_SALT
9756 | OPTI_TYPE_RAW_HASH;
9757 dgst_pos0 = 3;
9758 dgst_pos1 = 7;
9759 dgst_pos2 = 2;
9760 dgst_pos3 = 6;
9761 break;
9762
9763 case 10700: hash_type = HASH_TYPE_PDFU32;
9764 salt_type = SALT_TYPE_EMBEDDED;
9765 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9766 opts_type = OPTS_TYPE_PT_GENERATE_LE
9767 | OPTS_TYPE_HASH_COPY;
9768 kern_type = KERN_TYPE_PDF17L8;
9769 dgst_size = DGST_SIZE_4_8;
9770 parse_func = pdf17l8_parse_hash;
9771 sort_by_digest = sort_by_digest_4_8;
9772 opti_type = OPTI_TYPE_ZERO_BYTE
9773 | OPTI_TYPE_NOT_ITERATED;
9774 dgst_pos0 = 0;
9775 dgst_pos1 = 1;
9776 dgst_pos2 = 2;
9777 dgst_pos3 = 3;
9778 break;
9779
9780 case 10800: hash_type = HASH_TYPE_SHA384;
9781 salt_type = SALT_TYPE_NONE;
9782 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9783 opts_type = OPTS_TYPE_PT_GENERATE_BE
9784 | OPTS_TYPE_PT_ADD80
9785 | OPTS_TYPE_PT_ADDBITS15;
9786 kern_type = KERN_TYPE_SHA384;
9787 dgst_size = DGST_SIZE_8_8;
9788 parse_func = sha384_parse_hash;
9789 sort_by_digest = sort_by_digest_8_8;
9790 opti_type = OPTI_TYPE_ZERO_BYTE
9791 | OPTI_TYPE_PRECOMPUTE_INIT
9792 | OPTI_TYPE_PRECOMPUTE_MERKLE
9793 | OPTI_TYPE_EARLY_SKIP
9794 | OPTI_TYPE_NOT_ITERATED
9795 | OPTI_TYPE_NOT_SALTED
9796 | OPTI_TYPE_USES_BITS_64
9797 | OPTI_TYPE_RAW_HASH;
9798 dgst_pos0 = 6;
9799 dgst_pos1 = 7;
9800 dgst_pos2 = 4;
9801 dgst_pos3 = 5;
9802 break;
9803
9804 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9805 salt_type = SALT_TYPE_EMBEDDED;
9806 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9807 opts_type = OPTS_TYPE_PT_GENERATE_LE
9808 | OPTS_TYPE_ST_BASE64
9809 | OPTS_TYPE_HASH_COPY;
9810 kern_type = KERN_TYPE_PBKDF2_SHA256;
9811 dgst_size = DGST_SIZE_4_32;
9812 parse_func = pbkdf2_sha256_parse_hash;
9813 sort_by_digest = sort_by_digest_4_32;
9814 opti_type = OPTI_TYPE_ZERO_BYTE
9815 | OPTI_TYPE_SLOW_HASH_SIMD;
9816 dgst_pos0 = 0;
9817 dgst_pos1 = 1;
9818 dgst_pos2 = 2;
9819 dgst_pos3 = 3;
9820 break;
9821
9822 case 11000: hash_type = HASH_TYPE_MD5;
9823 salt_type = SALT_TYPE_INTERN;
9824 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9825 opts_type = OPTS_TYPE_PT_GENERATE_LE
9826 | OPTS_TYPE_PT_ADD80;
9827 kern_type = KERN_TYPE_PRESTASHOP;
9828 dgst_size = DGST_SIZE_4_4;
9829 parse_func = prestashop_parse_hash;
9830 sort_by_digest = sort_by_digest_4_4;
9831 opti_type = OPTI_TYPE_ZERO_BYTE
9832 | OPTI_TYPE_PRECOMPUTE_INIT
9833 | OPTI_TYPE_NOT_ITERATED
9834 | OPTI_TYPE_PREPENDED_SALT;
9835 dgst_pos0 = 0;
9836 dgst_pos1 = 3;
9837 dgst_pos2 = 2;
9838 dgst_pos3 = 1;
9839 break;
9840
9841 case 11100: hash_type = HASH_TYPE_MD5;
9842 salt_type = SALT_TYPE_EMBEDDED;
9843 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9844 opts_type = OPTS_TYPE_PT_GENERATE_LE
9845 | OPTS_TYPE_ST_ADD80;
9846 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9847 dgst_size = DGST_SIZE_4_4;
9848 parse_func = postgresql_auth_parse_hash;
9849 sort_by_digest = sort_by_digest_4_4;
9850 opti_type = OPTI_TYPE_ZERO_BYTE
9851 | OPTI_TYPE_PRECOMPUTE_INIT
9852 | OPTI_TYPE_PRECOMPUTE_MERKLE
9853 | OPTI_TYPE_EARLY_SKIP;
9854 dgst_pos0 = 0;
9855 dgst_pos1 = 3;
9856 dgst_pos2 = 2;
9857 dgst_pos3 = 1;
9858 break;
9859
9860 case 11200: hash_type = HASH_TYPE_SHA1;
9861 salt_type = SALT_TYPE_EMBEDDED;
9862 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9863 opts_type = OPTS_TYPE_PT_GENERATE_BE
9864 | OPTS_TYPE_PT_ADD80
9865 | OPTS_TYPE_ST_HEX;
9866 kern_type = KERN_TYPE_MYSQL_AUTH;
9867 dgst_size = DGST_SIZE_4_5;
9868 parse_func = mysql_auth_parse_hash;
9869 sort_by_digest = sort_by_digest_4_5;
9870 opti_type = OPTI_TYPE_ZERO_BYTE
9871 | OPTI_TYPE_EARLY_SKIP;
9872 dgst_pos0 = 3;
9873 dgst_pos1 = 4;
9874 dgst_pos2 = 2;
9875 dgst_pos3 = 1;
9876 break;
9877
9878 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9879 salt_type = SALT_TYPE_EMBEDDED;
9880 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9881 opts_type = OPTS_TYPE_PT_GENERATE_LE
9882 | OPTS_TYPE_ST_HEX
9883 | OPTS_TYPE_ST_ADD80;
9884 kern_type = KERN_TYPE_BITCOIN_WALLET;
9885 dgst_size = DGST_SIZE_4_4;
9886 parse_func = bitcoin_wallet_parse_hash;
9887 sort_by_digest = sort_by_digest_4_4;
9888 opti_type = OPTI_TYPE_ZERO_BYTE;
9889 dgst_pos0 = 0;
9890 dgst_pos1 = 1;
9891 dgst_pos2 = 2;
9892 dgst_pos3 = 3;
9893 break;
9894
9895 case 11400: hash_type = HASH_TYPE_MD5;
9896 salt_type = SALT_TYPE_EMBEDDED;
9897 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9898 opts_type = OPTS_TYPE_PT_GENERATE_LE
9899 | OPTS_TYPE_PT_ADD80
9900 | OPTS_TYPE_HASH_COPY;
9901 kern_type = KERN_TYPE_SIP_AUTH;
9902 dgst_size = DGST_SIZE_4_4;
9903 parse_func = sip_auth_parse_hash;
9904 sort_by_digest = sort_by_digest_4_4;
9905 opti_type = OPTI_TYPE_ZERO_BYTE;
9906 dgst_pos0 = 0;
9907 dgst_pos1 = 3;
9908 dgst_pos2 = 2;
9909 dgst_pos3 = 1;
9910 break;
9911
9912 case 11500: hash_type = HASH_TYPE_CRC32;
9913 salt_type = SALT_TYPE_INTERN;
9914 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9915 opts_type = OPTS_TYPE_PT_GENERATE_LE
9916 | OPTS_TYPE_ST_GENERATE_LE
9917 | OPTS_TYPE_ST_HEX;
9918 kern_type = KERN_TYPE_CRC32;
9919 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9920 parse_func = crc32_parse_hash;
9921 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9922 opti_type = OPTI_TYPE_ZERO_BYTE;
9923 dgst_pos0 = 0;
9924 dgst_pos1 = 1;
9925 dgst_pos2 = 2;
9926 dgst_pos3 = 3;
9927 break;
9928
9929 case 11600: hash_type = HASH_TYPE_AES;
9930 salt_type = SALT_TYPE_EMBEDDED;
9931 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9932 opts_type = OPTS_TYPE_PT_GENERATE_LE
9933 | OPTS_TYPE_PT_NEVERCRACK;
9934 kern_type = KERN_TYPE_SEVEN_ZIP;
9935 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9936 parse_func = seven_zip_parse_hash;
9937 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9938 opti_type = OPTI_TYPE_ZERO_BYTE;
9939 dgst_pos0 = 0;
9940 dgst_pos1 = 1;
9941 dgst_pos2 = 2;
9942 dgst_pos3 = 3;
9943 break;
9944
9945 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9946 salt_type = SALT_TYPE_NONE;
9947 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9948 opts_type = OPTS_TYPE_PT_GENERATE_LE
9949 | OPTS_TYPE_PT_ADD01;
9950 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9951 dgst_size = DGST_SIZE_4_8;
9952 parse_func = gost2012sbog_256_parse_hash;
9953 sort_by_digest = sort_by_digest_4_8;
9954 opti_type = OPTI_TYPE_ZERO_BYTE;
9955 dgst_pos0 = 0;
9956 dgst_pos1 = 1;
9957 dgst_pos2 = 2;
9958 dgst_pos3 = 3;
9959 break;
9960
9961 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9962 salt_type = SALT_TYPE_NONE;
9963 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9964 opts_type = OPTS_TYPE_PT_GENERATE_LE
9965 | OPTS_TYPE_PT_ADD01;
9966 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9967 dgst_size = DGST_SIZE_4_16;
9968 parse_func = gost2012sbog_512_parse_hash;
9969 sort_by_digest = sort_by_digest_4_16;
9970 opti_type = OPTI_TYPE_ZERO_BYTE;
9971 dgst_pos0 = 0;
9972 dgst_pos1 = 1;
9973 dgst_pos2 = 2;
9974 dgst_pos3 = 3;
9975 break;
9976
9977 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9978 salt_type = SALT_TYPE_EMBEDDED;
9979 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9980 opts_type = OPTS_TYPE_PT_GENERATE_LE
9981 | OPTS_TYPE_ST_BASE64
9982 | OPTS_TYPE_HASH_COPY;
9983 kern_type = KERN_TYPE_PBKDF2_MD5;
9984 dgst_size = DGST_SIZE_4_32;
9985 parse_func = pbkdf2_md5_parse_hash;
9986 sort_by_digest = sort_by_digest_4_32;
9987 opti_type = OPTI_TYPE_ZERO_BYTE
9988 | OPTI_TYPE_SLOW_HASH_SIMD;
9989 dgst_pos0 = 0;
9990 dgst_pos1 = 1;
9991 dgst_pos2 = 2;
9992 dgst_pos3 = 3;
9993 break;
9994
9995 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9996 salt_type = SALT_TYPE_EMBEDDED;
9997 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9998 opts_type = OPTS_TYPE_PT_GENERATE_LE
9999 | OPTS_TYPE_ST_BASE64
10000 | OPTS_TYPE_HASH_COPY;
10001 kern_type = KERN_TYPE_PBKDF2_SHA1;
10002 dgst_size = DGST_SIZE_4_32;
10003 parse_func = pbkdf2_sha1_parse_hash;
10004 sort_by_digest = sort_by_digest_4_32;
10005 opti_type = OPTI_TYPE_ZERO_BYTE
10006 | OPTI_TYPE_SLOW_HASH_SIMD;
10007 dgst_pos0 = 0;
10008 dgst_pos1 = 1;
10009 dgst_pos2 = 2;
10010 dgst_pos3 = 3;
10011 break;
10012
10013 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10014 salt_type = SALT_TYPE_EMBEDDED;
10015 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10016 opts_type = OPTS_TYPE_PT_GENERATE_LE
10017 | OPTS_TYPE_ST_BASE64
10018 | OPTS_TYPE_HASH_COPY;
10019 kern_type = KERN_TYPE_PBKDF2_SHA512;
10020 dgst_size = DGST_SIZE_8_16;
10021 parse_func = pbkdf2_sha512_parse_hash;
10022 sort_by_digest = sort_by_digest_8_16;
10023 opti_type = OPTI_TYPE_ZERO_BYTE
10024 | OPTI_TYPE_USES_BITS_64
10025 | OPTI_TYPE_SLOW_HASH_SIMD;
10026 dgst_pos0 = 0;
10027 dgst_pos1 = 1;
10028 dgst_pos2 = 2;
10029 dgst_pos3 = 3;
10030 break;
10031
10032 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10033 salt_type = SALT_TYPE_EMBEDDED;
10034 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10035 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10036 kern_type = KERN_TYPE_ECRYPTFS;
10037 dgst_size = DGST_SIZE_8_8;
10038 parse_func = ecryptfs_parse_hash;
10039 sort_by_digest = sort_by_digest_8_8;
10040 opti_type = OPTI_TYPE_ZERO_BYTE
10041 | OPTI_TYPE_USES_BITS_64;
10042 dgst_pos0 = 0;
10043 dgst_pos1 = 1;
10044 dgst_pos2 = 2;
10045 dgst_pos3 = 3;
10046 break;
10047
10048 case 12300: hash_type = HASH_TYPE_ORACLET;
10049 salt_type = SALT_TYPE_EMBEDDED;
10050 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10051 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10052 kern_type = KERN_TYPE_ORACLET;
10053 dgst_size = DGST_SIZE_8_16;
10054 parse_func = oraclet_parse_hash;
10055 sort_by_digest = sort_by_digest_8_16;
10056 opti_type = OPTI_TYPE_ZERO_BYTE
10057 | OPTI_TYPE_USES_BITS_64;
10058 dgst_pos0 = 0;
10059 dgst_pos1 = 1;
10060 dgst_pos2 = 2;
10061 dgst_pos3 = 3;
10062 break;
10063
10064 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10065 salt_type = SALT_TYPE_EMBEDDED;
10066 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10067 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10068 kern_type = KERN_TYPE_BSDICRYPT;
10069 dgst_size = DGST_SIZE_4_4;
10070 parse_func = bsdicrypt_parse_hash;
10071 sort_by_digest = sort_by_digest_4_4;
10072 opti_type = OPTI_TYPE_ZERO_BYTE
10073 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10074 dgst_pos0 = 0;
10075 dgst_pos1 = 1;
10076 dgst_pos2 = 2;
10077 dgst_pos3 = 3;
10078 break;
10079
10080 case 12500: hash_type = HASH_TYPE_RAR3HP;
10081 salt_type = SALT_TYPE_EMBEDDED;
10082 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10083 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10084 kern_type = KERN_TYPE_RAR3;
10085 dgst_size = DGST_SIZE_4_4;
10086 parse_func = rar3hp_parse_hash;
10087 sort_by_digest = sort_by_digest_4_4;
10088 opti_type = OPTI_TYPE_ZERO_BYTE;
10089 dgst_pos0 = 0;
10090 dgst_pos1 = 1;
10091 dgst_pos2 = 2;
10092 dgst_pos3 = 3;
10093 break;
10094
10095 case 12600: hash_type = HASH_TYPE_SHA256;
10096 salt_type = SALT_TYPE_INTERN;
10097 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10098 opts_type = OPTS_TYPE_PT_GENERATE_BE
10099 | OPTS_TYPE_PT_ADD80;
10100 kern_type = KERN_TYPE_CF10;
10101 dgst_size = DGST_SIZE_4_8;
10102 parse_func = cf10_parse_hash;
10103 sort_by_digest = sort_by_digest_4_8;
10104 opti_type = OPTI_TYPE_ZERO_BYTE
10105 | OPTI_TYPE_PRECOMPUTE_INIT
10106 | OPTI_TYPE_EARLY_SKIP
10107 | OPTI_TYPE_NOT_ITERATED;
10108 dgst_pos0 = 3;
10109 dgst_pos1 = 7;
10110 dgst_pos2 = 2;
10111 dgst_pos3 = 6;
10112 break;
10113
10114 case 12700: hash_type = HASH_TYPE_AES;
10115 salt_type = SALT_TYPE_EMBEDDED;
10116 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10117 opts_type = OPTS_TYPE_PT_GENERATE_LE
10118 | OPTS_TYPE_HASH_COPY;
10119 kern_type = KERN_TYPE_MYWALLET;
10120 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10121 parse_func = mywallet_parse_hash;
10122 sort_by_digest = sort_by_digest_4_5;
10123 opti_type = OPTI_TYPE_ZERO_BYTE;
10124 dgst_pos0 = 0;
10125 dgst_pos1 = 1;
10126 dgst_pos2 = 2;
10127 dgst_pos3 = 3;
10128 break;
10129
10130 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10131 salt_type = SALT_TYPE_EMBEDDED;
10132 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10133 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10134 kern_type = KERN_TYPE_MS_DRSR;
10135 dgst_size = DGST_SIZE_4_8;
10136 parse_func = ms_drsr_parse_hash;
10137 sort_by_digest = sort_by_digest_4_8;
10138 opti_type = OPTI_TYPE_ZERO_BYTE;
10139 dgst_pos0 = 0;
10140 dgst_pos1 = 1;
10141 dgst_pos2 = 2;
10142 dgst_pos3 = 3;
10143 break;
10144
10145 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10146 salt_type = SALT_TYPE_EMBEDDED;
10147 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10148 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10149 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10150 dgst_size = DGST_SIZE_4_8;
10151 parse_func = androidfde_samsung_parse_hash;
10152 sort_by_digest = sort_by_digest_4_8;
10153 opti_type = OPTI_TYPE_ZERO_BYTE;
10154 dgst_pos0 = 0;
10155 dgst_pos1 = 1;
10156 dgst_pos2 = 2;
10157 dgst_pos3 = 3;
10158 break;
10159
10160 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10161 salt_type = SALT_TYPE_EMBEDDED;
10162 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10163 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10164 kern_type = KERN_TYPE_RAR5;
10165 dgst_size = DGST_SIZE_4_4;
10166 parse_func = rar5_parse_hash;
10167 sort_by_digest = sort_by_digest_4_4;
10168 opti_type = OPTI_TYPE_ZERO_BYTE;
10169 dgst_pos0 = 0;
10170 dgst_pos1 = 1;
10171 dgst_pos2 = 2;
10172 dgst_pos3 = 3;
10173 break;
10174
10175 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10176 salt_type = SALT_TYPE_EMBEDDED;
10177 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10178 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10179 kern_type = KERN_TYPE_KRB5TGS;
10180 dgst_size = DGST_SIZE_4_4;
10181 parse_func = krb5tgs_parse_hash;
10182 sort_by_digest = sort_by_digest_4_4;
10183 opti_type = OPTI_TYPE_ZERO_BYTE
10184 | OPTI_TYPE_NOT_ITERATED;
10185 dgst_pos0 = 0;
10186 dgst_pos1 = 1;
10187 dgst_pos2 = 2;
10188 dgst_pos3 = 3;
10189 break;
10190
10191 case 13200: hash_type = HASH_TYPE_AES;
10192 salt_type = SALT_TYPE_EMBEDDED;
10193 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10194 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10195 kern_type = KERN_TYPE_AXCRYPT;
10196 dgst_size = DGST_SIZE_4_4;
10197 parse_func = axcrypt_parse_hash;
10198 sort_by_digest = sort_by_digest_4_4;
10199 opti_type = OPTI_TYPE_ZERO_BYTE;
10200 dgst_pos0 = 0;
10201 dgst_pos1 = 1;
10202 dgst_pos2 = 2;
10203 dgst_pos3 = 3;
10204 break;
10205
10206 case 13300: hash_type = HASH_TYPE_SHA1;
10207 salt_type = SALT_TYPE_NONE;
10208 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10209 opts_type = OPTS_TYPE_PT_GENERATE_BE
10210 | OPTS_TYPE_PT_ADD80
10211 | OPTS_TYPE_PT_ADDBITS15;
10212 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10213 dgst_size = DGST_SIZE_4_5;
10214 parse_func = sha1axcrypt_parse_hash;
10215 sort_by_digest = sort_by_digest_4_5;
10216 opti_type = OPTI_TYPE_ZERO_BYTE
10217 | OPTI_TYPE_PRECOMPUTE_INIT
10218 | OPTI_TYPE_EARLY_SKIP
10219 | OPTI_TYPE_NOT_ITERATED
10220 | OPTI_TYPE_NOT_SALTED;
10221 dgst_pos0 = 0;
10222 dgst_pos1 = 4;
10223 dgst_pos2 = 3;
10224 dgst_pos3 = 2;
10225 break;
10226
10227 case 13400: hash_type = HASH_TYPE_AES;
10228 salt_type = SALT_TYPE_EMBEDDED;
10229 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10230 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10231 kern_type = KERN_TYPE_KEEPASS;
10232 dgst_size = DGST_SIZE_4_4;
10233 parse_func = keepass_parse_hash;
10234 sort_by_digest = sort_by_digest_4_4;
10235 opti_type = OPTI_TYPE_ZERO_BYTE;
10236 dgst_pos0 = 0;
10237 dgst_pos1 = 1;
10238 dgst_pos2 = 2;
10239 dgst_pos3 = 3;
10240 break;
10241
10242 case 13500: hash_type = HASH_TYPE_SHA1;
10243 salt_type = SALT_TYPE_EMBEDDED;
10244 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10245 opts_type = OPTS_TYPE_PT_GENERATE_BE
10246 | OPTS_TYPE_PT_UNICODE
10247 | OPTS_TYPE_PT_ADD80;
10248 kern_type = KERN_TYPE_PSTOKEN;
10249 dgst_size = DGST_SIZE_4_5;
10250 parse_func = pstoken_parse_hash;
10251 sort_by_digest = sort_by_digest_4_5;
10252 opti_type = OPTI_TYPE_ZERO_BYTE
10253 | OPTI_TYPE_PRECOMPUTE_INIT
10254 | OPTI_TYPE_EARLY_SKIP
10255 | OPTI_TYPE_NOT_ITERATED
10256 | OPTI_TYPE_PREPENDED_SALT
10257 | OPTI_TYPE_RAW_HASH;
10258 dgst_pos0 = 3;
10259 dgst_pos1 = 4;
10260 dgst_pos2 = 2;
10261 dgst_pos3 = 1;
10262 break;
10263
10264 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10265 salt_type = SALT_TYPE_EMBEDDED;
10266 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10267 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10268 kern_type = KERN_TYPE_ZIP2;
10269 dgst_size = DGST_SIZE_4_4;
10270 parse_func = zip2_parse_hash;
10271 sort_by_digest = sort_by_digest_4_4;
10272 opti_type = OPTI_TYPE_ZERO_BYTE;
10273 dgst_pos0 = 0;
10274 dgst_pos1 = 1;
10275 dgst_pos2 = 2;
10276 dgst_pos3 = 3;
10277 break;
10278
10279 default: usage_mini_print (PROGNAME); return (-1);
10280 }
10281
10282 /**
10283 * parser
10284 */
10285
10286 data.parse_func = parse_func;
10287
10288 /**
10289 * misc stuff
10290 */
10291
10292 if (hex_salt)
10293 {
10294 if (salt_type == SALT_TYPE_INTERN)
10295 {
10296 opts_type |= OPTS_TYPE_ST_HEX;
10297 }
10298 else
10299 {
10300 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10301
10302 return (-1);
10303 }
10304 }
10305
10306 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10307 | (salt_type == SALT_TYPE_EXTERN)
10308 | (salt_type == SALT_TYPE_EMBEDDED)
10309 | (salt_type == SALT_TYPE_VIRTUAL));
10310
10311 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10312
10313 data.hash_type = hash_type;
10314 data.attack_mode = attack_mode;
10315 data.attack_kern = attack_kern;
10316 data.attack_exec = attack_exec;
10317 data.kern_type = kern_type;
10318 data.opts_type = opts_type;
10319 data.dgst_size = dgst_size;
10320 data.salt_type = salt_type;
10321 data.isSalted = isSalted;
10322 data.sort_by_digest = sort_by_digest;
10323 data.dgst_pos0 = dgst_pos0;
10324 data.dgst_pos1 = dgst_pos1;
10325 data.dgst_pos2 = dgst_pos2;
10326 data.dgst_pos3 = dgst_pos3;
10327
10328 esalt_size = 0;
10329
10330 switch (hash_mode)
10331 {
10332 case 2500: esalt_size = sizeof (wpa_t); break;
10333 case 5300: esalt_size = sizeof (ikepsk_t); break;
10334 case 5400: esalt_size = sizeof (ikepsk_t); break;
10335 case 5500: esalt_size = sizeof (netntlm_t); break;
10336 case 5600: esalt_size = sizeof (netntlm_t); break;
10337 case 6211: esalt_size = sizeof (tc_t); break;
10338 case 6212: esalt_size = sizeof (tc_t); break;
10339 case 6213: esalt_size = sizeof (tc_t); break;
10340 case 6221: esalt_size = sizeof (tc_t); break;
10341 case 6222: esalt_size = sizeof (tc_t); break;
10342 case 6223: esalt_size = sizeof (tc_t); break;
10343 case 6231: esalt_size = sizeof (tc_t); break;
10344 case 6232: esalt_size = sizeof (tc_t); break;
10345 case 6233: esalt_size = sizeof (tc_t); break;
10346 case 6241: esalt_size = sizeof (tc_t); break;
10347 case 6242: esalt_size = sizeof (tc_t); break;
10348 case 6243: esalt_size = sizeof (tc_t); break;
10349 case 6600: esalt_size = sizeof (agilekey_t); break;
10350 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10351 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10352 case 7300: esalt_size = sizeof (rakp_t); break;
10353 case 7500: esalt_size = sizeof (krb5pa_t); break;
10354 case 8200: esalt_size = sizeof (cloudkey_t); break;
10355 case 8800: esalt_size = sizeof (androidfde_t); break;
10356 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10357 case 9400: esalt_size = sizeof (office2007_t); break;
10358 case 9500: esalt_size = sizeof (office2010_t); break;
10359 case 9600: esalt_size = sizeof (office2013_t); break;
10360 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10361 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10362 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10363 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10364 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10365 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10366 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10367 case 10200: esalt_size = sizeof (cram_md5_t); break;
10368 case 10400: esalt_size = sizeof (pdf_t); break;
10369 case 10410: esalt_size = sizeof (pdf_t); break;
10370 case 10420: esalt_size = sizeof (pdf_t); break;
10371 case 10500: esalt_size = sizeof (pdf_t); break;
10372 case 10600: esalt_size = sizeof (pdf_t); break;
10373 case 10700: esalt_size = sizeof (pdf_t); break;
10374 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10375 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10376 case 11400: esalt_size = sizeof (sip_t); break;
10377 case 11600: esalt_size = sizeof (seven_zip_t); break;
10378 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10379 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10380 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10381 case 13000: esalt_size = sizeof (rar5_t); break;
10382 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10383 case 13400: esalt_size = sizeof (keepass_t); break;
10384 case 13500: esalt_size = sizeof (pstoken_t); break;
10385 case 13600: esalt_size = sizeof (zip2_t); break;
10386 }
10387
10388 data.esalt_size = esalt_size;
10389
10390 /**
10391 * choose dictionary parser
10392 */
10393
10394 if (hash_type == HASH_TYPE_LM)
10395 {
10396 get_next_word_func = get_next_word_lm;
10397 }
10398 else if (opts_type & OPTS_TYPE_PT_UPPER)
10399 {
10400 get_next_word_func = get_next_word_uc;
10401 }
10402 else
10403 {
10404 get_next_word_func = get_next_word_std;
10405 }
10406
10407 /**
10408 * dictstat
10409 */
10410
10411 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10412
10413 #ifdef _POSIX
10414 size_t dictstat_nmemb = 0;
10415 #endif
10416
10417 #ifdef _WIN
10418 uint dictstat_nmemb = 0;
10419 #endif
10420
10421 char dictstat[256] = { 0 };
10422
10423 FILE *dictstat_fp = NULL;
10424
10425 if (keyspace == 0)
10426 {
10427 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10428
10429 dictstat_fp = fopen (dictstat, "rb");
10430
10431 if (dictstat_fp)
10432 {
10433 #ifdef _POSIX
10434 struct stat tmpstat;
10435
10436 fstat (fileno (dictstat_fp), &tmpstat);
10437 #endif
10438
10439 #ifdef _WIN
10440 struct stat64 tmpstat;
10441
10442 _fstat64 (fileno (dictstat_fp), &tmpstat);
10443 #endif
10444
10445 if (tmpstat.st_mtime < COMPTIME)
10446 {
10447 /* with v0.15 the format changed so we have to ensure user is using a good version
10448 since there is no version-header in the dictstat file */
10449
10450 fclose (dictstat_fp);
10451
10452 unlink (dictstat);
10453 }
10454 else
10455 {
10456 while (!feof (dictstat_fp))
10457 {
10458 dictstat_t d;
10459
10460 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10461
10462 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10463
10464 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10465 {
10466 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10467
10468 return -1;
10469 }
10470 }
10471
10472 fclose (dictstat_fp);
10473 }
10474 }
10475 }
10476
10477 /**
10478 * potfile
10479 */
10480
10481 char potfile[256] = { 0 };
10482
10483 if (potfile_path == NULL)
10484 {
10485 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10486 }
10487 else
10488 {
10489 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10490 }
10491
10492 data.pot_fp = NULL;
10493
10494 FILE *out_fp = NULL;
10495 FILE *pot_fp = NULL;
10496
10497 if (show == 1 || left == 1)
10498 {
10499 pot_fp = fopen (potfile, "rb");
10500
10501 if (pot_fp == NULL)
10502 {
10503 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10504
10505 return (-1);
10506 }
10507
10508 if (outfile != NULL)
10509 {
10510 if ((out_fp = fopen (outfile, "ab")) == NULL)
10511 {
10512 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10513
10514 fclose (pot_fp);
10515
10516 return (-1);
10517 }
10518 }
10519 else
10520 {
10521 out_fp = stdout;
10522 }
10523 }
10524 else
10525 {
10526 if (potfile_disable == 0)
10527 {
10528 pot_fp = fopen (potfile, "ab");
10529
10530 if (pot_fp == NULL)
10531 {
10532 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10533
10534 return (-1);
10535 }
10536
10537 data.pot_fp = pot_fp;
10538 }
10539 }
10540
10541 pot_t *pot = NULL;
10542
10543 uint pot_cnt = 0;
10544 uint pot_avail = 0;
10545
10546 if (show == 1 || left == 1)
10547 {
10548 SUPPRESS_OUTPUT = 1;
10549
10550 pot_avail = count_lines (pot_fp);
10551
10552 rewind (pot_fp);
10553
10554 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10555
10556 uint pot_hashes_avail = 0;
10557
10558 uint line_num = 0;
10559
10560 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10561
10562 while (!feof (pot_fp))
10563 {
10564 line_num++;
10565
10566 int line_len = fgetl (pot_fp, line_buf);
10567
10568 if (line_len == 0) continue;
10569
10570 char *plain_buf = line_buf + line_len;
10571
10572 pot_t *pot_ptr = &pot[pot_cnt];
10573
10574 hash_t *hashes_buf = &pot_ptr->hash;
10575
10576 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10577 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10578
10579 if (pot_cnt == pot_hashes_avail)
10580 {
10581 uint pos = 0;
10582
10583 for (pos = 0; pos < INCR_POT; pos++)
10584 {
10585 if ((pot_cnt + pos) >= pot_avail) break;
10586
10587 pot_t *tmp_pot = &pot[pot_cnt + pos];
10588
10589 hash_t *tmp_hash = &tmp_pot->hash;
10590
10591 tmp_hash->digest = mymalloc (dgst_size);
10592
10593 if (isSalted)
10594 {
10595 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10596 }
10597
10598 if (esalt_size)
10599 {
10600 tmp_hash->esalt = mymalloc (esalt_size);
10601 }
10602
10603 pot_hashes_avail++;
10604 }
10605 }
10606
10607 int plain_len = 0;
10608
10609 int parser_status;
10610
10611 int iter = MAX_CUT_TRIES;
10612
10613 do
10614 {
10615 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10616 {
10617 if (line_buf[i] == ':')
10618 {
10619 line_len--;
10620
10621 break;
10622 }
10623 }
10624
10625 if (data.hash_mode != 2500)
10626 {
10627 parser_status = parse_func (line_buf, line_len, hashes_buf);
10628 }
10629 else
10630 {
10631 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10632
10633 if (line_len > max_salt_size)
10634 {
10635 parser_status = PARSER_GLOBAL_LENGTH;
10636 }
10637 else
10638 {
10639 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10640
10641 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10642
10643 hashes_buf->salt->salt_len = line_len;
10644
10645 parser_status = PARSER_OK;
10646 }
10647 }
10648
10649 // if NOT parsed without error, we add the ":" to the plain
10650
10651 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10652 {
10653 plain_len++;
10654 plain_buf--;
10655 }
10656
10657 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10658
10659 if (parser_status < PARSER_GLOBAL_ZERO)
10660 {
10661 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10662
10663 continue;
10664 }
10665
10666 if (plain_len >= 255) continue;
10667
10668 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10669
10670 pot_ptr->plain_len = plain_len;
10671
10672 pot_cnt++;
10673 }
10674
10675 myfree (line_buf);
10676
10677 fclose (pot_fp);
10678
10679 SUPPRESS_OUTPUT = 0;
10680
10681 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10682 }
10683
10684 /**
10685 * word len
10686 */
10687
10688 uint pw_min = PW_MIN;
10689 uint pw_max = PW_MAX;
10690
10691 switch (hash_mode)
10692 {
10693 case 125: if (pw_max > 32) pw_max = 32;
10694 break;
10695 case 400: if (pw_max > 40) pw_max = 40;
10696 break;
10697 case 500: if (pw_max > 16) pw_max = 16;
10698 break;
10699 case 1500: if (pw_max > 8) pw_max = 8;
10700 break;
10701 case 1600: if (pw_max > 16) pw_max = 16;
10702 break;
10703 case 1800: if (pw_max > 16) pw_max = 16;
10704 break;
10705 case 2100: if (pw_max > 16) pw_max = 16;
10706 break;
10707 case 2500: if (pw_min < 8) pw_min = 8;
10708 break;
10709 case 3000: if (pw_max > 7) pw_max = 7;
10710 break;
10711 case 5200: if (pw_max > 24) pw_max = 24;
10712 break;
10713 case 5800: if (pw_max > 16) pw_max = 16;
10714 break;
10715 case 6300: if (pw_max > 16) pw_max = 16;
10716 break;
10717 case 7400: if (pw_max > 16) pw_max = 16;
10718 break;
10719 case 7900: if (pw_max > 48) pw_max = 48;
10720 break;
10721 case 8500: if (pw_max > 8) pw_max = 8;
10722 break;
10723 case 8600: if (pw_max > 16) pw_max = 16;
10724 break;
10725 case 9710: pw_min = 5;
10726 pw_max = 5;
10727 break;
10728 case 9810: pw_min = 5;
10729 pw_max = 5;
10730 break;
10731 case 10410: pw_min = 5;
10732 pw_max = 5;
10733 break;
10734 case 10300: if (pw_max < 3) pw_min = 3;
10735 if (pw_max > 40) pw_max = 40;
10736 break;
10737 case 10500: if (pw_max < 3) pw_min = 3;
10738 if (pw_max > 40) pw_max = 40;
10739 break;
10740 case 10700: if (pw_max > 16) pw_max = 16;
10741 break;
10742 case 11300: if (pw_max > 40) pw_max = 40;
10743 break;
10744 case 11600: if (pw_max > 32) pw_max = 32;
10745 break;
10746 case 12500: if (pw_max > 20) pw_max = 20;
10747 break;
10748 case 12800: if (pw_max > 24) pw_max = 24;
10749 break;
10750 }
10751
10752 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10753 {
10754 switch (attack_kern)
10755 {
10756 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10757 break;
10758 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10759 break;
10760 }
10761 }
10762
10763 /**
10764 * charsets : keep them together for more easy maintainnce
10765 */
10766
10767 cs_t mp_sys[6] = { { { 0 }, 0 } };
10768 cs_t mp_usr[4] = { { { 0 }, 0 } };
10769
10770 mp_setup_sys (mp_sys);
10771
10772 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10773 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10774 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10775 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10776
10777 /**
10778 * load hashes, part I: find input mode, count hashes
10779 */
10780
10781 uint hashlist_mode = 0;
10782 uint hashlist_format = HLFMT_HASHCAT;
10783
10784 uint hashes_avail = 0;
10785
10786 if (benchmark == 0)
10787 {
10788 struct stat f;
10789
10790 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10791
10792 if ((hash_mode == 2500) ||
10793 (hash_mode == 5200) ||
10794 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10795 (hash_mode == 9000))
10796 {
10797 hashlist_mode = HL_MODE_ARG;
10798
10799 char *hashfile = myargv[optind];
10800
10801 data.hashfile = hashfile;
10802
10803 logfile_top_var_string ("target", hashfile);
10804 }
10805
10806 if (hashlist_mode == HL_MODE_ARG)
10807 {
10808 if (hash_mode == 2500)
10809 {
10810 struct stat st;
10811
10812 if (stat (data.hashfile, &st) == -1)
10813 {
10814 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10815
10816 return (-1);
10817 }
10818
10819 hashes_avail = st.st_size / sizeof (hccap_t);
10820 }
10821 else
10822 {
10823 hashes_avail = 1;
10824 }
10825 }
10826 else if (hashlist_mode == HL_MODE_FILE)
10827 {
10828 char *hashfile = myargv[optind];
10829
10830 data.hashfile = hashfile;
10831
10832 logfile_top_var_string ("target", hashfile);
10833
10834 FILE *fp = NULL;
10835
10836 if ((fp = fopen (hashfile, "rb")) == NULL)
10837 {
10838 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10839
10840 return (-1);
10841 }
10842
10843 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10844
10845 hashes_avail = count_lines (fp);
10846
10847 rewind (fp);
10848
10849 if (hashes_avail == 0)
10850 {
10851 log_error ("ERROR: hashfile is empty or corrupt");
10852
10853 fclose (fp);
10854
10855 return (-1);
10856 }
10857
10858 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10859
10860 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10861 {
10862 log_error ("ERROR: remove not supported in native hashfile-format mode");
10863
10864 fclose (fp);
10865
10866 return (-1);
10867 }
10868
10869 fclose (fp);
10870 }
10871 }
10872 else
10873 {
10874 hashlist_mode = HL_MODE_ARG;
10875
10876 hashes_avail = 1;
10877 }
10878
10879 if (hash_mode == 3000) hashes_avail *= 2;
10880
10881 data.hashlist_mode = hashlist_mode;
10882 data.hashlist_format = hashlist_format;
10883
10884 logfile_top_uint (hashlist_mode);
10885 logfile_top_uint (hashlist_format);
10886
10887 /**
10888 * load hashes, part II: allocate required memory, set pointers
10889 */
10890
10891 hash_t *hashes_buf = NULL;
10892 void *digests_buf = NULL;
10893 salt_t *salts_buf = NULL;
10894 void *esalts_buf = NULL;
10895
10896 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10897
10898 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10899
10900 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10901 {
10902 u32 hash_pos;
10903
10904 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10905 {
10906 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10907
10908 hashes_buf[hash_pos].hash_info = hash_info;
10909
10910 if (username && (remove || show || left))
10911 {
10912 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10913 }
10914
10915 if (benchmark)
10916 {
10917 hash_info->orighash = (char *) mymalloc (256);
10918 }
10919 }
10920 }
10921
10922 if (isSalted)
10923 {
10924 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10925
10926 if (esalt_size)
10927 {
10928 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10929 }
10930 }
10931 else
10932 {
10933 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10934 }
10935
10936 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10937 {
10938 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10939
10940 if (isSalted)
10941 {
10942 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10943
10944 if (esalt_size)
10945 {
10946 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10947 }
10948 }
10949 else
10950 {
10951 hashes_buf[hash_pos].salt = &salts_buf[0];
10952 }
10953 }
10954
10955 /**
10956 * load hashes, part III: parse hashes or generate them if benchmark
10957 */
10958
10959 uint hashes_cnt = 0;
10960
10961 if (benchmark == 0)
10962 {
10963 if (keyspace == 1)
10964 {
10965 // useless to read hash file for keyspace, cheat a little bit w/ optind
10966 }
10967 else if (hashes_avail == 0)
10968 {
10969 }
10970 else if (hashlist_mode == HL_MODE_ARG)
10971 {
10972 char *input_buf = myargv[optind];
10973
10974 uint input_len = strlen (input_buf);
10975
10976 logfile_top_var_string ("target", input_buf);
10977
10978 char *hash_buf = NULL;
10979 int hash_len = 0;
10980
10981 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10982
10983 bool hash_fmt_error = 0;
10984
10985 if (hash_len < 1) hash_fmt_error = 1;
10986 if (hash_buf == NULL) hash_fmt_error = 1;
10987
10988 if (hash_fmt_error)
10989 {
10990 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
10991 }
10992 else
10993 {
10994 if (opts_type & OPTS_TYPE_HASH_COPY)
10995 {
10996 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10997
10998 hash_info_tmp->orighash = mystrdup (hash_buf);
10999 }
11000
11001 if (isSalted)
11002 {
11003 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11004 }
11005
11006 int parser_status = PARSER_OK;
11007
11008 if (hash_mode == 2500)
11009 {
11010 if (hash_len == 0)
11011 {
11012 log_error ("ERROR: hccap file not specified");
11013
11014 return (-1);
11015 }
11016
11017 hashlist_mode = HL_MODE_FILE;
11018
11019 data.hashlist_mode = hashlist_mode;
11020
11021 FILE *fp = fopen (hash_buf, "rb");
11022
11023 if (fp == NULL)
11024 {
11025 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11026
11027 return (-1);
11028 }
11029
11030 if (hashes_avail < 1)
11031 {
11032 log_error ("ERROR: hccap file is empty or corrupt");
11033
11034 fclose (fp);
11035
11036 return (-1);
11037 }
11038
11039 uint hccap_size = sizeof (hccap_t);
11040
11041 char *in = (char *) mymalloc (hccap_size);
11042
11043 while (!feof (fp))
11044 {
11045 int n = fread (in, hccap_size, 1, fp);
11046
11047 if (n != 1)
11048 {
11049 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11050
11051 break;
11052 }
11053
11054 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11055
11056 if (parser_status != PARSER_OK)
11057 {
11058 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11059
11060 continue;
11061 }
11062
11063 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11064
11065 if ((show == 1) || (left == 1))
11066 {
11067 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11068
11069 char *salt_ptr = (char *) tmp_salt->salt_buf;
11070
11071 int cur_pos = tmp_salt->salt_len;
11072 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11073
11074 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11075
11076 // do the appending task
11077
11078 snprintf (salt_ptr + cur_pos,
11079 rem_len,
11080 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11081 wpa->orig_mac1[0],
11082 wpa->orig_mac1[1],
11083 wpa->orig_mac1[2],
11084 wpa->orig_mac1[3],
11085 wpa->orig_mac1[4],
11086 wpa->orig_mac1[5],
11087 wpa->orig_mac2[0],
11088 wpa->orig_mac2[1],
11089 wpa->orig_mac2[2],
11090 wpa->orig_mac2[3],
11091 wpa->orig_mac2[4],
11092 wpa->orig_mac2[5]);
11093
11094 // memset () the remaining part of the salt
11095
11096 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11097 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11098
11099 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11100
11101 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11102 }
11103
11104 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);
11105 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);
11106
11107 hashes_cnt++;
11108 }
11109
11110 fclose (fp);
11111
11112 myfree (in);
11113 }
11114 else if (hash_mode == 3000)
11115 {
11116 if (hash_len == 32)
11117 {
11118 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11119
11120 hash_t *lm_hash_left = NULL;
11121
11122 if (parser_status == PARSER_OK)
11123 {
11124 lm_hash_left = &hashes_buf[hashes_cnt];
11125
11126 hashes_cnt++;
11127 }
11128 else
11129 {
11130 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11131 }
11132
11133 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11134
11135 hash_t *lm_hash_right = NULL;
11136
11137 if (parser_status == PARSER_OK)
11138 {
11139 lm_hash_right = &hashes_buf[hashes_cnt];
11140
11141 hashes_cnt++;
11142 }
11143 else
11144 {
11145 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11146 }
11147
11148 // show / left
11149
11150 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11151 {
11152 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);
11153 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);
11154 }
11155 }
11156 else
11157 {
11158 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11159
11160 if (parser_status == PARSER_OK)
11161 {
11162 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11163 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11164 }
11165
11166 if (parser_status == PARSER_OK)
11167 {
11168 hashes_cnt++;
11169 }
11170 else
11171 {
11172 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11173 }
11174 }
11175 }
11176 else
11177 {
11178 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11179
11180 if (parser_status == PARSER_OK)
11181 {
11182 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11183 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11184 }
11185
11186 if (parser_status == PARSER_OK)
11187 {
11188 hashes_cnt++;
11189 }
11190 else
11191 {
11192 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11193 }
11194 }
11195 }
11196 }
11197 else if (hashlist_mode == HL_MODE_FILE)
11198 {
11199 char *hashfile = data.hashfile;
11200
11201 FILE *fp;
11202
11203 if ((fp = fopen (hashfile, "rb")) == NULL)
11204 {
11205 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11206
11207 return (-1);
11208 }
11209
11210 uint line_num = 0;
11211
11212 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11213
11214 while (!feof (fp))
11215 {
11216 line_num++;
11217
11218 int line_len = fgetl (fp, line_buf);
11219
11220 if (line_len == 0) continue;
11221
11222 char *hash_buf = NULL;
11223 int hash_len = 0;
11224
11225 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11226
11227 bool hash_fmt_error = 0;
11228
11229 if (hash_len < 1) hash_fmt_error = 1;
11230 if (hash_buf == NULL) hash_fmt_error = 1;
11231
11232 if (hash_fmt_error)
11233 {
11234 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11235
11236 continue;
11237 }
11238
11239 if (username)
11240 {
11241 char *user_buf = NULL;
11242 int user_len = 0;
11243
11244 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11245
11246 if (remove || show)
11247 {
11248 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11249
11250 *user = (user_t *) mymalloc (sizeof (user_t));
11251
11252 user_t *user_ptr = *user;
11253
11254 if (user_buf != NULL)
11255 {
11256 user_ptr->user_name = mystrdup (user_buf);
11257 }
11258 else
11259 {
11260 user_ptr->user_name = mystrdup ("");
11261 }
11262
11263 user_ptr->user_len = user_len;
11264 }
11265 }
11266
11267 if (opts_type & OPTS_TYPE_HASH_COPY)
11268 {
11269 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11270
11271 hash_info_tmp->orighash = mystrdup (hash_buf);
11272 }
11273
11274 if (isSalted)
11275 {
11276 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11277 }
11278
11279 if (hash_mode == 3000)
11280 {
11281 if (hash_len == 32)
11282 {
11283 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11284
11285 if (parser_status < PARSER_GLOBAL_ZERO)
11286 {
11287 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11288
11289 continue;
11290 }
11291
11292 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11293
11294 hashes_cnt++;
11295
11296 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11297
11298 if (parser_status < PARSER_GLOBAL_ZERO)
11299 {
11300 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11301
11302 continue;
11303 }
11304
11305 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11306
11307 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);
11308
11309 hashes_cnt++;
11310
11311 // show / left
11312
11313 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);
11314 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);
11315 }
11316 else
11317 {
11318 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11319
11320 if (parser_status < PARSER_GLOBAL_ZERO)
11321 {
11322 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11323
11324 continue;
11325 }
11326
11327 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);
11328
11329 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11330 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11331
11332 hashes_cnt++;
11333 }
11334 }
11335 else
11336 {
11337 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11338
11339 if (parser_status < PARSER_GLOBAL_ZERO)
11340 {
11341 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11342
11343 continue;
11344 }
11345
11346 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);
11347
11348 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11349 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11350
11351 hashes_cnt++;
11352 }
11353 }
11354
11355 myfree (line_buf);
11356
11357 fclose (fp);
11358
11359 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11360
11361 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11362 }
11363 }
11364 else
11365 {
11366 if (isSalted)
11367 {
11368 hashes_buf[0].salt->salt_len = 8;
11369
11370 // special salt handling
11371
11372 switch (hash_mode)
11373 {
11374 case 1500: hashes_buf[0].salt->salt_len = 2;
11375 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11376 break;
11377 case 1731: hashes_buf[0].salt->salt_len = 4;
11378 break;
11379 case 2410: hashes_buf[0].salt->salt_len = 4;
11380 break;
11381 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11382 break;
11383 case 3100: hashes_buf[0].salt->salt_len = 1;
11384 break;
11385 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11386 break;
11387 case 5800: hashes_buf[0].salt->salt_len = 16;
11388 break;
11389 case 6800: hashes_buf[0].salt->salt_len = 32;
11390 break;
11391 case 8400: hashes_buf[0].salt->salt_len = 40;
11392 break;
11393 case 8800: hashes_buf[0].salt->salt_len = 16;
11394 break;
11395 case 8900: hashes_buf[0].salt->salt_len = 16;
11396 hashes_buf[0].salt->scrypt_N = 1024;
11397 hashes_buf[0].salt->scrypt_r = 1;
11398 hashes_buf[0].salt->scrypt_p = 1;
11399 break;
11400 case 9100: hashes_buf[0].salt->salt_len = 16;
11401 break;
11402 case 9300: hashes_buf[0].salt->salt_len = 14;
11403 hashes_buf[0].salt->scrypt_N = 16384;
11404 hashes_buf[0].salt->scrypt_r = 1;
11405 hashes_buf[0].salt->scrypt_p = 1;
11406 break;
11407 case 9400: hashes_buf[0].salt->salt_len = 16;
11408 break;
11409 case 9500: hashes_buf[0].salt->salt_len = 16;
11410 break;
11411 case 9600: hashes_buf[0].salt->salt_len = 16;
11412 break;
11413 case 9700: hashes_buf[0].salt->salt_len = 16;
11414 break;
11415 case 9710: hashes_buf[0].salt->salt_len = 16;
11416 break;
11417 case 9720: hashes_buf[0].salt->salt_len = 16;
11418 break;
11419 case 9800: hashes_buf[0].salt->salt_len = 16;
11420 break;
11421 case 9810: hashes_buf[0].salt->salt_len = 16;
11422 break;
11423 case 9820: hashes_buf[0].salt->salt_len = 16;
11424 break;
11425 case 10300: hashes_buf[0].salt->salt_len = 12;
11426 break;
11427 case 11500: hashes_buf[0].salt->salt_len = 4;
11428 break;
11429 case 11600: hashes_buf[0].salt->salt_len = 4;
11430 break;
11431 case 12400: hashes_buf[0].salt->salt_len = 4;
11432 break;
11433 case 12500: hashes_buf[0].salt->salt_len = 8;
11434 break;
11435 case 12600: hashes_buf[0].salt->salt_len = 64;
11436 break;
11437 }
11438
11439 // special esalt handling
11440
11441 switch (hash_mode)
11442 {
11443 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11444 break;
11445 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11446 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11447 break;
11448 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11449 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11450 break;
11451 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11452 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11453 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11454 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11455 break;
11456 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11457 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11458 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11459 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11460 break;
11461 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11462 break;
11463 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11464 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11465 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11466 break;
11467 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11468 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11469 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11470 break;
11471 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11472 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11473 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11474 break;
11475 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11476 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11477 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11478 break;
11479 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11480 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11481 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11482 break;
11483 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11484 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11485 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11486 break;
11487 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11488 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11489 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11490 break;
11491 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11492 break;
11493 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
11494 break;
11495 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
11496 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
11497 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
11498 break;
11499 }
11500 }
11501
11502 // set hashfile
11503
11504 switch (hash_mode)
11505 {
11506 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11507 break;
11508 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11509 break;
11510 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11511 break;
11512 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11513 break;
11514 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11515 break;
11516 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11517 break;
11518 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11519 break;
11520 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11521 break;
11522 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11523 break;
11524 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11525 break;
11526 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11527 break;
11528 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11529 break;
11530 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11531 break;
11532 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11533 break;
11534 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11535 break;
11536 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11537 break;
11538 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11539 break;
11540 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11541 break;
11542 }
11543
11544 // set default iterations
11545
11546 switch (hash_mode)
11547 {
11548 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11549 break;
11550 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11551 break;
11552 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11553 break;
11554 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11555 break;
11556 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11557 break;
11558 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11559 break;
11560 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11561 break;
11562 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11563 break;
11564 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11565 break;
11566 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11567 break;
11568 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11569 break;
11570 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11571 break;
11572 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11573 break;
11574 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11575 break;
11576 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11577 break;
11578 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11579 break;
11580 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11581 break;
11582 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11583 break;
11584 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11585 break;
11586 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11587 break;
11588 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11589 break;
11590 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11591 break;
11592 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11593 break;
11594 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11595 break;
11596 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11597 break;
11598 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11599 break;
11600 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11601 break;
11602 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11603 break;
11604 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11605 break;
11606 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11607 break;
11608 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11609 break;
11610 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11611 break;
11612 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11613 break;
11614 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11615 break;
11616 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11617 break;
11618 case 8900: hashes_buf[0].salt->salt_iter = 1;
11619 break;
11620 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11621 break;
11622 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11623 break;
11624 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11625 break;
11626 case 9300: hashes_buf[0].salt->salt_iter = 1;
11627 break;
11628 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11629 break;
11630 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11631 break;
11632 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11633 break;
11634 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11635 break;
11636 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11637 break;
11638 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11639 break;
11640 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11641 break;
11642 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11643 break;
11644 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11645 break;
11646 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11647 break;
11648 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11649 break;
11650 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11651 break;
11652 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11653 break;
11654 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11655 break;
11656 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11657 break;
11658 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11659 break;
11660 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11661 break;
11662 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11663 break;
11664 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11665 break;
11666 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11667 break;
11668 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11669 break;
11670 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
11671 break;
11672 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
11673 break;
11674 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
11675 break;
11676 }
11677
11678 hashes_cnt = 1;
11679 }
11680
11681 if (show == 1 || left == 1)
11682 {
11683 for (uint i = 0; i < pot_cnt; i++)
11684 {
11685 pot_t *pot_ptr = &pot[i];
11686
11687 hash_t *hashes_buf = &pot_ptr->hash;
11688
11689 local_free (hashes_buf->digest);
11690
11691 if (isSalted)
11692 {
11693 local_free (hashes_buf->salt);
11694 }
11695 }
11696
11697 local_free (pot);
11698
11699 if (data.quiet == 0) log_info_nn ("");
11700
11701 return (0);
11702 }
11703
11704 if (keyspace == 0)
11705 {
11706 if (hashes_cnt == 0)
11707 {
11708 log_error ("ERROR: No hashes loaded");
11709
11710 return (-1);
11711 }
11712 }
11713
11714 /**
11715 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11716 */
11717
11718 if (data.outfile != NULL)
11719 {
11720 if (data.hashfile != NULL)
11721 {
11722 #ifdef _POSIX
11723 struct stat tmpstat_outfile;
11724 struct stat tmpstat_hashfile;
11725 #endif
11726
11727 #ifdef _WIN
11728 struct stat64 tmpstat_outfile;
11729 struct stat64 tmpstat_hashfile;
11730 #endif
11731
11732 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11733
11734 if (tmp_outfile_fp)
11735 {
11736 #ifdef _POSIX
11737 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11738 #endif
11739
11740 #ifdef _WIN
11741 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11742 #endif
11743
11744 fclose (tmp_outfile_fp);
11745 }
11746
11747 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11748
11749 if (tmp_hashfile_fp)
11750 {
11751 #ifdef _POSIX
11752 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11753 #endif
11754
11755 #ifdef _WIN
11756 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11757 #endif
11758
11759 fclose (tmp_hashfile_fp);
11760 }
11761
11762 if (tmp_outfile_fp && tmp_outfile_fp)
11763 {
11764 tmpstat_outfile.st_mode = 0;
11765 tmpstat_outfile.st_nlink = 0;
11766 tmpstat_outfile.st_uid = 0;
11767 tmpstat_outfile.st_gid = 0;
11768 tmpstat_outfile.st_rdev = 0;
11769 tmpstat_outfile.st_atime = 0;
11770
11771 tmpstat_hashfile.st_mode = 0;
11772 tmpstat_hashfile.st_nlink = 0;
11773 tmpstat_hashfile.st_uid = 0;
11774 tmpstat_hashfile.st_gid = 0;
11775 tmpstat_hashfile.st_rdev = 0;
11776 tmpstat_hashfile.st_atime = 0;
11777
11778 #ifdef _POSIX
11779 tmpstat_outfile.st_blksize = 0;
11780 tmpstat_outfile.st_blocks = 0;
11781
11782 tmpstat_hashfile.st_blksize = 0;
11783 tmpstat_hashfile.st_blocks = 0;
11784 #endif
11785
11786 #ifdef _POSIX
11787 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11788 {
11789 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11790
11791 return (-1);
11792 }
11793 #endif
11794
11795 #ifdef _WIN
11796 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11797 {
11798 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11799
11800 return (-1);
11801 }
11802 #endif
11803 }
11804 }
11805 }
11806
11807 /**
11808 * Remove duplicates
11809 */
11810
11811 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11812
11813 if (isSalted)
11814 {
11815 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11816 }
11817 else
11818 {
11819 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11820 }
11821
11822 uint hashes_cnt_orig = hashes_cnt;
11823
11824 hashes_cnt = 1;
11825
11826 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11827 {
11828 if (isSalted)
11829 {
11830 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11831 {
11832 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11833 }
11834 }
11835 else
11836 {
11837 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11838 }
11839
11840 if (hashes_pos > hashes_cnt)
11841 {
11842 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11843 }
11844
11845 hashes_cnt++;
11846 }
11847
11848 /**
11849 * Potfile removes
11850 */
11851
11852 uint potfile_remove_cracks = 0;
11853
11854 if (potfile_disable == 0)
11855 {
11856 hash_t hash_buf;
11857
11858 hash_buf.digest = mymalloc (dgst_size);
11859 hash_buf.salt = NULL;
11860 hash_buf.esalt = NULL;
11861 hash_buf.hash_info = NULL;
11862 hash_buf.cracked = 0;
11863
11864 if (isSalted)
11865 {
11866 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11867 }
11868
11869 if (esalt_size)
11870 {
11871 hash_buf.esalt = mymalloc (esalt_size);
11872 }
11873
11874 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11875
11876 // no solution for these special hash types (for instane because they use hashfile in output etc)
11877 if ((hash_mode != 5200) &&
11878 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11879 (hash_mode != 9000))
11880 {
11881 FILE *fp = fopen (potfile, "rb");
11882
11883 if (fp != NULL)
11884 {
11885 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11886
11887 // to be safe work with a copy (because of line_len loop, i etc)
11888 // moved up here because it's easier to handle continue case
11889 // it's just 64kb
11890
11891 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
11892
11893 while (!feof (fp))
11894 {
11895 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
11896
11897 if (ptr == NULL) break;
11898
11899 int line_len = strlen (line_buf);
11900
11901 if (line_len == 0) continue;
11902
11903 int iter = MAX_CUT_TRIES;
11904
11905 for (int i = line_len - 1; i && iter; i--, line_len--)
11906 {
11907 if (line_buf[i] != ':') continue;
11908
11909 if (isSalted)
11910 {
11911 memset (hash_buf.salt, 0, sizeof (salt_t));
11912 }
11913
11914 hash_t *found = NULL;
11915
11916 if (hash_mode == 6800)
11917 {
11918 if (i < 64) // 64 = 16 * uint in salt_buf[]
11919 {
11920 // manipulate salt_buf
11921 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11922
11923 hash_buf.salt->salt_len = i;
11924
11925 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11926 }
11927 }
11928 else if (hash_mode == 2500)
11929 {
11930 if (i < 64) // 64 = 16 * uint in salt_buf[]
11931 {
11932 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11933 // manipulate salt_buf
11934
11935 memcpy (line_buf_cpy, line_buf, i);
11936
11937 char *mac2_pos = strrchr (line_buf_cpy, ':');
11938
11939 if (mac2_pos == NULL) continue;
11940
11941 mac2_pos[0] = 0;
11942 mac2_pos++;
11943
11944 if (strlen (mac2_pos) != 12) continue;
11945
11946 char *mac1_pos = strrchr (line_buf_cpy, ':');
11947
11948 if (mac1_pos == NULL) continue;
11949
11950 mac1_pos[0] = 0;
11951 mac1_pos++;
11952
11953 if (strlen (mac1_pos) != 12) continue;
11954
11955 uint essid_length = mac1_pos - line_buf_cpy - 1;
11956
11957 // here we need the ESSID
11958 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11959
11960 hash_buf.salt->salt_len = essid_length;
11961
11962 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11963
11964 if (found)
11965 {
11966 wpa_t *wpa = (wpa_t *) found->esalt;
11967
11968 // compare hex string(s) vs binary MAC address(es)
11969
11970 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11971 {
11972 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11973 {
11974 found = NULL;
11975
11976 break;
11977 }
11978 }
11979
11980 // early skip ;)
11981 if (!found) continue;
11982
11983 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11984 {
11985 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11986 {
11987 found = NULL;
11988
11989 break;
11990 }
11991 }
11992 }
11993 }
11994 }
11995 else
11996 {
11997 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11998
11999 if (parser_status == PARSER_OK)
12000 {
12001 if (isSalted)
12002 {
12003 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12004 }
12005 else
12006 {
12007 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12008 }
12009 }
12010 }
12011
12012 if (found == NULL) continue;
12013
12014 if (!found->cracked) potfile_remove_cracks++;
12015
12016 found->cracked = 1;
12017
12018 if (found) break;
12019
12020 iter--;
12021 }
12022 }
12023
12024 myfree (line_buf_cpy);
12025
12026 myfree (line_buf);
12027
12028 fclose (fp);
12029 }
12030 }
12031
12032 if (esalt_size)
12033 {
12034 local_free (hash_buf.esalt);
12035 }
12036
12037 if (isSalted)
12038 {
12039 local_free (hash_buf.salt);
12040 }
12041
12042 local_free (hash_buf.digest);
12043 }
12044
12045 /**
12046 * Now generate all the buffers required for later
12047 */
12048
12049 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12050
12051 salt_t *salts_buf_new = NULL;
12052 void *esalts_buf_new = NULL;
12053
12054 if (isSalted)
12055 {
12056 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12057
12058 if (esalt_size)
12059 {
12060 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12061 }
12062 }
12063 else
12064 {
12065 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12066 }
12067
12068 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12069
12070 uint digests_cnt = hashes_cnt;
12071 uint digests_done = 0;
12072
12073 size_t size_digests = digests_cnt * dgst_size;
12074 size_t size_shown = digests_cnt * sizeof (uint);
12075
12076 uint *digests_shown = (uint *) mymalloc (size_shown);
12077 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12078
12079 uint salts_cnt = 0;
12080 uint salts_done = 0;
12081
12082 hashinfo_t **hash_info = NULL;
12083
12084 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12085 {
12086 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12087
12088 if (username && (remove || show))
12089 {
12090 uint user_pos;
12091
12092 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12093 {
12094 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12095
12096 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12097 }
12098 }
12099 }
12100
12101 uint *salts_shown = (uint *) mymalloc (size_shown);
12102
12103 salt_t *salt_buf;
12104
12105 {
12106 // copied from inner loop
12107
12108 salt_buf = &salts_buf_new[salts_cnt];
12109
12110 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12111
12112 if (esalt_size)
12113 {
12114 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12115 }
12116
12117 salt_buf->digests_cnt = 0;
12118 salt_buf->digests_done = 0;
12119 salt_buf->digests_offset = 0;
12120
12121 salts_cnt++;
12122 }
12123
12124 if (hashes_buf[0].cracked == 1)
12125 {
12126 digests_shown[0] = 1;
12127
12128 digests_done++;
12129
12130 salt_buf->digests_done++;
12131 }
12132
12133 salt_buf->digests_cnt++;
12134
12135 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12136
12137 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12138 {
12139 hash_info[0] = hashes_buf[0].hash_info;
12140 }
12141
12142 // copy from inner loop
12143
12144 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12145 {
12146 if (isSalted)
12147 {
12148 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12149 {
12150 salt_buf = &salts_buf_new[salts_cnt];
12151
12152 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12153
12154 if (esalt_size)
12155 {
12156 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12157 }
12158
12159 salt_buf->digests_cnt = 0;
12160 salt_buf->digests_done = 0;
12161 salt_buf->digests_offset = hashes_pos;
12162
12163 salts_cnt++;
12164 }
12165 }
12166
12167 if (hashes_buf[hashes_pos].cracked == 1)
12168 {
12169 digests_shown[hashes_pos] = 1;
12170
12171 digests_done++;
12172
12173 salt_buf->digests_done++;
12174 }
12175
12176 salt_buf->digests_cnt++;
12177
12178 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12179
12180 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12181 {
12182 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12183 }
12184 }
12185
12186 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12187 {
12188 salt_t *salt_buf = &salts_buf_new[salt_pos];
12189
12190 if (salt_buf->digests_done == salt_buf->digests_cnt)
12191 {
12192 salts_shown[salt_pos] = 1;
12193
12194 salts_done++;
12195 }
12196
12197 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12198 }
12199
12200 local_free (digests_buf);
12201 local_free (salts_buf);
12202 local_free (esalts_buf);
12203
12204 digests_buf = digests_buf_new;
12205 salts_buf = salts_buf_new;
12206 esalts_buf = esalts_buf_new;
12207
12208 local_free (hashes_buf);
12209
12210 /**
12211 * special modification not set from parser
12212 */
12213
12214 switch (hash_mode)
12215 {
12216 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12217 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12218 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12219 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12220 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12221 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12222 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12223 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12224 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12225 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12226 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12227 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12228 }
12229
12230 if (truecrypt_keyfiles)
12231 {
12232 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12233
12234 char *keyfiles = strdup (truecrypt_keyfiles);
12235
12236 char *keyfile = strtok (keyfiles, ",");
12237
12238 do
12239 {
12240 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12241
12242 } while ((keyfile = strtok (NULL, ",")) != NULL);
12243
12244 free (keyfiles);
12245 }
12246
12247 data.digests_cnt = digests_cnt;
12248 data.digests_done = digests_done;
12249 data.digests_buf = digests_buf;
12250 data.digests_shown = digests_shown;
12251 data.digests_shown_tmp = digests_shown_tmp;
12252
12253 data.salts_cnt = salts_cnt;
12254 data.salts_done = salts_done;
12255 data.salts_buf = salts_buf;
12256 data.salts_shown = salts_shown;
12257
12258 data.esalts_buf = esalts_buf;
12259 data.hash_info = hash_info;
12260
12261 /**
12262 * Automatic Optimizers
12263 */
12264
12265 if (salts_cnt == 1)
12266 opti_type |= OPTI_TYPE_SINGLE_SALT;
12267
12268 if (digests_cnt == 1)
12269 opti_type |= OPTI_TYPE_SINGLE_HASH;
12270
12271 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12272 opti_type |= OPTI_TYPE_NOT_ITERATED;
12273
12274 if (attack_mode == ATTACK_MODE_BF)
12275 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12276
12277 data.opti_type = opti_type;
12278
12279 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12280 {
12281 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12282 {
12283 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12284 {
12285 if (opts_type & OPTS_TYPE_ST_ADD80)
12286 {
12287 opts_type &= ~OPTS_TYPE_ST_ADD80;
12288 opts_type |= OPTS_TYPE_PT_ADD80;
12289 }
12290
12291 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12292 {
12293 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12294 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12295 }
12296
12297 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12298 {
12299 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12300 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12301 }
12302 }
12303 }
12304 }
12305
12306 /**
12307 * Some algorithm, like descrypt, can benefit from JIT compilation
12308 */
12309
12310 int force_jit_compilation = -1;
12311
12312 if (hash_mode == 8900)
12313 {
12314 force_jit_compilation = 8900;
12315 }
12316 else if (hash_mode == 9300)
12317 {
12318 force_jit_compilation = 8900;
12319 }
12320 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12321 {
12322 force_jit_compilation = 1500;
12323 }
12324
12325 /**
12326 * generate bitmap tables
12327 */
12328
12329 const uint bitmap_shift1 = 5;
12330 const uint bitmap_shift2 = 13;
12331
12332 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12333
12334 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12335 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12336 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12337 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12338 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12339 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12340 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12341 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12342
12343 uint bitmap_bits;
12344 uint bitmap_nums;
12345 uint bitmap_mask;
12346 uint bitmap_size;
12347
12348 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12349 {
12350 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12351
12352 bitmap_nums = 1 << bitmap_bits;
12353
12354 bitmap_mask = bitmap_nums - 1;
12355
12356 bitmap_size = bitmap_nums * sizeof (uint);
12357
12358 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12359
12360 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;
12361 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;
12362
12363 break;
12364 }
12365
12366 bitmap_nums = 1 << bitmap_bits;
12367
12368 bitmap_mask = bitmap_nums - 1;
12369
12370 bitmap_size = bitmap_nums * sizeof (uint);
12371
12372 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);
12373 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);
12374
12375 /**
12376 * prepare quick rule
12377 */
12378
12379 data.rule_buf_l = rule_buf_l;
12380 data.rule_buf_r = rule_buf_r;
12381
12382 int rule_len_l = (int) strlen (rule_buf_l);
12383 int rule_len_r = (int) strlen (rule_buf_r);
12384
12385 data.rule_len_l = rule_len_l;
12386 data.rule_len_r = rule_len_r;
12387
12388 /**
12389 * load rules
12390 */
12391
12392 uint *all_kernel_rules_cnt = NULL;
12393
12394 kernel_rule_t **all_kernel_rules_buf = NULL;
12395
12396 if (rp_files_cnt)
12397 {
12398 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12399
12400 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12401 }
12402
12403 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12404
12405 int rule_len = 0;
12406
12407 for (uint i = 0; i < rp_files_cnt; i++)
12408 {
12409 uint kernel_rules_avail = 0;
12410
12411 uint kernel_rules_cnt = 0;
12412
12413 kernel_rule_t *kernel_rules_buf = NULL;
12414
12415 char *rp_file = rp_files[i];
12416
12417 char in[BLOCK_SIZE] = { 0 };
12418 char out[BLOCK_SIZE] = { 0 };
12419
12420 FILE *fp = NULL;
12421
12422 uint rule_line = 0;
12423
12424 if ((fp = fopen (rp_file, "rb")) == NULL)
12425 {
12426 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12427
12428 return (-1);
12429 }
12430
12431 while (!feof (fp))
12432 {
12433 memset (rule_buf, 0, HCBUFSIZ);
12434
12435 rule_len = fgetl (fp, rule_buf);
12436
12437 rule_line++;
12438
12439 if (rule_len == 0) continue;
12440
12441 if (rule_buf[0] == '#') continue;
12442
12443 if (kernel_rules_avail == kernel_rules_cnt)
12444 {
12445 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12446
12447 kernel_rules_avail += INCR_RULES;
12448 }
12449
12450 memset (in, 0, BLOCK_SIZE);
12451 memset (out, 0, BLOCK_SIZE);
12452
12453 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12454
12455 if (result == -1)
12456 {
12457 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12458
12459 continue;
12460 }
12461
12462 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12463 {
12464 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12465
12466 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12467
12468 continue;
12469 }
12470
12471 /* its so slow
12472 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12473 {
12474 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12475
12476 continue;
12477 }
12478 */
12479
12480 kernel_rules_cnt++;
12481 }
12482
12483 fclose (fp);
12484
12485 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12486
12487 all_kernel_rules_buf[i] = kernel_rules_buf;
12488 }
12489
12490 /**
12491 * merge rules or automatic rule generator
12492 */
12493
12494 uint kernel_rules_cnt = 0;
12495
12496 kernel_rule_t *kernel_rules_buf = NULL;
12497
12498 if (attack_mode == ATTACK_MODE_STRAIGHT)
12499 {
12500 if (rp_files_cnt)
12501 {
12502 kernel_rules_cnt = 1;
12503
12504 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12505
12506 repeats[0] = kernel_rules_cnt;
12507
12508 for (uint i = 0; i < rp_files_cnt; i++)
12509 {
12510 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12511
12512 repeats[i + 1] = kernel_rules_cnt;
12513 }
12514
12515 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12516
12517 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12518
12519 for (uint i = 0; i < kernel_rules_cnt; i++)
12520 {
12521 uint out_pos = 0;
12522
12523 kernel_rule_t *out = &kernel_rules_buf[i];
12524
12525 for (uint j = 0; j < rp_files_cnt; j++)
12526 {
12527 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12528 uint in_pos;
12529
12530 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12531
12532 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12533 {
12534 if (out_pos == RULES_MAX - 1)
12535 {
12536 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12537
12538 break;
12539 }
12540
12541 out->cmds[out_pos] = in->cmds[in_pos];
12542 }
12543 }
12544 }
12545
12546 local_free (repeats);
12547 }
12548 else if (rp_gen)
12549 {
12550 uint kernel_rules_avail = 0;
12551
12552 while (kernel_rules_cnt < rp_gen)
12553 {
12554 if (kernel_rules_avail == kernel_rules_cnt)
12555 {
12556 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12557
12558 kernel_rules_avail += INCR_RULES;
12559 }
12560
12561 memset (rule_buf, 0, HCBUFSIZ);
12562
12563 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12564
12565 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12566
12567 kernel_rules_cnt++;
12568 }
12569 }
12570 }
12571
12572 myfree (rule_buf);
12573
12574 /**
12575 * generate NOP rules
12576 */
12577
12578 if (kernel_rules_cnt == 0)
12579 {
12580 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12581
12582 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12583
12584 kernel_rules_cnt++;
12585 }
12586
12587 data.kernel_rules_cnt = kernel_rules_cnt;
12588 data.kernel_rules_buf = kernel_rules_buf;
12589
12590 /**
12591 * OpenCL platforms: detect
12592 */
12593
12594 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12595 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12596
12597 cl_uint platforms_cnt = 0;
12598 cl_uint platform_devices_cnt = 0;
12599
12600 if (keyspace == 0)
12601 {
12602 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12603
12604 if (platforms_cnt == 0)
12605 {
12606 log_info ("");
12607 log_info ("ATTENTION! No OpenCL compatible platform found");
12608 log_info ("");
12609 log_info ("You're probably missing the OpenCL runtime installation");
12610 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
12611 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
12612 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
12613 log_info ("");
12614
12615 return (-1);
12616 }
12617
12618 if (opencl_platforms_filter != (uint) -1)
12619 {
12620 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
12621
12622 if (opencl_platforms_filter > platform_cnt_mask)
12623 {
12624 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
12625
12626 return (-1);
12627 }
12628 }
12629 }
12630
12631 /**
12632 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12633 */
12634
12635 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12636 {
12637 cl_platform_id platform = platforms[platform_id];
12638
12639 char platform_vendor[INFOSZ] = { 0 };
12640
12641 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12642
12643 #ifdef HAVE_HWMON
12644 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12645 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12646 {
12647 // make sure that we do not directly control the fan for NVidia
12648
12649 gpu_temp_retain = 0;
12650
12651 data.gpu_temp_retain = gpu_temp_retain;
12652 }
12653 #endif // HAVE_NVML || HAVE_NVAPI
12654 #endif
12655 }
12656
12657 /**
12658 * OpenCL device types:
12659 * 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.
12660 * In such a case, automatically enable CPU device type support, since it's disabled by default.
12661 */
12662
12663 if (opencl_device_types == NULL)
12664 {
12665 cl_device_type device_types_all = 0;
12666
12667 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12668 {
12669 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12670
12671 cl_platform_id platform = platforms[platform_id];
12672
12673 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12674
12675 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12676 {
12677 cl_device_id device = platform_devices[platform_devices_id];
12678
12679 cl_device_type device_type;
12680
12681 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12682
12683 device_types_all |= device_type;
12684 }
12685 }
12686
12687 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
12688 {
12689 device_types_filter |= CL_DEVICE_TYPE_CPU;
12690 }
12691 }
12692
12693 /**
12694 * OpenCL devices: simply push all devices from all platforms into the same device array
12695 */
12696
12697 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12698
12699 data.devices_param = devices_param;
12700
12701 uint devices_cnt = 0;
12702
12703 uint devices_active = 0;
12704
12705 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12706 {
12707 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12708
12709 cl_platform_id platform = platforms[platform_id];
12710
12711 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12712
12713 char platform_vendor[INFOSZ] = { 0 };
12714
12715 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12716
12717 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
12718 // this causes trouble with vendor id based macros
12719 // we'll assign generic to those without special optimization available
12720
12721 cl_uint vendor_id = 0;
12722
12723 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
12724 {
12725 vendor_id = VENDOR_ID_AMD;
12726 }
12727 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
12728 {
12729 vendor_id = VENDOR_ID_APPLE;
12730 }
12731 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
12732 {
12733 vendor_id = VENDOR_ID_INTEL_BEIGNET;
12734 }
12735 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
12736 {
12737 vendor_id = VENDOR_ID_INTEL_SDK;
12738 }
12739 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
12740 {
12741 vendor_id = VENDOR_ID_MESA;
12742 }
12743 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12744 {
12745 vendor_id = VENDOR_ID_NV;
12746 }
12747 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
12748 {
12749 vendor_id = VENDOR_ID_POCL;
12750 }
12751 else
12752 {
12753 vendor_id = VENDOR_ID_GENERIC;
12754 }
12755
12756 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12757 {
12758 size_t param_value_size = 0;
12759
12760 const uint device_id = devices_cnt;
12761
12762 hc_device_param_t *device_param = &data.devices_param[device_id];
12763
12764 device_param->vendor_id = vendor_id;
12765
12766 device_param->device = platform_devices[platform_devices_id];
12767
12768 device_param->device_id = device_id;
12769
12770 device_param->platform_devices_id = platform_devices_id;
12771
12772 // device_type
12773
12774 cl_device_type device_type;
12775
12776 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12777
12778 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12779
12780 device_param->device_type = device_type;
12781
12782 // device_name
12783
12784 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12785
12786 char *device_name = (char *) mymalloc (param_value_size);
12787
12788 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12789
12790 device_param->device_name = device_name;
12791
12792 // tuning db
12793
12794 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12795
12796 // device_version
12797
12798 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12799
12800 char *device_version = (char *) mymalloc (param_value_size);
12801
12802 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12803
12804 device_param->device_version = device_version;
12805
12806 // device_opencl_version
12807
12808 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12809
12810 char *device_opencl_version = (char *) mymalloc (param_value_size);
12811
12812 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12813
12814 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12815
12816 myfree (device_opencl_version);
12817
12818 // vector_width
12819
12820 cl_uint vector_width;
12821
12822 if (opencl_vector_width_chgd == 0)
12823 {
12824 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12825 {
12826 if (opti_type & OPTI_TYPE_USES_BITS_64)
12827 {
12828 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12829 }
12830 else
12831 {
12832 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12833 }
12834 }
12835 else
12836 {
12837 vector_width = (cl_uint) tuningdb_entry->vector_width;
12838 }
12839 }
12840 else
12841 {
12842 vector_width = opencl_vector_width;
12843 }
12844
12845 if (vector_width > 16) vector_width = 16;
12846
12847 device_param->vector_width = vector_width;
12848
12849 // max_compute_units
12850
12851 cl_uint device_processors;
12852
12853 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12854
12855 device_param->device_processors = device_processors;
12856
12857 // device_maxmem_alloc
12858 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
12859
12860 cl_ulong device_maxmem_alloc;
12861
12862 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12863
12864 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
12865
12866 // device_global_mem
12867
12868 cl_ulong device_global_mem;
12869
12870 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12871
12872 device_param->device_global_mem = device_global_mem;
12873
12874 // max_work_group_size
12875
12876 size_t device_maxworkgroup_size;
12877
12878 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
12879
12880 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
12881
12882 // max_clock_frequency
12883
12884 cl_uint device_maxclock_frequency;
12885
12886 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12887
12888 device_param->device_maxclock_frequency = device_maxclock_frequency;
12889
12890 // device_endian_little
12891
12892 cl_bool device_endian_little;
12893
12894 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
12895
12896 if (device_endian_little == CL_FALSE)
12897 {
12898 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
12899
12900 device_param->skipped = 1;
12901 }
12902
12903 // device_available
12904
12905 cl_bool device_available;
12906
12907 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
12908
12909 if (device_available == CL_FALSE)
12910 {
12911 log_info ("Device #%u: WARNING: device not available", device_id + 1);
12912
12913 device_param->skipped = 1;
12914 }
12915
12916 // device_compiler_available
12917
12918 cl_bool device_compiler_available;
12919
12920 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
12921
12922 if (device_compiler_available == CL_FALSE)
12923 {
12924 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
12925
12926 device_param->skipped = 1;
12927 }
12928
12929 // device_execution_capabilities
12930
12931 cl_device_exec_capabilities device_execution_capabilities;
12932
12933 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
12934
12935 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
12936 {
12937 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
12938
12939 device_param->skipped = 1;
12940 }
12941
12942 // device_extensions
12943
12944 size_t device_extensions_size;
12945
12946 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
12947
12948 char *device_extensions = mymalloc (device_extensions_size + 1);
12949
12950 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
12951
12952 if (strstr (device_extensions, "base_atomics") == 0)
12953 {
12954 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
12955
12956 device_param->skipped = 1;
12957 }
12958
12959 if (strstr (device_extensions, "byte_addressable_store") == 0)
12960 {
12961 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
12962
12963 device_param->skipped = 1;
12964 }
12965
12966 myfree (device_extensions);
12967
12968 // device_local_mem_size
12969
12970 cl_ulong device_local_mem_size;
12971
12972 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
12973
12974 if (device_local_mem_size < 32768)
12975 {
12976 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
12977
12978 device_param->skipped = 1;
12979 }
12980
12981
12982 // skipped
12983
12984 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
12985 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
12986
12987 // driver_version
12988
12989 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12990
12991 char *driver_version = (char *) mymalloc (param_value_size);
12992
12993 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12994
12995 device_param->driver_version = driver_version;
12996
12997 // device_name_chksum
12998
12999 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13000
13001 #if __x86_64__
13002 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);
13003 #else
13004 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);
13005 #endif
13006
13007 uint device_name_digest[4] = { 0 };
13008
13009 md5_64 ((uint *) device_name_chksum, device_name_digest);
13010
13011 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13012
13013 device_param->device_name_chksum = device_name_chksum;
13014
13015 // device_processor_cores
13016
13017 if (device_type & CL_DEVICE_TYPE_CPU)
13018 {
13019 cl_uint device_processor_cores = 1;
13020
13021 device_param->device_processor_cores = device_processor_cores;
13022 }
13023
13024 if (device_type & CL_DEVICE_TYPE_GPU)
13025 {
13026 if (vendor_id == VENDOR_ID_AMD)
13027 {
13028 cl_uint device_processor_cores = 0;
13029
13030 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13031
13032 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13033
13034 device_param->device_processor_cores = device_processor_cores;
13035 }
13036 else if (vendor_id == VENDOR_ID_NV)
13037 {
13038 cl_uint kernel_exec_timeout = 0;
13039
13040 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13041
13042 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13043
13044 device_param->kernel_exec_timeout = kernel_exec_timeout;
13045
13046 cl_uint device_processor_cores = 0;
13047
13048 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13049
13050 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13051
13052 device_param->device_processor_cores = device_processor_cores;
13053
13054 cl_uint sm_minor = 0;
13055 cl_uint sm_major = 0;
13056
13057 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13058 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13059
13060 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13061 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13062
13063 device_param->sm_minor = sm_minor;
13064 device_param->sm_major = sm_major;
13065 }
13066 else
13067 {
13068 cl_uint device_processor_cores = 1;
13069
13070 device_param->device_processor_cores = device_processor_cores;
13071 }
13072 }
13073
13074 // display results
13075
13076 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13077 {
13078 if (device_param->skipped == 0)
13079 {
13080 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
13081 device_id + 1,
13082 device_name,
13083 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13084 (unsigned int) (device_global_mem / 1024 / 1024),
13085 (unsigned int) (device_maxclock_frequency),
13086 (unsigned int) device_processors);
13087 }
13088 else
13089 {
13090 log_info ("Device #%u: %s, skipped",
13091 device_id + 1,
13092 device_name);
13093 }
13094 }
13095
13096 // common driver check
13097
13098 if (device_param->skipped == 0)
13099 {
13100 if (device_type & CL_DEVICE_TYPE_GPU)
13101 {
13102 if (vendor_id == VENDOR_ID_AMD)
13103 {
13104 int catalyst_check = (force == 1) ? 0 : 1;
13105
13106 int catalyst_warn = 0;
13107
13108 int catalyst_broken = 0;
13109
13110 if (catalyst_check == 1)
13111 {
13112 catalyst_warn = 1;
13113
13114 // v14.9 and higher
13115 if (atoi (device_param->driver_version) >= 1573)
13116 {
13117 catalyst_warn = 0;
13118 }
13119
13120 catalyst_check = 0;
13121 }
13122
13123 if (catalyst_broken == 1)
13124 {
13125 log_info ("");
13126 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13127 log_info ("It will pass over cracked hashes and does not report them as cracked");
13128 log_info ("You are STRONGLY encouraged not to use it");
13129 log_info ("You can use --force to override this but do not post error reports if you do so");
13130 log_info ("");
13131
13132 return (-1);
13133 }
13134
13135 if (catalyst_warn == 1)
13136 {
13137 log_info ("");
13138 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13139 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13140 log_info ("See hashcat's homepage for official supported catalyst drivers");
13141 #ifdef _WIN
13142 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13143 #endif
13144 log_info ("You can use --force to override this but do not post error reports if you do so");
13145 log_info ("");
13146
13147 return (-1);
13148 }
13149 }
13150 else if (vendor_id == VENDOR_ID_NV)
13151 {
13152 if (device_param->kernel_exec_timeout != 0)
13153 {
13154 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);
13155 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13156 }
13157 }
13158 }
13159
13160 if (device_type & CL_DEVICE_TYPE_CPU)
13161 {
13162 if (vendor_id == VENDOR_ID_AMD)
13163 {
13164 if (force == 0)
13165 {
13166 log_info ("");
13167 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13168 log_info ("You are STRONGLY encouraged not to use it");
13169 log_info ("You can use --force to override this but do not post error reports if you do so");
13170 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13171 log_info ("");
13172
13173 return (-1);
13174 }
13175 }
13176 }
13177
13178 /**
13179 * kernel accel and loops tuning db adjustment
13180 */
13181
13182 device_param->kernel_accel_min = 1;
13183 device_param->kernel_accel_max = 1024;
13184
13185 device_param->kernel_loops_min = 1;
13186 device_param->kernel_loops_max = 1024;
13187
13188 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13189
13190 if (tuningdb_entry)
13191 {
13192 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13193 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13194
13195 if (_kernel_accel)
13196 {
13197 device_param->kernel_accel_min = _kernel_accel;
13198 device_param->kernel_accel_max = _kernel_accel;
13199 }
13200
13201 if (_kernel_loops)
13202 {
13203 if (workload_profile == 1)
13204 {
13205 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13206 }
13207 else if (workload_profile == 2)
13208 {
13209 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13210 }
13211
13212 device_param->kernel_loops_min = _kernel_loops;
13213 device_param->kernel_loops_max = _kernel_loops;
13214 }
13215 }
13216
13217 // commandline parameters overwrite tuningdb entries
13218
13219 if (kernel_accel)
13220 {
13221 device_param->kernel_accel_min = kernel_accel;
13222 device_param->kernel_accel_max = kernel_accel;
13223 }
13224
13225 if (kernel_loops)
13226 {
13227 device_param->kernel_loops_min = kernel_loops;
13228 device_param->kernel_loops_max = kernel_loops;
13229 }
13230
13231 /**
13232 * activate device
13233 */
13234
13235 devices_active++;
13236 }
13237
13238 // next please
13239
13240 devices_cnt++;
13241 }
13242 }
13243
13244 if (keyspace == 0 && devices_active == 0)
13245 {
13246 log_error ("ERROR: No devices found/left");
13247
13248 return (-1);
13249 }
13250
13251 // 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)
13252
13253 if (devices_filter != (uint) -1)
13254 {
13255 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13256
13257 if (devices_filter > devices_cnt_mask)
13258 {
13259 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13260
13261 return (-1);
13262 }
13263 }
13264
13265 data.devices_cnt = devices_cnt;
13266
13267 data.devices_active = devices_active;
13268
13269 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13270 {
13271 log_info ("");
13272 }
13273
13274 /**
13275 * HM devices: init
13276 */
13277
13278 #ifdef HAVE_HWMON
13279 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13280 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13281 #endif
13282
13283 #ifdef HAVE_ADL
13284 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13285 #endif
13286
13287 if (gpu_temp_disable == 0)
13288 {
13289 #if defined(WIN) && defined(HAVE_NVAPI)
13290 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13291
13292 if (nvapi_init (nvapi) == 0)
13293 data.hm_nv = nvapi;
13294
13295 if (data.hm_nv)
13296 {
13297 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13298 {
13299 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13300
13301 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13302
13303 int tmp_out = 0;
13304
13305 for (int i = 0; i < tmp_in; i++)
13306 {
13307 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13308 }
13309
13310 for (int i = 0; i < tmp_out; i++)
13311 {
13312 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13313
13314 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13315
13316 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;
13317 }
13318 }
13319 }
13320 #endif // WIN && HAVE_NVAPI
13321
13322 #if defined(LINUX) && defined(HAVE_NVML)
13323 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13324
13325 if (nvml_init (nvml) == 0)
13326 data.hm_nv = nvml;
13327
13328 if (data.hm_nv)
13329 {
13330 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13331 {
13332 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13333
13334 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13335
13336 int tmp_out = 0;
13337
13338 for (int i = 0; i < tmp_in; i++)
13339 {
13340 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13341 }
13342
13343 for (int i = 0; i < tmp_out; i++)
13344 {
13345 unsigned int speed;
13346
13347 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;
13348 }
13349 }
13350 }
13351 #endif // LINUX && HAVE_NVML
13352
13353 data.hm_amd = NULL;
13354
13355 #ifdef HAVE_ADL
13356 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13357
13358 if (adl_init (adl) == 0)
13359 data.hm_amd = adl;
13360
13361 if (data.hm_amd)
13362 {
13363 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13364 {
13365 // total number of adapters
13366
13367 int hm_adapters_num;
13368
13369 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13370
13371 // adapter info
13372
13373 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13374
13375 if (lpAdapterInfo == NULL) return (-1);
13376
13377 // get a list (of ids of) valid/usable adapters
13378
13379 int num_adl_adapters = 0;
13380
13381 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13382
13383 if (num_adl_adapters > 0)
13384 {
13385 hc_thread_mutex_lock (mux_adl);
13386
13387 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13388
13389 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13390
13391 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13392 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13393
13394 hc_thread_mutex_unlock (mux_adl);
13395 }
13396
13397 myfree (valid_adl_device_list);
13398 myfree (lpAdapterInfo);
13399 }
13400 }
13401 #endif // HAVE_ADL
13402
13403 if (data.hm_amd == NULL && data.hm_nv == NULL)
13404 {
13405 gpu_temp_disable = 1;
13406 }
13407 }
13408
13409 /**
13410 * OpenCL devices: allocate buffer for device specific information
13411 */
13412
13413 #ifdef HAVE_HWMON
13414 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13415
13416 #ifdef HAVE_ADL
13417 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13418
13419 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13420 #endif // ADL
13421 #endif
13422
13423 /**
13424 * enable custom signal handler(s)
13425 */
13426
13427 if (benchmark == 0)
13428 {
13429 hc_signal (sigHandler_default);
13430 }
13431 else
13432 {
13433 hc_signal (sigHandler_benchmark);
13434 }
13435
13436 /**
13437 * User-defined GPU temp handling
13438 */
13439
13440 #ifdef HAVE_HWMON
13441 if (gpu_temp_disable == 1)
13442 {
13443 gpu_temp_abort = 0;
13444 gpu_temp_retain = 0;
13445 }
13446
13447 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13448 {
13449 if (gpu_temp_abort < gpu_temp_retain)
13450 {
13451 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13452
13453 return (-1);
13454 }
13455 }
13456
13457 data.gpu_temp_disable = gpu_temp_disable;
13458 data.gpu_temp_abort = gpu_temp_abort;
13459 data.gpu_temp_retain = gpu_temp_retain;
13460 #endif
13461
13462 /**
13463 * inform the user
13464 */
13465
13466 if (data.quiet == 0)
13467 {
13468 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13469
13470 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);
13471
13472 if (attack_mode == ATTACK_MODE_STRAIGHT)
13473 {
13474 log_info ("Rules: %u", kernel_rules_cnt);
13475 }
13476
13477 if (opti_type)
13478 {
13479 log_info ("Applicable Optimizers:");
13480
13481 for (uint i = 0; i < 32; i++)
13482 {
13483 const uint opti_bit = 1u << i;
13484
13485 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13486 }
13487 }
13488
13489 /**
13490 * Watchdog and Temperature balance
13491 */
13492
13493 #ifdef HAVE_HWMON
13494 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13495 {
13496 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13497 }
13498
13499 if (gpu_temp_abort == 0)
13500 {
13501 log_info ("Watchdog: Temperature abort trigger disabled");
13502 }
13503 else
13504 {
13505 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13506 }
13507
13508 if (gpu_temp_retain == 0)
13509 {
13510 log_info ("Watchdog: Temperature retain trigger disabled");
13511 }
13512 else
13513 {
13514 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13515 }
13516
13517 if (data.quiet == 0) log_info ("");
13518 #endif
13519 }
13520
13521 /**
13522 * HM devices: copy
13523 */
13524
13525 if (gpu_temp_disable == 0)
13526 {
13527 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13528 {
13529 hc_device_param_t *device_param = &data.devices_param[device_id];
13530
13531 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13532
13533 if (device_param->skipped) continue;
13534
13535 const uint platform_devices_id = device_param->platform_devices_id;
13536
13537 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13538 if (device_param->vendor_id == VENDOR_ID_NV)
13539 {
13540 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13541 }
13542 #endif
13543
13544 #ifdef HAVE_ADL
13545 if (device_param->vendor_id == VENDOR_ID_AMD)
13546 {
13547 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13548 }
13549 #endif
13550 }
13551 }
13552
13553 /*
13554 * Temporary fix:
13555 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13556 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13557 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13558 * Driver / ADL bug?
13559 */
13560
13561 #ifdef HAVE_ADL
13562 if (powertune_enable == 1)
13563 {
13564 hc_thread_mutex_lock (mux_adl);
13565
13566 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13567 {
13568 hc_device_param_t *device_param = &data.devices_param[device_id];
13569
13570 if (device_param->skipped) continue;
13571
13572 if (data.hm_device[device_id].od_version == 6)
13573 {
13574 // set powertune value only
13575
13576 int powertune_supported = 0;
13577
13578 int ADL_rc = 0;
13579
13580 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13581 {
13582 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13583
13584 return (-1);
13585 }
13586
13587 if (powertune_supported != 0)
13588 {
13589 // powertune set
13590 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13591
13592 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13593 {
13594 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13595
13596 return (-1);
13597 }
13598
13599 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13600 {
13601 log_error ("ERROR: Failed to set new ADL PowerControl values");
13602
13603 return (-1);
13604 }
13605 }
13606 }
13607 }
13608
13609 hc_thread_mutex_unlock (mux_adl);
13610 }
13611 #endif // HAVE_ADK
13612 #endif // HAVE_HWMON
13613
13614 #ifdef DEBUG
13615 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13616 #endif
13617
13618 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
13619
13620 uint kernel_power_all = 0;
13621
13622 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13623 {
13624 /**
13625 * host buffer
13626 */
13627
13628 hc_device_param_t *device_param = &data.devices_param[device_id];
13629
13630 if (device_param->skipped) continue;
13631
13632 /**
13633 * device properties
13634 */
13635
13636 const char *device_name_chksum = device_param->device_name_chksum;
13637 const u32 device_processors = device_param->device_processors;
13638 const u32 device_processor_cores = device_param->device_processor_cores;
13639
13640 /**
13641 * create context for each device
13642 */
13643
13644 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13645
13646 /**
13647 * create command-queue
13648 */
13649
13650 // not supported with NV
13651 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13652
13653 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13654
13655 /**
13656 * kernel threads: some algorithms need a fixed kernel-threads count
13657 * because of shared memory usage or bitslice
13658 * there needs to be some upper limit, otherwise there's too much overhead
13659 */
13660
13661 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
13662
13663 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
13664 {
13665 kernel_threads = KERNEL_THREADS_MAX_CPU;
13666 }
13667
13668 if (hash_mode == 1500) kernel_threads = 64; // DES
13669 if (hash_mode == 3000) kernel_threads = 64; // DES
13670 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
13671 if (hash_mode == 7500) kernel_threads = 64; // RC4
13672 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
13673 if (hash_mode == 9700) kernel_threads = 64; // RC4
13674 if (hash_mode == 9710) kernel_threads = 64; // RC4
13675 if (hash_mode == 9800) kernel_threads = 64; // RC4
13676 if (hash_mode == 9810) kernel_threads = 64; // RC4
13677 if (hash_mode == 10400) kernel_threads = 64; // RC4
13678 if (hash_mode == 10410) kernel_threads = 64; // RC4
13679 if (hash_mode == 10500) kernel_threads = 64; // RC4
13680 if (hash_mode == 13100) kernel_threads = 64; // RC4
13681
13682 /**
13683 * create input buffers on device : calculate size of fixed memory buffers
13684 */
13685
13686 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
13687 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13688
13689 device_param->size_root_css = size_root_css;
13690 device_param->size_markov_css = size_markov_css;
13691
13692 size_t size_results = kernel_threads * sizeof (uint);
13693
13694 device_param->size_results = size_results;
13695
13696 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13697 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13698
13699 size_t size_plains = digests_cnt * sizeof (plain_t);
13700 size_t size_salts = salts_cnt * sizeof (salt_t);
13701 size_t size_esalts = salts_cnt * esalt_size;
13702
13703 device_param->size_plains = size_plains;
13704 device_param->size_digests = size_digests;
13705 device_param->size_shown = size_shown;
13706 device_param->size_salts = size_salts;
13707
13708 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
13709 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
13710 size_t size_tm = 32 * sizeof (bs_word_t);
13711
13712 // scryptV stuff
13713
13714 size_t size_scryptV = 1;
13715
13716 if ((hash_mode == 8900) || (hash_mode == 9300))
13717 {
13718 uint tmto_start = 0;
13719 uint tmto_stop = 10;
13720
13721 if (scrypt_tmto)
13722 {
13723 tmto_start = scrypt_tmto;
13724 }
13725 else
13726 {
13727 // in case the user did not specify the tmto manually
13728 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13729 // but set the lower end only in case the user has a device with too less memory
13730
13731 if (hash_mode == 8900)
13732 {
13733 if (device_param->vendor_id == VENDOR_ID_AMD)
13734 {
13735 tmto_start = 1;
13736 }
13737 else if (device_param->vendor_id == VENDOR_ID_NV)
13738 {
13739 tmto_start = 2;
13740 }
13741 }
13742 else if (hash_mode == 9300)
13743 {
13744 if (device_param->vendor_id == VENDOR_ID_AMD)
13745 {
13746 tmto_start = 2;
13747 }
13748 else if (device_param->vendor_id == VENDOR_ID_NV)
13749 {
13750 tmto_start = 2;
13751 }
13752 }
13753 }
13754
13755 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13756 {
13757 // TODO: in theory the following calculation needs to be done per salt, not global
13758 // we assume all hashes have the same scrypt settings
13759
13760 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13761
13762 size_scryptV /= 1 << tmto;
13763
13764 size_scryptV *= device_processors * device_processor_cores;
13765
13766 if (size_scryptV > device_param->device_maxmem_alloc)
13767 {
13768 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13769
13770 continue;
13771 }
13772
13773 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13774 {
13775 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13776 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
13777 }
13778
13779 break;
13780 }
13781
13782 if (data.salts_buf[0].scrypt_phy == 0)
13783 {
13784 log_error ("ERROR: can't allocate enough device memory");
13785
13786 return -1;
13787 }
13788
13789 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13790 }
13791
13792 /**
13793 * some algorithms need a fixed kernel-loops count
13794 */
13795
13796 if (hash_mode == 1500)
13797 {
13798 const u32 kernel_loops_fixed = 1024;
13799
13800 device_param->kernel_loops_min = kernel_loops_fixed;
13801 device_param->kernel_loops_max = kernel_loops_fixed;
13802 }
13803
13804 if (hash_mode == 3000)
13805 {
13806 const u32 kernel_loops_fixed = 1024;
13807
13808 device_param->kernel_loops_min = kernel_loops_fixed;
13809 device_param->kernel_loops_max = kernel_loops_fixed;
13810 }
13811
13812 if (hash_mode == 8900)
13813 {
13814 const u32 kernel_loops_fixed = 1;
13815
13816 device_param->kernel_loops_min = kernel_loops_fixed;
13817 device_param->kernel_loops_max = kernel_loops_fixed;
13818 }
13819
13820 if (hash_mode == 9300)
13821 {
13822 const u32 kernel_loops_fixed = 1;
13823
13824 device_param->kernel_loops_min = kernel_loops_fixed;
13825 device_param->kernel_loops_max = kernel_loops_fixed;
13826 }
13827
13828 if (hash_mode == 12500)
13829 {
13830 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13831
13832 device_param->kernel_loops_min = kernel_loops_fixed;
13833 device_param->kernel_loops_max = kernel_loops_fixed;
13834 }
13835
13836 /**
13837 * some algorithms have a maximum kernel-loops count
13838 */
13839
13840 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13841 {
13842 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13843 {
13844 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13845 }
13846 }
13847
13848 /**
13849 * some algorithms need a special kernel-accel
13850 */
13851
13852 if (hash_mode == 8900)
13853 {
13854 device_param->kernel_accel_min = 1;
13855 device_param->kernel_accel_max = 64;
13856 }
13857
13858 if (hash_mode == 9300)
13859 {
13860 device_param->kernel_accel_min = 1;
13861 device_param->kernel_accel_max = 64;
13862 }
13863
13864 u32 kernel_accel_min = device_param->kernel_accel_min;
13865 u32 kernel_accel_max = device_param->kernel_accel_max;
13866
13867 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13868
13869 size_t size_pws = 4;
13870 size_t size_tmps = 4;
13871 size_t size_hooks = 4;
13872
13873 while (kernel_accel_max >= kernel_accel_min)
13874 {
13875 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13876
13877 // size_pws
13878
13879 size_pws = kernel_power_max * sizeof (pw_t);
13880
13881 // size_tmps
13882
13883 switch (hash_mode)
13884 {
13885 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13886 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13887 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13888 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13889 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13890 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13891 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13892 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13893 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13894 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13895 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13896 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13897 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13898 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13899 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13900 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13901 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13902 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13903 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13904 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13905 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13906 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13907 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13908 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13909 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13910 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13911 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13912 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13913 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13914 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13915 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13916 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13917 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13918 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13919 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13920 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13921 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13922 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13923 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13924 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13925 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13926 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13927 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13928 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13929 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13930 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13931 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13932 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13933 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13934 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13935 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13936 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13937 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13938 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13939 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13940 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13941 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13942 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13943 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13944 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13945 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13946 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
13947 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
13948 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13949 };
13950
13951 // size_hooks
13952
13953 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13954 {
13955 // none yet
13956 }
13957
13958 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13959 // if not, decrease amplifier and try again
13960
13961 int skip = 0;
13962
13963 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13964 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13965 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13966
13967 if (( bitmap_size
13968 + bitmap_size
13969 + bitmap_size
13970 + bitmap_size
13971 + bitmap_size
13972 + bitmap_size
13973 + bitmap_size
13974 + bitmap_size
13975 + size_bfs
13976 + size_combs
13977 + size_digests
13978 + size_esalts
13979 + size_hooks
13980 + size_markov_css
13981 + size_plains
13982 + size_pws
13983 + size_pws // not a bug
13984 + size_results
13985 + size_root_css
13986 + size_rules
13987 + size_rules_c
13988 + size_salts
13989 + size_scryptV
13990 + size_shown
13991 + size_tm
13992 + size_tmps) > device_param->device_global_mem) skip = 1;
13993
13994 if (skip == 1)
13995 {
13996 kernel_accel_max--;
13997
13998 continue;
13999 }
14000
14001 break;
14002 }
14003
14004 /*
14005 if (kernel_accel_max == 0)
14006 {
14007 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14008
14009 return -1;
14010 }
14011 */
14012
14013 device_param->kernel_accel_min = kernel_accel_min;
14014 device_param->kernel_accel_max = kernel_accel_max;
14015
14016 /*
14017 if (kernel_accel_max < kernel_accel)
14018 {
14019 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14020
14021 device_param->kernel_accel = kernel_accel_max;
14022 }
14023 */
14024
14025 device_param->size_bfs = size_bfs;
14026 device_param->size_combs = size_combs;
14027 device_param->size_rules = size_rules;
14028 device_param->size_rules_c = size_rules_c;
14029 device_param->size_pws = size_pws;
14030 device_param->size_tmps = size_tmps;
14031 device_param->size_hooks = size_hooks;
14032
14033 // do not confuse kernel_accel_max with kernel_accel here
14034
14035 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
14036
14037 device_param->kernel_threads = kernel_threads;
14038 device_param->kernel_power_user = kernel_power;
14039
14040 kernel_power_all += kernel_power;
14041
14042 /**
14043 * default building options
14044 */
14045
14046 char build_opts[1024] = { 0 };
14047
14048 // we don't have sm_* on vendors not NV but it doesn't matter
14049
14050 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);
14051
14052 if (device_param->vendor_id == VENDOR_ID_INTEL_SDK)
14053 {
14054 // we do vectorizing much better than the auto-vectorizer
14055
14056 char build_opts_new[1024] = { 0 };
14057
14058 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14059
14060 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14061 }
14062
14063 #ifdef DEBUG
14064 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14065 #endif
14066
14067 /**
14068 * main kernel
14069 */
14070
14071 {
14072 /**
14073 * kernel source filename
14074 */
14075
14076 char source_file[256] = { 0 };
14077
14078 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14079
14080 struct stat sst;
14081
14082 if (stat (source_file, &sst) == -1)
14083 {
14084 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14085
14086 return -1;
14087 }
14088
14089 /**
14090 * kernel cached filename
14091 */
14092
14093 char cached_file[256] = { 0 };
14094
14095 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14096
14097 int cached = 1;
14098
14099 struct stat cst;
14100
14101 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14102 {
14103 cached = 0;
14104 }
14105
14106 /**
14107 * kernel compile or load
14108 */
14109
14110 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14111
14112 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14113
14114 if (force_jit_compilation == -1)
14115 {
14116 if (cached == 0)
14117 {
14118 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14119
14120 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14121
14122 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14123
14124 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14125
14126 #ifdef DEBUG
14127 size_t build_log_size = 0;
14128
14129 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14130
14131 if (build_log_size > 1)
14132 {
14133 char *build_log = (char *) malloc (build_log_size + 1);
14134
14135 memset (build_log, 0, build_log_size + 1);
14136
14137 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14138
14139 puts (build_log);
14140
14141 free (build_log);
14142 }
14143 #endif
14144
14145 if (rc != 0)
14146 {
14147 device_param->skipped = true;
14148
14149 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14150
14151 continue;
14152 }
14153
14154 size_t binary_size;
14155
14156 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14157
14158 u8 *binary = (u8 *) mymalloc (binary_size);
14159
14160 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14161
14162 writeProgramBin (cached_file, binary, binary_size);
14163
14164 local_free (binary);
14165 }
14166 else
14167 {
14168 #ifdef DEBUG
14169 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14170 #endif
14171
14172 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14173
14174 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14175
14176 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14177 }
14178 }
14179 else
14180 {
14181 #ifdef DEBUG
14182 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14183 #endif
14184
14185 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14186
14187 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14188
14189 char build_opts_update[1024] = { 0 };
14190
14191 if (force_jit_compilation == 1500)
14192 {
14193 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14194 }
14195 else if (force_jit_compilation == 8900)
14196 {
14197 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);
14198 }
14199 else
14200 {
14201 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14202 }
14203
14204 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14205
14206 #ifdef DEBUG
14207 size_t build_log_size = 0;
14208
14209 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14210
14211 if (build_log_size > 1)
14212 {
14213 char *build_log = (char *) malloc (build_log_size + 1);
14214
14215 memset (build_log, 0, build_log_size + 1);
14216
14217 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14218
14219 puts (build_log);
14220
14221 free (build_log);
14222 }
14223 #endif
14224
14225 if (rc != 0)
14226 {
14227 device_param->skipped = true;
14228
14229 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14230 }
14231 }
14232
14233 local_free (kernel_lengths);
14234 local_free (kernel_sources[0]);
14235 local_free (kernel_sources);
14236 }
14237
14238 /**
14239 * word generator kernel
14240 */
14241
14242 if (attack_mode != ATTACK_MODE_STRAIGHT)
14243 {
14244 /**
14245 * kernel mp source filename
14246 */
14247
14248 char source_file[256] = { 0 };
14249
14250 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14251
14252 struct stat sst;
14253
14254 if (stat (source_file, &sst) == -1)
14255 {
14256 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14257
14258 return -1;
14259 }
14260
14261 /**
14262 * kernel mp cached filename
14263 */
14264
14265 char cached_file[256] = { 0 };
14266
14267 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14268
14269 int cached = 1;
14270
14271 struct stat cst;
14272
14273 if (stat (cached_file, &cst) == -1)
14274 {
14275 cached = 0;
14276 }
14277
14278 /**
14279 * kernel compile or load
14280 */
14281
14282 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14283
14284 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14285
14286 if (cached == 0)
14287 {
14288 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14289 if (quiet == 0) log_info ("");
14290
14291 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14292
14293 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14294
14295 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14296
14297 if (rc != 0)
14298 {
14299 device_param->skipped = true;
14300
14301 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14302
14303 continue;
14304 }
14305
14306 size_t binary_size;
14307
14308 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14309
14310 u8 *binary = (u8 *) mymalloc (binary_size);
14311
14312 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14313
14314 writeProgramBin (cached_file, binary, binary_size);
14315
14316 local_free (binary);
14317 }
14318 else
14319 {
14320 #ifdef DEBUG
14321 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14322 #endif
14323
14324 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14325
14326 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14327
14328 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14329 }
14330
14331 local_free (kernel_lengths);
14332 local_free (kernel_sources[0]);
14333 local_free (kernel_sources);
14334 }
14335
14336 /**
14337 * amplifier kernel
14338 */
14339
14340 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14341 {
14342
14343 }
14344 else
14345 {
14346 /**
14347 * kernel amp source filename
14348 */
14349
14350 char source_file[256] = { 0 };
14351
14352 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14353
14354 struct stat sst;
14355
14356 if (stat (source_file, &sst) == -1)
14357 {
14358 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14359
14360 return -1;
14361 }
14362
14363 /**
14364 * kernel amp cached filename
14365 */
14366
14367 char cached_file[256] = { 0 };
14368
14369 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14370
14371 int cached = 1;
14372
14373 struct stat cst;
14374
14375 if (stat (cached_file, &cst) == -1)
14376 {
14377 cached = 0;
14378 }
14379
14380 /**
14381 * kernel compile or load
14382 */
14383
14384 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14385
14386 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14387
14388 if (cached == 0)
14389 {
14390 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14391 if (quiet == 0) log_info ("");
14392
14393 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14394
14395 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14396
14397 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14398
14399 if (rc != 0)
14400 {
14401 device_param->skipped = true;
14402
14403 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14404
14405 continue;
14406 }
14407
14408 size_t binary_size;
14409
14410 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14411
14412 u8 *binary = (u8 *) mymalloc (binary_size);
14413
14414 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14415
14416 writeProgramBin (cached_file, binary, binary_size);
14417
14418 local_free (binary);
14419 }
14420 else
14421 {
14422 #ifdef DEBUG
14423 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14424 #endif
14425
14426 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14427
14428 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14429
14430 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14431 }
14432
14433 local_free (kernel_lengths);
14434 local_free (kernel_sources[0]);
14435 local_free (kernel_sources);
14436 }
14437
14438 // some algorithm collide too fast, make that impossible
14439
14440 if (benchmark == 1)
14441 {
14442 ((uint *) digests_buf)[0] = -1;
14443 ((uint *) digests_buf)[1] = -1;
14444 ((uint *) digests_buf)[2] = -1;
14445 ((uint *) digests_buf)[3] = -1;
14446 }
14447
14448 /**
14449 * global buffers
14450 */
14451
14452 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14453 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14454 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14455 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14456 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14457 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14458 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14459 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14460 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14461 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14462 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14463 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14464 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14465 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14466 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14467 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14468 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14469 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14470
14471 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);
14472 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);
14473 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);
14474 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);
14475 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);
14476 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);
14477 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);
14478 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);
14479 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14480 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14481 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14482
14483 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14484 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14485 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14486 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14487 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14488 run_kernel_bzero (device_param, device_param->d_result, size_results);
14489
14490 /**
14491 * special buffers
14492 */
14493
14494 if (attack_kern == ATTACK_KERN_STRAIGHT)
14495 {
14496 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14497 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14498
14499 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14500
14501 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14502 }
14503 else if (attack_kern == ATTACK_KERN_COMBI)
14504 {
14505 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14506 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14507 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14508 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14509
14510 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14511 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14512 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14513 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14514 }
14515 else if (attack_kern == ATTACK_KERN_BF)
14516 {
14517 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14518 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14519 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14520 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14521 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14522
14523 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14524 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14525 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14526 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14527 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14528 }
14529
14530 if (size_esalts)
14531 {
14532 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14533
14534 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14535 }
14536
14537 /**
14538 * main host data
14539 */
14540
14541 uint *result = (uint *) mymalloc (size_results);
14542
14543 device_param->result = result;
14544
14545 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14546
14547 device_param->pws_buf = pws_buf;
14548
14549 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14550
14551 device_param->combs_buf = combs_buf;
14552
14553 void *hooks_buf = mymalloc (size_hooks);
14554
14555 device_param->hooks_buf = hooks_buf;
14556
14557 /**
14558 * kernel args
14559 */
14560
14561 device_param->kernel_params_buf32[21] = bitmap_mask;
14562 device_param->kernel_params_buf32[22] = bitmap_shift1;
14563 device_param->kernel_params_buf32[23] = bitmap_shift2;
14564 device_param->kernel_params_buf32[24] = 0; // salt_pos
14565 device_param->kernel_params_buf32[25] = 0; // loop_pos
14566 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14567 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14568 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14569 device_param->kernel_params_buf32[29] = 0; // digests_offset
14570 device_param->kernel_params_buf32[30] = 0; // combs_mode
14571 device_param->kernel_params_buf32[31] = 0; // gid_max
14572
14573 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14574 ? &device_param->d_pws_buf
14575 : &device_param->d_pws_amp_buf;
14576 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14577 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14578 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14579 device_param->kernel_params[ 4] = &device_param->d_tmps;
14580 device_param->kernel_params[ 5] = &device_param->d_hooks;
14581 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14582 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14583 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14584 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14585 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14586 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14587 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14588 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14589 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14590 device_param->kernel_params[15] = &device_param->d_digests_buf;
14591 device_param->kernel_params[16] = &device_param->d_digests_shown;
14592 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14593 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14594 device_param->kernel_params[19] = &device_param->d_result;
14595 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14596 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14597 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14598 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14599 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14600 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14601 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14602 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14603 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14604 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14605 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14606 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14607
14608 device_param->kernel_params_mp_buf64[3] = 0;
14609 device_param->kernel_params_mp_buf32[4] = 0;
14610 device_param->kernel_params_mp_buf32[5] = 0;
14611 device_param->kernel_params_mp_buf32[6] = 0;
14612 device_param->kernel_params_mp_buf32[7] = 0;
14613 device_param->kernel_params_mp_buf32[8] = 0;
14614
14615 device_param->kernel_params_mp[0] = NULL;
14616 device_param->kernel_params_mp[1] = NULL;
14617 device_param->kernel_params_mp[2] = NULL;
14618 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14619 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14620 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14621 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14622 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14623 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14624
14625 device_param->kernel_params_mp_l_buf64[3] = 0;
14626 device_param->kernel_params_mp_l_buf32[4] = 0;
14627 device_param->kernel_params_mp_l_buf32[5] = 0;
14628 device_param->kernel_params_mp_l_buf32[6] = 0;
14629 device_param->kernel_params_mp_l_buf32[7] = 0;
14630 device_param->kernel_params_mp_l_buf32[8] = 0;
14631 device_param->kernel_params_mp_l_buf32[9] = 0;
14632
14633 device_param->kernel_params_mp_l[0] = NULL;
14634 device_param->kernel_params_mp_l[1] = NULL;
14635 device_param->kernel_params_mp_l[2] = NULL;
14636 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14637 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14638 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14639 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14640 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14641 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14642 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14643
14644 device_param->kernel_params_mp_r_buf64[3] = 0;
14645 device_param->kernel_params_mp_r_buf32[4] = 0;
14646 device_param->kernel_params_mp_r_buf32[5] = 0;
14647 device_param->kernel_params_mp_r_buf32[6] = 0;
14648 device_param->kernel_params_mp_r_buf32[7] = 0;
14649 device_param->kernel_params_mp_r_buf32[8] = 0;
14650
14651 device_param->kernel_params_mp_r[0] = NULL;
14652 device_param->kernel_params_mp_r[1] = NULL;
14653 device_param->kernel_params_mp_r[2] = NULL;
14654 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14655 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14656 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14657 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14658 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14659 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14660
14661 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14662 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14663
14664 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14665 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14666 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14667 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14668 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14669 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14670 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14671
14672 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14673 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14674
14675 /**
14676 * kernel name
14677 */
14678
14679 size_t kernel_wgs_tmp;
14680
14681 char kernel_name[64] = { 0 };
14682
14683 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14684 {
14685 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14686 {
14687 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14688
14689 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14690
14691 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14692
14693 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14694
14695 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14696
14697 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14698 }
14699 else
14700 {
14701 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14702
14703 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14704
14705 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14706
14707 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14708
14709 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14710
14711 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14712 }
14713
14714 if (data.attack_mode == ATTACK_MODE_BF)
14715 {
14716 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14717 {
14718 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14719
14720 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14721
14722 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);
14723 }
14724 }
14725 }
14726 else
14727 {
14728 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14729
14730 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14731
14732 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14733
14734 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14735
14736 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14737
14738 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14739
14740 if (opts_type & OPTS_TYPE_HOOK12)
14741 {
14742 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14743
14744 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14745
14746 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);
14747 }
14748
14749 if (opts_type & OPTS_TYPE_HOOK23)
14750 {
14751 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14752
14753 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14754
14755 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);
14756 }
14757 }
14758
14759 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);
14760 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);
14761 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);
14762
14763 for (uint i = 0; i <= 20; i++)
14764 {
14765 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14766 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14767 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14768
14769 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14770 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14771 }
14772
14773 for (uint i = 21; i <= 31; i++)
14774 {
14775 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14776 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14777 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14778
14779 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14780 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14781 }
14782
14783 if (attack_mode == ATTACK_MODE_BF)
14784 {
14785 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14786 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14787
14788 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);
14789 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);
14790
14791 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14792 {
14793 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14794 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14795 }
14796 }
14797 else if (attack_mode == ATTACK_MODE_HYBRID1)
14798 {
14799 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14800
14801 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);
14802 }
14803 else if (attack_mode == ATTACK_MODE_HYBRID2)
14804 {
14805 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14806
14807 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);
14808 }
14809
14810 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14811 {
14812 // nothing to do
14813 }
14814 else
14815 {
14816 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14817
14818 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);
14819 }
14820
14821 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14822 {
14823 // nothing to do
14824 }
14825 else
14826 {
14827 for (uint i = 0; i < 5; i++)
14828 {
14829 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14830 }
14831
14832 for (uint i = 5; i < 7; i++)
14833 {
14834 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14835 }
14836 }
14837
14838 // maybe this has been updated by clGetKernelWorkGroupInfo()
14839 // value can only be decreased, so we don't need to reallocate buffers
14840
14841 device_param->kernel_threads = kernel_threads;
14842
14843 /**
14844 * Store initial fanspeed if gpu_temp_retain is enabled
14845 */
14846
14847 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14848 int gpu_temp_retain_set = 0;
14849
14850 if (gpu_temp_disable == 0)
14851 {
14852 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14853 {
14854 hc_thread_mutex_lock (mux_adl);
14855
14856 if (data.hm_device[device_id].fan_supported == 1)
14857 {
14858 if (gpu_temp_retain_chgd == 0)
14859 {
14860 uint cur_temp = 0;
14861 uint default_temp = 0;
14862
14863 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);
14864
14865 if (ADL_rc == ADL_OK)
14866 {
14867 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14868
14869 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14870
14871 // special case with multi gpu setups: always use minimum retain
14872
14873 if (gpu_temp_retain_set == 0)
14874 {
14875 gpu_temp_retain = gpu_temp_retain_target;
14876 gpu_temp_retain_set = 1;
14877 }
14878 else
14879 {
14880 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14881 }
14882
14883 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14884 }
14885 }
14886
14887 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14888
14889 temp_retain_fanspeed_value[device_id] = fan_speed;
14890
14891 if (fan_speed == -1)
14892 {
14893 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14894
14895 temp_retain_fanspeed_value[device_id] = 0;
14896 }
14897 }
14898
14899 hc_thread_mutex_unlock (mux_adl);
14900 }
14901 }
14902
14903 /**
14904 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14905 */
14906
14907 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14908 {
14909 hc_thread_mutex_lock (mux_adl);
14910
14911 if (data.hm_device[device_id].od_version == 6)
14912 {
14913 int ADL_rc;
14914
14915 // check powertune capabilities first, if not available then skip device
14916
14917 int powertune_supported = 0;
14918
14919 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14920 {
14921 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14922
14923 return (-1);
14924 }
14925
14926 if (powertune_supported != 0)
14927 {
14928 // powercontrol settings
14929
14930 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14931
14932 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14933 {
14934 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14935 }
14936
14937 if (ADL_rc != ADL_OK)
14938 {
14939 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14940
14941 return (-1);
14942 }
14943
14944 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14945 {
14946 log_error ("ERROR: Failed to set new ADL PowerControl values");
14947
14948 return (-1);
14949 }
14950
14951 // clocks
14952
14953 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14954
14955 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14956
14957 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)
14958 {
14959 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14960
14961 return (-1);
14962 }
14963
14964 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14965
14966 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14967
14968 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14969 {
14970 log_error ("ERROR: Failed to get ADL device capabilities");
14971
14972 return (-1);
14973 }
14974
14975 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14976 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14977
14978 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14979 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14980
14981 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14982 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14983
14984 // warning if profile has too low max values
14985
14986 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14987 {
14988 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14989 }
14990
14991 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14992 {
14993 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14994 }
14995
14996 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14997
14998 performance_state->iNumberOfPerformanceLevels = 2;
14999
15000 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
15001 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
15002 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
15003 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
15004
15005 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)
15006 {
15007 log_info ("ERROR: Failed to set ADL performance state");
15008
15009 return (-1);
15010 }
15011
15012 local_free (performance_state);
15013 }
15014 }
15015
15016 hc_thread_mutex_unlock (mux_adl);
15017 }
15018 #endif // HAVE_HWMON && HAVE_ADL
15019 }
15020
15021 data.kernel_power_all = kernel_power_all;
15022
15023 if (data.quiet == 0) log_info_nn ("");
15024
15025 /**
15026 * In benchmark-mode, inform user which algorithm is checked
15027 */
15028
15029 if (benchmark == 1 && status_automat == 0)
15030 {
15031 quiet = 0;
15032
15033 data.quiet = quiet;
15034
15035 char *hash_type = strhashtype (data.hash_mode); // not a bug
15036
15037 log_info ("Hashtype: %s", hash_type);
15038 log_info ("");
15039 }
15040
15041 /**
15042 * keep track of the progress
15043 */
15044
15045 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15046 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15047 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15048
15049 /**
15050 * open filehandles
15051 */
15052
15053 #if _WIN
15054 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15055 {
15056 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15057
15058 return (-1);
15059 }
15060
15061 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15062 {
15063 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15064
15065 return (-1);
15066 }
15067
15068 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15069 {
15070 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15071
15072 return (-1);
15073 }
15074 #endif
15075
15076 /**
15077 * dictionary pad
15078 */
15079
15080 segment_size *= (1024 * 1024);
15081
15082 data.segment_size = segment_size;
15083
15084 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15085
15086 wl_data->buf = (char *) mymalloc (segment_size);
15087 wl_data->avail = segment_size;
15088 wl_data->incr = segment_size;
15089 wl_data->cnt = 0;
15090 wl_data->pos = 0;
15091
15092 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15093
15094 data.wordlist_mode = wordlist_mode;
15095
15096 cs_t *css_buf = NULL;
15097 uint css_cnt = 0;
15098 uint dictcnt = 0;
15099 uint maskcnt = 1;
15100 char **masks = NULL;
15101 char **dictfiles = NULL;
15102
15103 uint mask_from_file = 0;
15104
15105 if (attack_mode == ATTACK_MODE_STRAIGHT)
15106 {
15107 if (wordlist_mode == WL_MODE_FILE)
15108 {
15109 int wls_left = myargc - (optind + 1);
15110
15111 for (int i = 0; i < wls_left; i++)
15112 {
15113 char *l0_filename = myargv[optind + 1 + i];
15114
15115 struct stat l0_stat;
15116
15117 if (stat (l0_filename, &l0_stat) == -1)
15118 {
15119 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15120
15121 return (-1);
15122 }
15123
15124 uint is_dir = S_ISDIR (l0_stat.st_mode);
15125
15126 if (is_dir == 0)
15127 {
15128 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15129
15130 dictcnt++;
15131
15132 dictfiles[dictcnt - 1] = l0_filename;
15133 }
15134 else
15135 {
15136 // do not allow --keyspace w/ a directory
15137
15138 if (keyspace == 1)
15139 {
15140 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15141
15142 return (-1);
15143 }
15144
15145 char **dictionary_files = NULL;
15146
15147 dictionary_files = scan_directory (l0_filename);
15148
15149 if (dictionary_files != NULL)
15150 {
15151 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15152
15153 for (int d = 0; dictionary_files[d] != NULL; d++)
15154 {
15155 char *l1_filename = dictionary_files[d];
15156
15157 struct stat l1_stat;
15158
15159 if (stat (l1_filename, &l1_stat) == -1)
15160 {
15161 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15162
15163 return (-1);
15164 }
15165
15166 if (S_ISREG (l1_stat.st_mode))
15167 {
15168 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15169
15170 dictcnt++;
15171
15172 dictfiles[dictcnt - 1] = strdup (l1_filename);
15173 }
15174 }
15175 }
15176
15177 local_free (dictionary_files);
15178 }
15179 }
15180
15181 if (dictcnt < 1)
15182 {
15183 log_error ("ERROR: No usable dictionary file found.");
15184
15185 return (-1);
15186 }
15187 }
15188 else if (wordlist_mode == WL_MODE_STDIN)
15189 {
15190 dictcnt = 1;
15191 }
15192 }
15193 else if (attack_mode == ATTACK_MODE_COMBI)
15194 {
15195 // display
15196
15197 char *dictfile1 = myargv[optind + 1 + 0];
15198 char *dictfile2 = myargv[optind + 1 + 1];
15199
15200 // find the bigger dictionary and use as base
15201
15202 FILE *fp1 = NULL;
15203 FILE *fp2 = NULL;
15204
15205 struct stat tmp_stat;
15206
15207 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15208 {
15209 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15210
15211 return (-1);
15212 }
15213
15214 if (stat (dictfile1, &tmp_stat) == -1)
15215 {
15216 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15217
15218 fclose (fp1);
15219
15220 return (-1);
15221 }
15222
15223 if (S_ISDIR (tmp_stat.st_mode))
15224 {
15225 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15226
15227 fclose (fp1);
15228
15229 return (-1);
15230 }
15231
15232 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15233 {
15234 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15235
15236 fclose (fp1);
15237
15238 return (-1);
15239 }
15240
15241 if (stat (dictfile2, &tmp_stat) == -1)
15242 {
15243 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15244
15245 fclose (fp1);
15246 fclose (fp2);
15247
15248 return (-1);
15249 }
15250
15251 if (S_ISDIR (tmp_stat.st_mode))
15252 {
15253 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15254
15255 fclose (fp1);
15256 fclose (fp2);
15257
15258 return (-1);
15259 }
15260
15261 data.combs_cnt = 1;
15262
15263 data.quiet = 1;
15264
15265 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15266
15267 data.quiet = quiet;
15268
15269 if (words1_cnt == 0)
15270 {
15271 log_error ("ERROR: %s: empty file", dictfile1);
15272
15273 fclose (fp1);
15274 fclose (fp2);
15275
15276 return (-1);
15277 }
15278
15279 data.combs_cnt = 1;
15280
15281 data.quiet = 1;
15282
15283 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15284
15285 data.quiet = quiet;
15286
15287 if (words2_cnt == 0)
15288 {
15289 log_error ("ERROR: %s: empty file", dictfile2);
15290
15291 fclose (fp1);
15292 fclose (fp2);
15293
15294 return (-1);
15295 }
15296
15297 fclose (fp1);
15298 fclose (fp2);
15299
15300 data.dictfile = dictfile1;
15301 data.dictfile2 = dictfile2;
15302
15303 if (words1_cnt >= words2_cnt)
15304 {
15305 data.combs_cnt = words2_cnt;
15306 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15307
15308 dictfiles = &data.dictfile;
15309
15310 dictcnt = 1;
15311 }
15312 else
15313 {
15314 data.combs_cnt = words1_cnt;
15315 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15316
15317 dictfiles = &data.dictfile2;
15318
15319 dictcnt = 1;
15320
15321 // we also have to switch wordlist related rules!
15322
15323 char *tmpc = data.rule_buf_l;
15324
15325 data.rule_buf_l = data.rule_buf_r;
15326 data.rule_buf_r = tmpc;
15327
15328 int tmpi = data.rule_len_l;
15329
15330 data.rule_len_l = data.rule_len_r;
15331 data.rule_len_r = tmpi;
15332 }
15333 }
15334 else if (attack_mode == ATTACK_MODE_BF)
15335 {
15336 char *mask = NULL;
15337
15338 maskcnt = 0;
15339
15340 if (benchmark == 0)
15341 {
15342 mask = myargv[optind + 1];
15343
15344 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15345
15346 if ((optind + 2) <= myargc)
15347 {
15348 struct stat file_stat;
15349
15350 if (stat (mask, &file_stat) == -1)
15351 {
15352 maskcnt = 1;
15353
15354 masks[maskcnt - 1] = mystrdup (mask);
15355 }
15356 else
15357 {
15358 int wls_left = myargc - (optind + 1);
15359
15360 uint masks_avail = INCR_MASKS;
15361
15362 for (int i = 0; i < wls_left; i++)
15363 {
15364 if (i != 0)
15365 {
15366 mask = myargv[optind + 1 + i];
15367
15368 if (stat (mask, &file_stat) == -1)
15369 {
15370 log_error ("ERROR: %s: %s", mask, strerror (errno));
15371
15372 return (-1);
15373 }
15374 }
15375
15376 uint is_file = S_ISREG (file_stat.st_mode);
15377
15378 if (is_file == 1)
15379 {
15380 FILE *mask_fp;
15381
15382 if ((mask_fp = fopen (mask, "r")) == NULL)
15383 {
15384 log_error ("ERROR: %s: %s", mask, strerror (errno));
15385
15386 return (-1);
15387 }
15388
15389 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15390
15391 while (!feof (mask_fp))
15392 {
15393 memset (line_buf, 0, HCBUFSIZ);
15394
15395 int line_len = fgetl (mask_fp, line_buf);
15396
15397 if (line_len == 0) continue;
15398
15399 if (line_buf[0] == '#') continue;
15400
15401 if (masks_avail == maskcnt)
15402 {
15403 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15404
15405 masks_avail += INCR_MASKS;
15406 }
15407
15408 masks[maskcnt] = mystrdup (line_buf);
15409
15410 maskcnt++;
15411 }
15412
15413 myfree (line_buf);
15414
15415 fclose (mask_fp);
15416 }
15417 else
15418 {
15419 log_error ("ERROR: %s: unsupported file-type", mask);
15420
15421 return (-1);
15422 }
15423 }
15424
15425 mask_from_file = 1;
15426 }
15427 }
15428 else
15429 {
15430 custom_charset_1 = (char *) "?l?d?u";
15431 custom_charset_2 = (char *) "?l?d";
15432 custom_charset_3 = (char *) "?l?d*!$@_";
15433
15434 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15435 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15436 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15437
15438 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15439
15440 wordlist_mode = WL_MODE_MASK;
15441
15442 data.wordlist_mode = wordlist_mode;
15443
15444 increment = 1;
15445
15446 maskcnt = 1;
15447 }
15448 }
15449 else
15450 {
15451 /**
15452 * generate full masks and charsets
15453 */
15454
15455 masks = (char **) mymalloc (sizeof (char *));
15456
15457 switch (hash_mode)
15458 {
15459 case 1731: pw_min = 5;
15460 pw_max = 5;
15461 mask = mystrdup ("?b?b?b?b?b");
15462 break;
15463 case 12500: pw_min = 5;
15464 pw_max = 5;
15465 mask = mystrdup ("?b?b?b?b?b");
15466 break;
15467 default: pw_min = 7;
15468 pw_max = 7;
15469 mask = mystrdup ("?b?b?b?b?b?b?b");
15470 break;
15471 }
15472
15473 maskcnt = 1;
15474
15475 masks[maskcnt - 1] = mystrdup (mask);
15476
15477 wordlist_mode = WL_MODE_MASK;
15478
15479 data.wordlist_mode = wordlist_mode;
15480
15481 increment = 1;
15482 }
15483
15484 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15485
15486 if (increment)
15487 {
15488 if (increment_min > pw_min) pw_min = increment_min;
15489
15490 if (increment_max < pw_max) pw_max = increment_max;
15491 }
15492 }
15493 else if (attack_mode == ATTACK_MODE_HYBRID1)
15494 {
15495 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15496
15497 // display
15498
15499 char *mask = myargv[myargc - 1];
15500
15501 maskcnt = 0;
15502
15503 masks = (char **) mymalloc (1 * sizeof (char *));
15504
15505 // mod
15506
15507 struct stat file_stat;
15508
15509 if (stat (mask, &file_stat) == -1)
15510 {
15511 maskcnt = 1;
15512
15513 masks[maskcnt - 1] = mystrdup (mask);
15514 }
15515 else
15516 {
15517 uint is_file = S_ISREG (file_stat.st_mode);
15518
15519 if (is_file == 1)
15520 {
15521 FILE *mask_fp;
15522
15523 if ((mask_fp = fopen (mask, "r")) == NULL)
15524 {
15525 log_error ("ERROR: %s: %s", mask, strerror (errno));
15526
15527 return (-1);
15528 }
15529
15530 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15531
15532 uint masks_avail = 1;
15533
15534 while (!feof (mask_fp))
15535 {
15536 memset (line_buf, 0, HCBUFSIZ);
15537
15538 int line_len = fgetl (mask_fp, line_buf);
15539
15540 if (line_len == 0) continue;
15541
15542 if (line_buf[0] == '#') continue;
15543
15544 if (masks_avail == maskcnt)
15545 {
15546 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15547
15548 masks_avail += INCR_MASKS;
15549 }
15550
15551 masks[maskcnt] = mystrdup (line_buf);
15552
15553 maskcnt++;
15554 }
15555
15556 myfree (line_buf);
15557
15558 fclose (mask_fp);
15559
15560 mask_from_file = 1;
15561 }
15562 else
15563 {
15564 maskcnt = 1;
15565
15566 masks[maskcnt - 1] = mystrdup (mask);
15567 }
15568 }
15569
15570 // base
15571
15572 int wls_left = myargc - (optind + 2);
15573
15574 for (int i = 0; i < wls_left; i++)
15575 {
15576 char *filename = myargv[optind + 1 + i];
15577
15578 struct stat file_stat;
15579
15580 if (stat (filename, &file_stat) == -1)
15581 {
15582 log_error ("ERROR: %s: %s", filename, strerror (errno));
15583
15584 return (-1);
15585 }
15586
15587 uint is_dir = S_ISDIR (file_stat.st_mode);
15588
15589 if (is_dir == 0)
15590 {
15591 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15592
15593 dictcnt++;
15594
15595 dictfiles[dictcnt - 1] = filename;
15596 }
15597 else
15598 {
15599 // do not allow --keyspace w/ a directory
15600
15601 if (keyspace == 1)
15602 {
15603 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15604
15605 return (-1);
15606 }
15607
15608 char **dictionary_files = NULL;
15609
15610 dictionary_files = scan_directory (filename);
15611
15612 if (dictionary_files != NULL)
15613 {
15614 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15615
15616 for (int d = 0; dictionary_files[d] != NULL; d++)
15617 {
15618 char *l1_filename = dictionary_files[d];
15619
15620 struct stat l1_stat;
15621
15622 if (stat (l1_filename, &l1_stat) == -1)
15623 {
15624 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15625
15626 return (-1);
15627 }
15628
15629 if (S_ISREG (l1_stat.st_mode))
15630 {
15631 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15632
15633 dictcnt++;
15634
15635 dictfiles[dictcnt - 1] = strdup (l1_filename);
15636 }
15637 }
15638 }
15639
15640 local_free (dictionary_files);
15641 }
15642 }
15643
15644 if (dictcnt < 1)
15645 {
15646 log_error ("ERROR: No usable dictionary file found.");
15647
15648 return (-1);
15649 }
15650
15651 if (increment)
15652 {
15653 maskcnt = 0;
15654
15655 uint mask_min = increment_min; // we can't reject smaller masks here
15656 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15657
15658 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15659 {
15660 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15661
15662 if (cur_mask == NULL) break;
15663
15664 masks[maskcnt] = cur_mask;
15665
15666 maskcnt++;
15667
15668 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15669 }
15670 }
15671 }
15672 else if (attack_mode == ATTACK_MODE_HYBRID2)
15673 {
15674 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15675
15676 // display
15677
15678 char *mask = myargv[optind + 1 + 0];
15679
15680 maskcnt = 0;
15681
15682 masks = (char **) mymalloc (1 * sizeof (char *));
15683
15684 // mod
15685
15686 struct stat file_stat;
15687
15688 if (stat (mask, &file_stat) == -1)
15689 {
15690 maskcnt = 1;
15691
15692 masks[maskcnt - 1] = mystrdup (mask);
15693 }
15694 else
15695 {
15696 uint is_file = S_ISREG (file_stat.st_mode);
15697
15698 if (is_file == 1)
15699 {
15700 FILE *mask_fp;
15701
15702 if ((mask_fp = fopen (mask, "r")) == NULL)
15703 {
15704 log_error ("ERROR: %s: %s", mask, strerror (errno));
15705
15706 return (-1);
15707 }
15708
15709 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15710
15711 uint masks_avail = 1;
15712
15713 while (!feof (mask_fp))
15714 {
15715 memset (line_buf, 0, HCBUFSIZ);
15716
15717 int line_len = fgetl (mask_fp, line_buf);
15718
15719 if (line_len == 0) continue;
15720
15721 if (line_buf[0] == '#') continue;
15722
15723 if (masks_avail == maskcnt)
15724 {
15725 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15726
15727 masks_avail += INCR_MASKS;
15728 }
15729
15730 masks[maskcnt] = mystrdup (line_buf);
15731
15732 maskcnt++;
15733 }
15734
15735 myfree (line_buf);
15736
15737 fclose (mask_fp);
15738
15739 mask_from_file = 1;
15740 }
15741 else
15742 {
15743 maskcnt = 1;
15744
15745 masks[maskcnt - 1] = mystrdup (mask);
15746 }
15747 }
15748
15749 // base
15750
15751 int wls_left = myargc - (optind + 2);
15752
15753 for (int i = 0; i < wls_left; i++)
15754 {
15755 char *filename = myargv[optind + 2 + i];
15756
15757 struct stat file_stat;
15758
15759 if (stat (filename, &file_stat) == -1)
15760 {
15761 log_error ("ERROR: %s: %s", filename, strerror (errno));
15762
15763 return (-1);
15764 }
15765
15766 uint is_dir = S_ISDIR (file_stat.st_mode);
15767
15768 if (is_dir == 0)
15769 {
15770 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15771
15772 dictcnt++;
15773
15774 dictfiles[dictcnt - 1] = filename;
15775 }
15776 else
15777 {
15778 // do not allow --keyspace w/ a directory
15779
15780 if (keyspace == 1)
15781 {
15782 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15783
15784 return (-1);
15785 }
15786
15787 char **dictionary_files = NULL;
15788
15789 dictionary_files = scan_directory (filename);
15790
15791 if (dictionary_files != NULL)
15792 {
15793 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15794
15795 for (int d = 0; dictionary_files[d] != NULL; d++)
15796 {
15797 char *l1_filename = dictionary_files[d];
15798
15799 struct stat l1_stat;
15800
15801 if (stat (l1_filename, &l1_stat) == -1)
15802 {
15803 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15804
15805 return (-1);
15806 }
15807
15808 if (S_ISREG (l1_stat.st_mode))
15809 {
15810 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15811
15812 dictcnt++;
15813
15814 dictfiles[dictcnt - 1] = strdup (l1_filename);
15815 }
15816 }
15817 }
15818
15819 local_free (dictionary_files);
15820 }
15821 }
15822
15823 if (dictcnt < 1)
15824 {
15825 log_error ("ERROR: No usable dictionary file found.");
15826
15827 return (-1);
15828 }
15829
15830 if (increment)
15831 {
15832 maskcnt = 0;
15833
15834 uint mask_min = increment_min; // we can't reject smaller masks here
15835 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15836
15837 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15838 {
15839 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15840
15841 if (cur_mask == NULL) break;
15842
15843 masks[maskcnt] = cur_mask;
15844
15845 maskcnt++;
15846
15847 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15848 }
15849 }
15850 }
15851
15852 data.pw_min = pw_min;
15853 data.pw_max = pw_max;
15854
15855 /**
15856 * weak hash check
15857 */
15858
15859 if (weak_hash_threshold >= salts_cnt)
15860 {
15861 hc_device_param_t *device_param = NULL;
15862
15863 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15864 {
15865 device_param = &data.devices_param[device_id];
15866
15867 if (device_param->skipped) continue;
15868
15869 break;
15870 }
15871
15872 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15873
15874 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15875 {
15876 weak_hash_check (device_param, salt_pos);
15877 }
15878
15879 // Display hack, guarantee that there is at least one \r before real start
15880
15881 //if (data.quiet == 0) log_info ("");
15882 }
15883
15884 /**
15885 * status and monitor threads
15886 */
15887
15888 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15889
15890 hc_thread_t i_thread = 0;
15891
15892 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15893 {
15894 hc_thread_create (i_thread, thread_keypress, &benchmark);
15895 }
15896
15897 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15898
15899 uint ni_threads_cnt = 0;
15900
15901 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15902
15903 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15904
15905 ni_threads_cnt++;
15906
15907 /**
15908 * Outfile remove
15909 */
15910
15911 if (keyspace == 0)
15912 {
15913 if (outfile_check_timer != 0)
15914 {
15915 if (data.outfile_check_directory != NULL)
15916 {
15917 if ((hash_mode != 5200) &&
15918 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15919 (hash_mode != 9000))
15920 {
15921 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15922
15923 ni_threads_cnt++;
15924 }
15925 else
15926 {
15927 outfile_check_timer = 0;
15928 }
15929 }
15930 else
15931 {
15932 outfile_check_timer = 0;
15933 }
15934 }
15935 }
15936
15937 /**
15938 * Inform the user if we got some hashes remove because of the pot file remove feature
15939 */
15940
15941 if (data.quiet == 0)
15942 {
15943 if (potfile_remove_cracks > 0)
15944 {
15945 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15946 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15947 }
15948 }
15949
15950 data.outfile_check_timer = outfile_check_timer;
15951
15952 /**
15953 * main loop
15954 */
15955
15956 char **induction_dictionaries = NULL;
15957
15958 int induction_dictionaries_cnt = 0;
15959
15960 hcstat_table_t *root_table_buf = NULL;
15961 hcstat_table_t *markov_table_buf = NULL;
15962
15963 uint initial_restore_done = 0;
15964
15965 data.maskcnt = maskcnt;
15966
15967 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15968 {
15969 if (data.devices_status == STATUS_CRACKED) break;
15970
15971 data.devices_status = STATUS_INIT;
15972
15973 if (maskpos > rd->maskpos)
15974 {
15975 rd->dictpos = 0;
15976 }
15977
15978 rd->maskpos = maskpos;
15979 data.maskpos = maskpos;
15980
15981 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15982 {
15983 char *mask = masks[maskpos];
15984
15985 if (mask_from_file == 1)
15986 {
15987 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15988
15989 char *str_ptr;
15990 uint str_pos;
15991
15992 uint mask_offset = 0;
15993
15994 uint separator_cnt;
15995
15996 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15997 {
15998 str_ptr = strstr (mask + mask_offset, ",");
15999
16000 if (str_ptr == NULL) break;
16001
16002 str_pos = str_ptr - mask;
16003
16004 // escaped separator, i.e. "\,"
16005
16006 if (str_pos > 0)
16007 {
16008 if (mask[str_pos - 1] == '\\')
16009 {
16010 separator_cnt --;
16011
16012 mask_offset = str_pos + 1;
16013
16014 continue;
16015 }
16016 }
16017
16018 // reset the offset
16019
16020 mask_offset = 0;
16021
16022 mask[str_pos] = '\0';
16023
16024 switch (separator_cnt)
16025 {
16026 case 0:
16027 mp_reset_usr (mp_usr, 0);
16028
16029 custom_charset_1 = mask;
16030 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16031 break;
16032
16033 case 1:
16034 mp_reset_usr (mp_usr, 1);
16035
16036 custom_charset_2 = mask;
16037 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16038 break;
16039
16040 case 2:
16041 mp_reset_usr (mp_usr, 2);
16042
16043 custom_charset_3 = mask;
16044 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16045 break;
16046
16047 case 3:
16048 mp_reset_usr (mp_usr, 3);
16049
16050 custom_charset_4 = mask;
16051 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16052 break;
16053 }
16054
16055 mask = mask + str_pos + 1;
16056 }
16057 }
16058
16059 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16060 {
16061 if (maskpos > 0)
16062 {
16063 local_free (css_buf);
16064 local_free (data.root_css_buf);
16065 local_free (data.markov_css_buf);
16066
16067 local_free (masks[maskpos - 1]);
16068 }
16069
16070 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16071
16072 data.mask = mask;
16073 data.css_cnt = css_cnt;
16074 data.css_buf = css_buf;
16075
16076 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16077
16078 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16079
16080 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16081 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16082
16083 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16084
16085 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16086
16087 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16088 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16089
16090 data.root_css_buf = root_css_buf;
16091 data.markov_css_buf = markov_css_buf;
16092
16093 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16094
16095 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16096
16097 local_free (root_table_buf);
16098 local_free (markov_table_buf);
16099
16100 // args
16101
16102 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16103 {
16104 hc_device_param_t *device_param = &data.devices_param[device_id];
16105
16106 if (device_param->skipped) continue;
16107
16108 device_param->kernel_params_mp[0] = &device_param->d_combs;
16109 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16110 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16111
16112 device_param->kernel_params_mp_buf64[3] = 0;
16113 device_param->kernel_params_mp_buf32[4] = css_cnt;
16114 device_param->kernel_params_mp_buf32[5] = 0;
16115 device_param->kernel_params_mp_buf32[6] = 0;
16116 device_param->kernel_params_mp_buf32[7] = 0;
16117
16118 if (attack_mode == ATTACK_MODE_HYBRID1)
16119 {
16120 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16121 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16122 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16123 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16124 }
16125 else if (attack_mode == ATTACK_MODE_HYBRID2)
16126 {
16127 device_param->kernel_params_mp_buf32[5] = 0;
16128 device_param->kernel_params_mp_buf32[6] = 0;
16129 device_param->kernel_params_mp_buf32[7] = 0;
16130 }
16131
16132 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]);
16133 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]);
16134 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]);
16135
16136 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);
16137 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);
16138 }
16139 }
16140 else if (attack_mode == ATTACK_MODE_BF)
16141 {
16142 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16143
16144 if (increment)
16145 {
16146 for (uint i = 0; i < dictcnt; i++)
16147 {
16148 local_free (dictfiles[i]);
16149 }
16150
16151 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16152 {
16153 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16154
16155 if (l1_filename == NULL) break;
16156
16157 dictcnt++;
16158
16159 dictfiles[dictcnt - 1] = l1_filename;
16160 }
16161 }
16162 else
16163 {
16164 dictcnt++;
16165
16166 dictfiles[dictcnt - 1] = mask;
16167 }
16168
16169 if (dictcnt == 0)
16170 {
16171 log_error ("ERROR: Mask is too small");
16172
16173 return (-1);
16174 }
16175 }
16176 }
16177
16178 free (induction_dictionaries);
16179
16180 // induction_dictionaries_cnt = 0; // implied
16181
16182 if (attack_mode != ATTACK_MODE_BF)
16183 {
16184 if (keyspace == 0)
16185 {
16186 induction_dictionaries = scan_directory (induction_directory);
16187
16188 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16189 }
16190 }
16191
16192 if (induction_dictionaries_cnt)
16193 {
16194 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16195 }
16196
16197 /**
16198 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16199 */
16200 if (keyspace == 1)
16201 {
16202 if ((maskcnt > 1) || (dictcnt > 1))
16203 {
16204 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16205
16206 return (-1);
16207 }
16208 }
16209
16210 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16211 {
16212 char *subid = logfile_generate_subid ();
16213
16214 data.subid = subid;
16215
16216 logfile_sub_msg ("START");
16217
16218 data.devices_status = STATUS_INIT;
16219
16220 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16221 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16222 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16223
16224 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16225
16226 data.cpt_pos = 0;
16227
16228 data.cpt_start = time (NULL);
16229
16230 data.cpt_total = 0;
16231
16232 if (data.restore == 0)
16233 {
16234 rd->words_cur = skip;
16235
16236 skip = 0;
16237
16238 data.skip = 0;
16239 }
16240
16241 data.ms_paused = 0;
16242
16243 data.words_cur = rd->words_cur;
16244
16245 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16246 {
16247 hc_device_param_t *device_param = &data.devices_param[device_id];
16248
16249 if (device_param->skipped) continue;
16250
16251 device_param->speed_pos = 0;
16252
16253 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16254 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16255
16256 device_param->exec_pos = 0;
16257
16258 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16259
16260 device_param->kernel_power = device_param->kernel_power_user;
16261
16262 device_param->outerloop_pos = 0;
16263 device_param->outerloop_left = 0;
16264 device_param->innerloop_pos = 0;
16265 device_param->innerloop_left = 0;
16266
16267 // some more resets:
16268
16269 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16270
16271 device_param->pws_cnt = 0;
16272
16273 device_param->words_off = 0;
16274 device_param->words_done = 0;
16275 }
16276
16277 data.kernel_power_div = 0;
16278
16279 // figure out some workload
16280
16281 if (attack_mode == ATTACK_MODE_STRAIGHT)
16282 {
16283 if (data.wordlist_mode == WL_MODE_FILE)
16284 {
16285 char *dictfile = NULL;
16286
16287 if (induction_dictionaries_cnt)
16288 {
16289 dictfile = induction_dictionaries[0];
16290 }
16291 else
16292 {
16293 dictfile = dictfiles[dictpos];
16294 }
16295
16296 data.dictfile = dictfile;
16297
16298 logfile_sub_string (dictfile);
16299
16300 for (uint i = 0; i < rp_files_cnt; i++)
16301 {
16302 logfile_sub_var_string ("rulefile", rp_files[i]);
16303 }
16304
16305 FILE *fd2 = fopen (dictfile, "rb");
16306
16307 if (fd2 == NULL)
16308 {
16309 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16310
16311 return (-1);
16312 }
16313
16314 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16315
16316 fclose (fd2);
16317
16318 if (data.words_cnt == 0)
16319 {
16320 if (data.devices_status == STATUS_CRACKED) break;
16321 if (data.devices_status == STATUS_ABORTED) break;
16322
16323 dictpos++;
16324
16325 continue;
16326 }
16327 }
16328 }
16329 else if (attack_mode == ATTACK_MODE_COMBI)
16330 {
16331 char *dictfile = data.dictfile;
16332 char *dictfile2 = data.dictfile2;
16333
16334 logfile_sub_string (dictfile);
16335 logfile_sub_string (dictfile2);
16336
16337 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16338 {
16339 FILE *fd2 = fopen (dictfile, "rb");
16340
16341 if (fd2 == NULL)
16342 {
16343 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16344
16345 return (-1);
16346 }
16347
16348 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16349
16350 fclose (fd2);
16351 }
16352 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16353 {
16354 FILE *fd2 = fopen (dictfile2, "rb");
16355
16356 if (fd2 == NULL)
16357 {
16358 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16359
16360 return (-1);
16361 }
16362
16363 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16364
16365 fclose (fd2);
16366 }
16367
16368 if (data.words_cnt == 0)
16369 {
16370 if (data.devices_status == STATUS_CRACKED) break;
16371 if (data.devices_status == STATUS_ABORTED) break;
16372
16373 dictpos++;
16374
16375 continue;
16376 }
16377 }
16378 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16379 {
16380 char *dictfile = NULL;
16381
16382 if (induction_dictionaries_cnt)
16383 {
16384 dictfile = induction_dictionaries[0];
16385 }
16386 else
16387 {
16388 dictfile = dictfiles[dictpos];
16389 }
16390
16391 data.dictfile = dictfile;
16392
16393 char *mask = data.mask;
16394
16395 logfile_sub_string (dictfile);
16396 logfile_sub_string (mask);
16397
16398 FILE *fd2 = fopen (dictfile, "rb");
16399
16400 if (fd2 == NULL)
16401 {
16402 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16403
16404 return (-1);
16405 }
16406
16407 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16408
16409 fclose (fd2);
16410
16411 if (data.words_cnt == 0)
16412 {
16413 if (data.devices_status == STATUS_CRACKED) break;
16414 if (data.devices_status == STATUS_ABORTED) break;
16415
16416 dictpos++;
16417
16418 continue;
16419 }
16420 }
16421 else if (attack_mode == ATTACK_MODE_BF)
16422 {
16423 local_free (css_buf);
16424 local_free (data.root_css_buf);
16425 local_free (data.markov_css_buf);
16426
16427 char *mask = dictfiles[dictpos];
16428
16429 logfile_sub_string (mask);
16430
16431 // base
16432
16433 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16434
16435 if (opts_type & OPTS_TYPE_PT_UNICODE)
16436 {
16437 uint css_cnt_unicode = css_cnt * 2;
16438
16439 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16440
16441 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16442 {
16443 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16444
16445 css_buf_unicode[j + 1].cs_buf[0] = 0;
16446 css_buf_unicode[j + 1].cs_len = 1;
16447 }
16448
16449 free (css_buf);
16450
16451 css_buf = css_buf_unicode;
16452 css_cnt = css_cnt_unicode;
16453 }
16454
16455 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16456
16457 uint mask_min = pw_min;
16458 uint mask_max = pw_max;
16459
16460 if (opts_type & OPTS_TYPE_PT_UNICODE)
16461 {
16462 mask_min *= 2;
16463 mask_max *= 2;
16464 }
16465
16466 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16467 {
16468 if (css_cnt < mask_min)
16469 {
16470 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16471 }
16472
16473 if (css_cnt > mask_max)
16474 {
16475 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16476 }
16477
16478 // skip to next mask
16479
16480 dictpos++;
16481
16482 rd->dictpos = dictpos;
16483
16484 logfile_sub_msg ("STOP");
16485
16486 continue;
16487 }
16488
16489 uint save_css_cnt = css_cnt;
16490
16491 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16492 {
16493 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16494 {
16495 uint salt_len = (uint) data.salts_buf[0].salt_len;
16496 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16497
16498 uint css_cnt_salt = css_cnt + salt_len;
16499
16500 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16501
16502 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16503
16504 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16505 {
16506 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16507 css_buf_salt[j].cs_len = 1;
16508 }
16509
16510 free (css_buf);
16511
16512 css_buf = css_buf_salt;
16513 css_cnt = css_cnt_salt;
16514 }
16515 }
16516
16517 data.mask = mask;
16518 data.css_cnt = css_cnt;
16519 data.css_buf = css_buf;
16520
16521 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16522
16523 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16524
16525 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16526
16527 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16528 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16529
16530 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16531
16532 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16533
16534 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16535 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16536
16537 data.root_css_buf = root_css_buf;
16538 data.markov_css_buf = markov_css_buf;
16539
16540 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16541
16542 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16543
16544 local_free (root_table_buf);
16545 local_free (markov_table_buf);
16546
16547 // copy + args
16548
16549 uint css_cnt_l = css_cnt;
16550 uint css_cnt_r;
16551
16552 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16553 {
16554 if (save_css_cnt < 6)
16555 {
16556 css_cnt_r = 1;
16557 }
16558 else if (save_css_cnt == 6)
16559 {
16560 css_cnt_r = 2;
16561 }
16562 else
16563 {
16564 if (opts_type & OPTS_TYPE_PT_UNICODE)
16565 {
16566 if (save_css_cnt == 8 || save_css_cnt == 10)
16567 {
16568 css_cnt_r = 2;
16569 }
16570 else
16571 {
16572 css_cnt_r = 4;
16573 }
16574 }
16575 else
16576 {
16577 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16578 {
16579 css_cnt_r = 3;
16580 }
16581 else
16582 {
16583 css_cnt_r = 4;
16584 }
16585 }
16586 }
16587 }
16588 else
16589 {
16590 css_cnt_r = 1;
16591
16592 /* unfinished code?
16593 int sum = css_buf[css_cnt_r - 1].cs_len;
16594
16595 for (uint i = 1; i < 4 && i < css_cnt; i++)
16596 {
16597 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16598
16599 css_cnt_r++;
16600
16601 sum *= css_buf[css_cnt_r - 1].cs_len;
16602 }
16603 */
16604 }
16605
16606 css_cnt_l -= css_cnt_r;
16607
16608 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16609
16610 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16611 {
16612 hc_device_param_t *device_param = &data.devices_param[device_id];
16613
16614 if (device_param->skipped) continue;
16615
16616 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16617 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16618 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16619
16620 device_param->kernel_params_mp_l_buf64[3] = 0;
16621 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16622 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16623 device_param->kernel_params_mp_l_buf32[6] = 0;
16624 device_param->kernel_params_mp_l_buf32[7] = 0;
16625 device_param->kernel_params_mp_l_buf32[8] = 0;
16626
16627 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16628 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16629 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16630 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16631
16632 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16633 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16634 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16635
16636 device_param->kernel_params_mp_r_buf64[3] = 0;
16637 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16638 device_param->kernel_params_mp_r_buf32[5] = 0;
16639 device_param->kernel_params_mp_r_buf32[6] = 0;
16640 device_param->kernel_params_mp_r_buf32[7] = 0;
16641
16642 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]);
16643 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]);
16644 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]);
16645
16646 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]);
16647 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]);
16648 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]);
16649
16650 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);
16651 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);
16652 }
16653 }
16654
16655 u64 words_base = data.words_cnt;
16656
16657 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16658 {
16659 if (data.kernel_rules_cnt)
16660 {
16661 words_base /= data.kernel_rules_cnt;
16662 }
16663 }
16664 else if (data.attack_kern == ATTACK_KERN_COMBI)
16665 {
16666 if (data.combs_cnt)
16667 {
16668 words_base /= data.combs_cnt;
16669 }
16670 }
16671 else if (data.attack_kern == ATTACK_KERN_BF)
16672 {
16673 if (data.bfs_cnt)
16674 {
16675 words_base /= data.bfs_cnt;
16676 }
16677 }
16678
16679 data.words_base = words_base;
16680
16681 if (keyspace == 1)
16682 {
16683 log_info ("%llu", (unsigned long long int) words_base);
16684
16685 return (0);
16686 }
16687
16688 if (data.words_cur > data.words_base)
16689 {
16690 log_error ("ERROR: restore value greater keyspace");
16691
16692 return (-1);
16693 }
16694
16695 if (data.words_cur)
16696 {
16697 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16698 {
16699 for (uint i = 0; i < data.salts_cnt; i++)
16700 {
16701 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16702 }
16703 }
16704 else if (data.attack_kern == ATTACK_KERN_COMBI)
16705 {
16706 for (uint i = 0; i < data.salts_cnt; i++)
16707 {
16708 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16709 }
16710 }
16711 else if (data.attack_kern == ATTACK_KERN_BF)
16712 {
16713 for (uint i = 0; i < data.salts_cnt; i++)
16714 {
16715 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16716 }
16717 }
16718 }
16719
16720 /*
16721 * Inform user about possible slow speeds
16722 */
16723
16724 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16725 {
16726 if (data.words_base < kernel_power_all)
16727 {
16728 if (quiet == 0)
16729 {
16730 log_info ("ATTENTION!");
16731 log_info (" The wordlist or mask you are using is too small.");
16732 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
16733 log_info (" The cracking speed will drop.");
16734 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16735 log_info ("");
16736 }
16737 }
16738 }
16739
16740 /*
16741 * Update loopback file
16742 */
16743
16744 if (loopback == 1)
16745 {
16746 time_t now;
16747
16748 time (&now);
16749
16750 uint random_num = get_random_num (0, 9999);
16751
16752 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16753
16754 data.loopback_file = loopback_file;
16755 }
16756
16757 /*
16758 * Update dictionary statistic
16759 */
16760
16761 if (keyspace == 0)
16762 {
16763 dictstat_fp = fopen (dictstat, "wb");
16764
16765 if (dictstat_fp)
16766 {
16767 lock_file (dictstat_fp);
16768
16769 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16770
16771 fclose (dictstat_fp);
16772 }
16773 }
16774
16775 data.devices_status = STATUS_RUNNING;
16776
16777 if (initial_restore_done == 0)
16778 {
16779 if (data.restore_disable == 0) cycle_restore ();
16780
16781 initial_restore_done = 1;
16782 }
16783
16784 hc_timer_set (&data.timer_running);
16785
16786 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16787 {
16788 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16789 {
16790 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16791 if (quiet == 0) fflush (stdout);
16792 }
16793 }
16794 else if (wordlist_mode == WL_MODE_STDIN)
16795 {
16796 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16797 if (data.quiet == 0) log_info ("");
16798 }
16799
16800 time_t runtime_start;
16801
16802 time (&runtime_start);
16803
16804 data.runtime_start = runtime_start;
16805
16806 /**
16807 * create cracker threads
16808 */
16809
16810 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16811
16812 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16813 {
16814 hc_device_param_t *device_param = &devices_param[device_id];
16815
16816 if (wordlist_mode == WL_MODE_STDIN)
16817 {
16818 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16819 }
16820 else
16821 {
16822 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16823 }
16824 }
16825
16826 // wait for crack threads to exit
16827
16828 hc_thread_wait (data.devices_cnt, c_threads);
16829
16830 local_free (c_threads);
16831
16832 data.restore = 0;
16833
16834 // finalize task
16835
16836 logfile_sub_var_uint ("status-after-work", data.devices_status);
16837
16838 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16839
16840 if (data.devices_status == STATUS_CRACKED) break;
16841 if (data.devices_status == STATUS_ABORTED) break;
16842
16843 if (data.devices_status == STATUS_BYPASS)
16844 {
16845 data.devices_status = STATUS_RUNNING;
16846 }
16847
16848 if (induction_dictionaries_cnt)
16849 {
16850 unlink (induction_dictionaries[0]);
16851 }
16852
16853 free (induction_dictionaries);
16854
16855 if (attack_mode != ATTACK_MODE_BF)
16856 {
16857 induction_dictionaries = scan_directory (induction_directory);
16858
16859 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16860 }
16861
16862 if (benchmark == 0)
16863 {
16864 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16865 {
16866 if (quiet == 0) clear_prompt ();
16867
16868 if (quiet == 0) log_info ("");
16869
16870 if (status == 1)
16871 {
16872 status_display ();
16873 }
16874 else
16875 {
16876 if (quiet == 0) status_display ();
16877 }
16878
16879 if (quiet == 0) log_info ("");
16880 }
16881 }
16882
16883 if (attack_mode == ATTACK_MODE_BF)
16884 {
16885 dictpos++;
16886
16887 rd->dictpos = dictpos;
16888 }
16889 else
16890 {
16891 if (induction_dictionaries_cnt)
16892 {
16893 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16894 }
16895 else
16896 {
16897 dictpos++;
16898
16899 rd->dictpos = dictpos;
16900 }
16901 }
16902
16903 time_t runtime_stop;
16904
16905 time (&runtime_stop);
16906
16907 data.runtime_stop = runtime_stop;
16908
16909 logfile_sub_uint (runtime_start);
16910 logfile_sub_uint (runtime_stop);
16911
16912 logfile_sub_msg ("STOP");
16913
16914 global_free (subid);
16915 }
16916
16917 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16918
16919 if (data.devices_status == STATUS_CRACKED) break;
16920 if (data.devices_status == STATUS_ABORTED) break;
16921 if (data.devices_status == STATUS_QUIT) break;
16922
16923 if (data.devices_status == STATUS_BYPASS)
16924 {
16925 data.devices_status = STATUS_RUNNING;
16926 }
16927 }
16928
16929 // 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
16930
16931 if (attack_mode == ATTACK_MODE_STRAIGHT)
16932 {
16933 if (data.wordlist_mode == WL_MODE_FILE)
16934 {
16935 if (data.dictfile == NULL)
16936 {
16937 if (dictfiles != NULL)
16938 {
16939 data.dictfile = dictfiles[0];
16940
16941 hc_timer_set (&data.timer_running);
16942 }
16943 }
16944 }
16945 }
16946 // NOTE: combi is okay because it is already set beforehand
16947 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16948 {
16949 if (data.dictfile == NULL)
16950 {
16951 if (dictfiles != NULL)
16952 {
16953 hc_timer_set (&data.timer_running);
16954
16955 data.dictfile = dictfiles[0];
16956 }
16957 }
16958 }
16959 else if (attack_mode == ATTACK_MODE_BF)
16960 {
16961 if (data.mask == NULL)
16962 {
16963 hc_timer_set (&data.timer_running);
16964
16965 data.mask = masks[0];
16966 }
16967 }
16968
16969 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16970 {
16971 data.devices_status = STATUS_EXHAUSTED;
16972 }
16973
16974 // if cracked / aborted remove last induction dictionary
16975
16976 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16977 {
16978 struct stat induct_stat;
16979
16980 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16981 {
16982 unlink (induction_dictionaries[file_pos]);
16983 }
16984 }
16985
16986 // wait for non-interactive threads
16987
16988 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16989 {
16990 hc_thread_wait (1, &ni_threads[thread_idx]);
16991 }
16992
16993 local_free (ni_threads);
16994
16995 // wait for interactive threads
16996
16997 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16998 {
16999 hc_thread_wait (1, &i_thread);
17000 }
17001
17002 // we dont need restore file anymore
17003 if (data.restore_disable == 0)
17004 {
17005 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17006 {
17007 unlink (eff_restore_file);
17008 unlink (new_restore_file);
17009 }
17010 else
17011 {
17012 cycle_restore ();
17013 }
17014 }
17015
17016 // finally save left hashes
17017
17018 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17019 {
17020 save_hash ();
17021 }
17022
17023 /**
17024 * Clean up
17025 */
17026
17027 if (benchmark == 1)
17028 {
17029 status_benchmark ();
17030
17031 if (status_automat == 0)
17032 {
17033 log_info ("");
17034 }
17035 }
17036 else
17037 {
17038 if (quiet == 0) clear_prompt ();
17039
17040 if (quiet == 0) log_info ("");
17041
17042 if (status == 1)
17043 {
17044 status_display ();
17045 }
17046 else
17047 {
17048 if (quiet == 0) status_display ();
17049 }
17050
17051 if (quiet == 0) log_info ("");
17052 }
17053
17054 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17055 {
17056 hc_device_param_t *device_param = &data.devices_param[device_id];
17057
17058 if (device_param->skipped) continue;
17059
17060 local_free (device_param->result);
17061
17062 local_free (device_param->combs_buf);
17063
17064 local_free (device_param->hooks_buf);
17065
17066 local_free (device_param->device_name);
17067
17068 local_free (device_param->device_name_chksum);
17069
17070 local_free (device_param->device_version);
17071
17072 local_free (device_param->driver_version);
17073
17074 if (device_param->pws_buf) myfree (device_param->pws_buf);
17075 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17076 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17077 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17078 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17079 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17080 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17081 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17082 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17083 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17084 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17085 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17086 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17087 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17088 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17089 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17090 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17091 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17092 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17093 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17094 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17095 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17096 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17097 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17098 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17099 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17100 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17101 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17102 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17103
17104 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17105 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17106 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17107 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17108 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17109 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17110 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17111 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17112 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17113 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17114
17115 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17116 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17117 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17118
17119 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17120 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17121 }
17122
17123 // reset default fan speed
17124
17125 #ifdef HAVE_HWMON
17126 if (gpu_temp_disable == 0)
17127 {
17128 #ifdef HAVE_ADL
17129 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17130 {
17131 hc_thread_mutex_lock (mux_adl);
17132
17133 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17134 {
17135 hc_device_param_t *device_param = &data.devices_param[device_id];
17136
17137 if (device_param->skipped) continue;
17138
17139 if (data.hm_device[device_id].fan_supported == 1)
17140 {
17141 int fanspeed = temp_retain_fanspeed_value[device_id];
17142
17143 if (fanspeed == -1) continue;
17144
17145 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
17146
17147 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
17148 }
17149 }
17150
17151 hc_thread_mutex_unlock (mux_adl);
17152 }
17153 #endif // HAVE_ADL
17154 }
17155
17156 #ifdef HAVE_ADL
17157 // reset power tuning
17158
17159 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17160 {
17161 hc_thread_mutex_lock (mux_adl);
17162
17163 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17164 {
17165 hc_device_param_t *device_param = &data.devices_param[device_id];
17166
17167 if (device_param->skipped) continue;
17168
17169 if (data.hm_device[device_id].od_version == 6)
17170 {
17171 // check powertune capabilities first, if not available then skip device
17172
17173 int powertune_supported = 0;
17174
17175 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17176 {
17177 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17178
17179 return (-1);
17180 }
17181
17182 if (powertune_supported != 0)
17183 {
17184 // powercontrol settings
17185
17186 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)
17187 {
17188 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17189
17190 return (-1);
17191 }
17192
17193 // clocks
17194
17195 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17196
17197 performance_state->iNumberOfPerformanceLevels = 2;
17198
17199 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17200 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17201 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17202 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17203
17204 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)
17205 {
17206 log_info ("ERROR: Failed to restore ADL performance state");
17207
17208 return (-1);
17209 }
17210
17211 local_free (performance_state);
17212 }
17213 }
17214 }
17215
17216 hc_thread_mutex_unlock (mux_adl);
17217 }
17218 #endif // HAVE_ADL
17219
17220 if (gpu_temp_disable == 0)
17221 {
17222 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17223 if (data.hm_nv)
17224 {
17225 #if defined(LINUX) && defined(HAVE_NVML)
17226
17227 hm_NVML_nvmlShutdown (data.hm_nv);
17228
17229 nvml_close (data.hm_nv);
17230
17231 #elif defined(WIN) && (HAVE_NVAPI)
17232
17233 hm_NvAPI_Unload (data.hm_nv);
17234
17235 nvapi_close (data.hm_nv);
17236
17237 #endif
17238
17239 data.hm_nv = NULL;
17240 }
17241 #endif
17242
17243 #ifdef HAVE_ADL
17244 if (data.hm_amd)
17245 {
17246 hm_ADL_Main_Control_Destroy (data.hm_amd);
17247
17248 adl_close (data.hm_amd);
17249 data.hm_amd = NULL;
17250 }
17251 #endif
17252 }
17253 #endif // HAVE_HWMON
17254
17255 // free memory
17256
17257 local_free (masks);
17258
17259 local_free (dictstat_base);
17260
17261 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17262 {
17263 pot_t *pot_ptr = &pot[pot_pos];
17264
17265 hash_t *hash = &pot_ptr->hash;
17266
17267 local_free (hash->digest);
17268
17269 if (isSalted)
17270 {
17271 local_free (hash->salt);
17272 }
17273 }
17274
17275 local_free (pot);
17276
17277 local_free (all_kernel_rules_cnt);
17278 local_free (all_kernel_rules_buf);
17279
17280 local_free (wl_data->buf);
17281 local_free (wl_data);
17282
17283 local_free (bitmap_s1_a);
17284 local_free (bitmap_s1_b);
17285 local_free (bitmap_s1_c);
17286 local_free (bitmap_s1_d);
17287 local_free (bitmap_s2_a);
17288 local_free (bitmap_s2_b);
17289 local_free (bitmap_s2_c);
17290 local_free (bitmap_s2_d);
17291
17292 #ifdef HAVE_HWMON
17293 local_free (temp_retain_fanspeed_value);
17294 #ifdef HAVE_ADL
17295 local_free (od_clock_mem_status);
17296 local_free (od_power_control_status);
17297 #endif // ADL
17298 #endif
17299
17300 global_free (devices_param);
17301
17302 global_free (kernel_rules_buf);
17303
17304 global_free (root_css_buf);
17305 global_free (markov_css_buf);
17306
17307 global_free (digests_buf);
17308 global_free (digests_shown);
17309 global_free (digests_shown_tmp);
17310
17311 global_free (salts_buf);
17312 global_free (salts_shown);
17313
17314 global_free (esalts_buf);
17315
17316 global_free (words_progress_done);
17317 global_free (words_progress_rejected);
17318 global_free (words_progress_restored);
17319
17320 if (pot_fp) fclose (pot_fp);
17321
17322 if (data.devices_status == STATUS_QUIT) break;
17323 }
17324
17325 // destroy others mutex
17326
17327 hc_thread_mutex_delete (mux_dispatcher);
17328 hc_thread_mutex_delete (mux_counter);
17329 hc_thread_mutex_delete (mux_display);
17330 hc_thread_mutex_delete (mux_adl);
17331
17332 // free memory
17333
17334 local_free (eff_restore_file);
17335 local_free (new_restore_file);
17336
17337 local_free (rd);
17338
17339 // tuning db
17340
17341 tuning_db_destroy (tuning_db);
17342
17343 // loopback
17344
17345 local_free (loopback_file);
17346
17347 if (loopback == 1) unlink (loopback_file);
17348
17349 // induction directory
17350
17351 if (induction_dir == NULL)
17352 {
17353 if (attack_mode != ATTACK_MODE_BF)
17354 {
17355 if (rmdir (induction_directory) == -1)
17356 {
17357 if (errno == ENOENT)
17358 {
17359 // good, we can ignore
17360 }
17361 else if (errno == ENOTEMPTY)
17362 {
17363 // good, we can ignore
17364 }
17365 else
17366 {
17367 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17368
17369 return (-1);
17370 }
17371 }
17372
17373 local_free (induction_directory);
17374 }
17375 }
17376
17377 // outfile-check directory
17378
17379 if (outfile_check_dir == NULL)
17380 {
17381 if (rmdir (outfile_check_directory) == -1)
17382 {
17383 if (errno == ENOENT)
17384 {
17385 // good, we can ignore
17386 }
17387 else if (errno == ENOTEMPTY)
17388 {
17389 // good, we can ignore
17390 }
17391 else
17392 {
17393 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17394
17395 return (-1);
17396 }
17397 }
17398
17399 local_free (outfile_check_directory);
17400 }
17401
17402 time_t proc_stop;
17403
17404 time (&proc_stop);
17405
17406 logfile_top_uint (proc_start);
17407 logfile_top_uint (proc_stop);
17408
17409 logfile_top_msg ("STOP");
17410
17411 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17412 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17413
17414 if (data.ocl) ocl_close (data.ocl);
17415
17416 if (data.devices_status == STATUS_ABORTED) return 2;
17417 if (data.devices_status == STATUS_QUIT) return 2;
17418 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17419 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17420 if (data.devices_status == STATUS_CRACKED) return 0;
17421
17422 return -1;
17423 }
Hashcat additions to support pwdhash