projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Added SIMD code for all generic PBKDF2-HMAC-* modes
[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 float hashes_all_ms = 0;
1164
1165 float 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] = 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 ()
1612 {
1613 if (data.devices_status == STATUS_INIT) return;
1614 if (data.devices_status == STATUS_STARTING) return;
1615
1616 if (data.words_cnt == 0) return;
1617
1618 u64 speed_cnt[DEVICES_MAX] = { 0 };
1619 double speed_ms[DEVICES_MAX] = { 0 };
1620
1621 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1622 {
1623 hc_device_param_t *device_param = &data.devices_param[device_id];
1624
1625 if (device_param->skipped) continue;
1626
1627 speed_cnt[device_id] = device_param->speed_cnt[0];
1628 speed_ms[device_id] = device_param->speed_ms[0];
1629 }
1630
1631 float hashes_all_ms = 0;
1632
1633 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1634
1635 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1636 {
1637 hc_device_param_t *device_param = &data.devices_param[device_id];
1638
1639 if (device_param->skipped) continue;
1640
1641 hashes_dev_ms[device_id] = 0;
1642
1643 if (speed_ms[device_id])
1644 {
1645 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1646
1647 hashes_all_ms += hashes_dev_ms[device_id];
1648 }
1649 }
1650
1651 /**
1652 * exec time
1653 */
1654
1655 double exec_all_ms[DEVICES_MAX] = { 0 };
1656
1657 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1658 {
1659 hc_device_param_t *device_param = &data.devices_param[device_id];
1660
1661 if (device_param->skipped) continue;
1662
1663 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1664
1665 exec_all_ms[device_id] = exec_ms_avg;
1666 }
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 char display_dev_cur[16] = { 0 };
1675
1676 strncpy (display_dev_cur, "0.00", 4);
1677
1678 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1679
1680 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1681 }
1682
1683 char display_all_cur[16] = { 0 };
1684
1685 strncpy (display_all_cur, "0.00", 4);
1686
1687 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1688
1689 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1690 }
1691
1692 /**
1693 * hashcat -only- functions
1694 */
1695
1696 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1697 {
1698 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1699 {
1700 if (attack_kern == ATTACK_KERN_STRAIGHT)
1701 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1702 else if (attack_kern == ATTACK_KERN_COMBI)
1703 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1704 else if (attack_kern == ATTACK_KERN_BF)
1705 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1706 }
1707 else
1708 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1709 }
1710
1711 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)
1712 {
1713 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1714 {
1715 if (attack_kern == ATTACK_KERN_STRAIGHT)
1716 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1717 else if (attack_kern == ATTACK_KERN_COMBI)
1718 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1719 else if (attack_kern == ATTACK_KERN_BF)
1720 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1721 }
1722 else
1723 {
1724 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1725 }
1726 }
1727
1728 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1729 {
1730 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1731 {
1732 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1733 }
1734 else
1735 {
1736 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1737 }
1738 }
1739
1740 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)
1741 {
1742 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1743 {
1744 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1745 }
1746 else
1747 {
1748 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1749 }
1750 }
1751
1752 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1753 {
1754 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1755 }
1756
1757 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1758 {
1759 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1760 }
1761
1762 static uint convert_from_hex (char *line_buf, const uint line_len)
1763 {
1764 if (line_len & 1) return (line_len); // not in hex
1765
1766 if (data.hex_wordlist == 1)
1767 {
1768 uint i;
1769 uint j;
1770
1771 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1772 {
1773 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1774 }
1775
1776 memset (line_buf + i, 0, line_len - i);
1777
1778 return (i);
1779 }
1780 else if (line_len >= 6) // $HEX[] = 6
1781 {
1782 if (line_buf[0] != '$') return (line_len);
1783 if (line_buf[1] != 'H') return (line_len);
1784 if (line_buf[2] != 'E') return (line_len);
1785 if (line_buf[3] != 'X') return (line_len);
1786 if (line_buf[4] != '[') return (line_len);
1787 if (line_buf[line_len - 1] != ']') return (line_len);
1788
1789 uint i;
1790 uint j;
1791
1792 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1793 {
1794 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1795 }
1796
1797 memset (line_buf + i, 0, line_len - i);
1798
1799 return (i);
1800 }
1801
1802 return (line_len);
1803 }
1804
1805 static void clear_prompt ()
1806 {
1807 fputc ('\r', stdout);
1808
1809 for (size_t i = 0; i < strlen (PROMPT); i++)
1810 {
1811 fputc (' ', stdout);
1812 }
1813
1814 fputc ('\r', stdout);
1815
1816 fflush (stdout);
1817 }
1818
1819 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1820 {
1821 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);
1822 }
1823
1824 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1825 {
1826 char *outfile = data.outfile;
1827 uint quiet = data.quiet;
1828 FILE *pot_fp = data.pot_fp;
1829 uint loopback = data.loopback;
1830 uint debug_mode = data.debug_mode;
1831 char *debug_file = data.debug_file;
1832
1833 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1834 int debug_rule_len = 0; // -1 error
1835 uint debug_plain_len = 0;
1836
1837 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1838
1839 // hash
1840
1841 char out_buf[HCBUFSIZ] = { 0 };
1842
1843 ascii_digest (out_buf, salt_pos, digest_pos);
1844
1845 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1846
1847 // plain
1848
1849 plain_t plain;
1850
1851 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);
1852
1853 uint gidvid = plain.gidvid;
1854 uint il_pos = plain.il_pos;
1855
1856 u64 crackpos = device_param->words_off;
1857
1858 uint plain_buf[16] = { 0 };
1859
1860 u8 *plain_ptr = (u8 *) plain_buf;
1861 unsigned int plain_len = 0;
1862
1863 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1864 {
1865 u64 gidd = gidvid;
1866 u64 gidm = 0;
1867
1868 pw_t pw;
1869
1870 gidd_to_pw_t (device_param, gidd, &pw);
1871
1872 for (int i = 0, j = gidm; i < 16; i++, j++)
1873 {
1874 plain_buf[i] = pw.i[j];
1875 }
1876
1877 plain_len = pw.pw_len;
1878
1879 const uint off = device_param->innerloop_pos + il_pos;
1880
1881 if (debug_mode > 0)
1882 {
1883 debug_rule_len = 0;
1884
1885 // save rule
1886 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1887 {
1888 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1889
1890 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1891 }
1892
1893 // save plain
1894 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1895 {
1896 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1897
1898 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1899
1900 debug_plain_len = plain_len;
1901 }
1902 }
1903
1904 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1905
1906 crackpos += gidvid;
1907 crackpos *= data.kernel_rules_cnt;
1908 crackpos += device_param->innerloop_pos + il_pos;
1909
1910 if (plain_len > data.pw_max) plain_len = data.pw_max;
1911 }
1912 else if (data.attack_mode == ATTACK_MODE_COMBI)
1913 {
1914 u64 gidd = gidvid;
1915 u64 gidm = 0;
1916
1917 pw_t pw;
1918
1919 gidd_to_pw_t (device_param, gidd, &pw);
1920
1921 for (int i = 0, j = gidm; i < 16; i++, j++)
1922 {
1923 plain_buf[i] = pw.i[j];
1924 }
1925
1926 plain_len = pw.pw_len;
1927
1928 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1929 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1930
1931 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1932 {
1933 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1934 }
1935 else
1936 {
1937 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1938
1939 memcpy (plain_ptr, comb_buf, comb_len);
1940 }
1941
1942 plain_len += comb_len;
1943
1944 crackpos += gidvid;
1945 crackpos *= data.combs_cnt;
1946 crackpos += device_param->innerloop_pos + il_pos;
1947
1948 if (data.pw_max != PW_DICTMAX1)
1949 {
1950 if (plain_len > data.pw_max) plain_len = data.pw_max;
1951 }
1952 }
1953 else if (data.attack_mode == ATTACK_MODE_BF)
1954 {
1955 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1956 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1957
1958 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1959 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1960
1961 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1962 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1963
1964 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1965 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1966
1967 plain_len = data.css_cnt;
1968
1969 crackpos += gidvid;
1970 crackpos *= data.bfs_cnt;
1971 crackpos += device_param->innerloop_pos + il_pos;
1972 }
1973 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1974 {
1975 u64 gidd = gidvid;
1976 u64 gidm = 0;
1977
1978 pw_t pw;
1979
1980 gidd_to_pw_t (device_param, gidd, &pw);
1981
1982 for (int i = 0, j = gidm; i < 16; i++, j++)
1983 {
1984 plain_buf[i] = pw.i[j];
1985 }
1986
1987 plain_len = pw.pw_len;
1988
1989 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
1990
1991 uint start = 0;
1992 uint stop = device_param->kernel_params_mp_buf32[4];
1993
1994 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1995
1996 plain_len += start + stop;
1997
1998 crackpos += gidvid;
1999 crackpos *= data.combs_cnt;
2000 crackpos += device_param->innerloop_pos + il_pos;
2001
2002 if (data.pw_max != PW_DICTMAX1)
2003 {
2004 if (plain_len > data.pw_max) plain_len = data.pw_max;
2005 }
2006 }
2007 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2008 {
2009 u64 gidd = gidvid;
2010 u64 gidm = 0;
2011
2012 pw_t pw;
2013
2014 gidd_to_pw_t (device_param, gidd, &pw);
2015
2016 for (int i = 0, j = gidm; i < 16; i++, j++)
2017 {
2018 plain_buf[i] = pw.i[j];
2019 }
2020
2021 plain_len = pw.pw_len;
2022
2023 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2024
2025 uint start = 0;
2026 uint stop = device_param->kernel_params_mp_buf32[4];
2027
2028 memmove (plain_ptr + stop, plain_ptr, plain_len);
2029
2030 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2031
2032 plain_len += start + stop;
2033
2034 crackpos += gidvid;
2035 crackpos *= data.combs_cnt;
2036 crackpos += device_param->innerloop_pos + il_pos;
2037
2038 if (data.pw_max != PW_DICTMAX1)
2039 {
2040 if (plain_len > data.pw_max) plain_len = data.pw_max;
2041 }
2042 }
2043
2044 if (data.attack_mode == ATTACK_MODE_BF)
2045 {
2046 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2047 {
2048 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2049 {
2050 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2051 {
2052 plain_len = plain_len - data.salts_buf[0].salt_len;
2053 }
2054 }
2055
2056 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2057 {
2058 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2059 {
2060 plain_ptr[j] = plain_ptr[i];
2061 }
2062
2063 plain_len = plain_len / 2;
2064 }
2065 }
2066 }
2067
2068 // if enabled, update also the potfile
2069
2070 if (pot_fp)
2071 {
2072 lock_file (pot_fp);
2073
2074 fprintf (pot_fp, "%s:", out_buf);
2075
2076 format_plain (pot_fp, plain_ptr, plain_len, 1);
2077
2078 fputc ('\n', pot_fp);
2079
2080 fflush (pot_fp);
2081
2082 unlock_file (pot_fp);
2083 }
2084
2085 // outfile
2086
2087 FILE *out_fp = NULL;
2088
2089 if (outfile != NULL)
2090 {
2091 if ((out_fp = fopen (outfile, "ab")) == NULL)
2092 {
2093 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2094
2095 out_fp = stdout;
2096 }
2097 lock_file (out_fp);
2098 }
2099 else
2100 {
2101 out_fp = stdout;
2102
2103 if (quiet == 0) clear_prompt ();
2104 }
2105
2106 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2107
2108 if (outfile != NULL)
2109 {
2110 if (out_fp != stdout)
2111 {
2112 fclose (out_fp);
2113 }
2114 }
2115 else
2116 {
2117 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2118 {
2119 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2120 {
2121 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2122 if (quiet == 0) fflush (stdout);
2123 }
2124 }
2125 }
2126
2127 // loopback
2128
2129 if (loopback)
2130 {
2131 char *loopback_file = data.loopback_file;
2132
2133 FILE *fb_fp = NULL;
2134
2135 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2136 {
2137 lock_file (fb_fp);
2138
2139 format_plain (fb_fp, plain_ptr, plain_len, 1);
2140
2141 fputc ('\n', fb_fp);
2142
2143 fclose (fb_fp);
2144 }
2145 }
2146
2147 // (rule) debug mode
2148
2149 // the next check implies that:
2150 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2151 // - debug_mode > 0
2152
2153 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2154 {
2155 if (debug_rule_len < 0) debug_rule_len = 0;
2156
2157 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2158
2159 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2160
2161 if ((quiet == 0) && (debug_file == NULL))
2162 {
2163 fprintf (stdout, "%s", PROMPT);
2164
2165 fflush (stdout);
2166 }
2167 }
2168 }
2169
2170 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2171 {
2172 salt_t *salt_buf = &data.salts_buf[salt_pos];
2173
2174 int found = 0;
2175
2176 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);
2177
2178 for (uint i = 0; i < device_param->kernel_threads; i++) if (device_param->result[i] == 1) found = 1;
2179
2180 if (found == 1)
2181 {
2182 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2183
2184 log_info_nn ("");
2185
2186 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);
2187
2188 uint cpt_cracked = 0;
2189
2190 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2191 {
2192 uint idx = salt_buf->digests_offset + digest_pos;
2193
2194 if (data.digests_shown_tmp[idx] == 0) continue;
2195
2196 if (data.digests_shown[idx] == 1) continue;
2197
2198 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2199 {
2200 data.digests_shown[idx] = 1;
2201
2202 data.digests_done++;
2203
2204 cpt_cracked++;
2205
2206 salt_buf->digests_done++;
2207
2208 if (salt_buf->digests_done == salt_buf->digests_cnt)
2209 {
2210 data.salts_shown[salt_pos] = 1;
2211
2212 data.salts_done++;
2213 }
2214 }
2215
2216 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2217
2218 check_hash (device_param, salt_pos, digest_pos);
2219 }
2220
2221 if (cpt_cracked > 0)
2222 {
2223 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2224 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2225
2226 data.cpt_pos++;
2227
2228 data.cpt_total += cpt_cracked;
2229
2230 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2231 }
2232
2233 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2234 {
2235 // we need to reset cracked state on the device
2236 // otherwise host thinks again and again the hash was cracked
2237 // and returns invalid password each time
2238
2239 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2240
2241 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);
2242 }
2243
2244 memset (device_param->result, 0, device_param->size_results);
2245
2246 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);
2247 }
2248 }
2249
2250 static void save_hash ()
2251 {
2252 char *hashfile = data.hashfile;
2253
2254 char new_hashfile[256] = { 0 };
2255 char old_hashfile[256] = { 0 };
2256
2257 snprintf (new_hashfile, 255, "%s.new", hashfile);
2258 snprintf (old_hashfile, 255, "%s.old", hashfile);
2259
2260 unlink (new_hashfile);
2261
2262 char separator = data.separator;
2263
2264 FILE *fp = fopen (new_hashfile, "wb");
2265
2266 if (fp == NULL)
2267 {
2268 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2269
2270 exit (-1);
2271 }
2272
2273 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2274 {
2275 if (data.salts_shown[salt_pos] == 1) continue;
2276
2277 salt_t *salt_buf = &data.salts_buf[salt_pos];
2278
2279 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2280 {
2281 uint idx = salt_buf->digests_offset + digest_pos;
2282
2283 if (data.digests_shown[idx] == 1) continue;
2284
2285 if (data.hash_mode != 2500)
2286 {
2287 char out_buf[HCBUFSIZ] = { 0 };
2288
2289 if (data.username == 1)
2290 {
2291 user_t *user = data.hash_info[idx]->user;
2292
2293 uint i;
2294
2295 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2296
2297 fputc (separator, fp);
2298 }
2299
2300 ascii_digest (out_buf, salt_pos, digest_pos);
2301
2302 fputs (out_buf, fp);
2303
2304 log_out (fp, "");
2305 }
2306 else
2307 {
2308 hccap_t hccap;
2309
2310 to_hccap_t (&hccap, salt_pos, digest_pos);
2311
2312 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2313 }
2314 }
2315 }
2316
2317 fflush (fp);
2318
2319 fclose (fp);
2320
2321 unlink (old_hashfile);
2322
2323 if (rename (hashfile, old_hashfile) != 0)
2324 {
2325 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2326
2327 exit (-1);
2328 }
2329
2330 unlink (hashfile);
2331
2332 if (rename (new_hashfile, hashfile) != 0)
2333 {
2334 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2335
2336 exit (-1);
2337 }
2338
2339 unlink (old_hashfile);
2340 }
2341
2342 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2343 {
2344 // function called only in case kernel_power_all > words_left
2345
2346 float kernel_power_div = (float) (total_left) / kernel_power_all;
2347
2348 kernel_power_div += kernel_power_div / 100;
2349
2350 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2351
2352 while (kernel_power_new < total_left)
2353 {
2354 kernel_power_div += kernel_power_div / 100;
2355
2356 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2357 }
2358
2359 if (data.quiet == 0)
2360 {
2361 clear_prompt ();
2362
2363 //log_info ("");
2364
2365 log_info ("INFO: approaching final keyspace, workload adjusted");
2366 log_info ("");
2367
2368 fprintf (stdout, "%s", PROMPT);
2369
2370 fflush (stdout);
2371 }
2372
2373 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2374
2375 return kernel_power_div;
2376 }
2377
2378 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2379 {
2380 uint num_elements = num;
2381
2382 device_param->kernel_params_buf32[30] = data.combs_mode;
2383 device_param->kernel_params_buf32[31] = num;
2384
2385 uint kernel_threads = device_param->kernel_threads;
2386
2387 while (num_elements % kernel_threads) num_elements++;
2388
2389 cl_kernel kernel = NULL;
2390
2391 switch (kern_run)
2392 {
2393 case KERN_RUN_1: kernel = device_param->kernel1; break;
2394 case KERN_RUN_12: kernel = device_param->kernel12; break;
2395 case KERN_RUN_2: kernel = device_param->kernel2; break;
2396 case KERN_RUN_23: kernel = device_param->kernel23; break;
2397 case KERN_RUN_3: kernel = device_param->kernel3; break;
2398 }
2399
2400 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2401 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2402 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2403 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2404 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2405 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2406 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2407 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2408 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2409 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2410 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2411
2412 cl_event event;
2413
2414 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2415 {
2416 const size_t global_work_size[3] = { num_elements, 32, 1 };
2417 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2418
2419 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2420 }
2421 else
2422 {
2423 if (kern_run == KERN_RUN_2)
2424 {
2425 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2426 {
2427 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2428 }
2429 }
2430
2431 while (num_elements % kernel_threads) num_elements++;
2432
2433 const size_t global_work_size[3] = { num_elements, 1, 1 };
2434 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2435
2436 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2437 }
2438
2439 hc_clFlush (data.ocl, device_param->command_queue);
2440
2441 hc_clWaitForEvents (data.ocl, 1, &event);
2442
2443 if (event_update)
2444 {
2445 cl_ulong time_start;
2446 cl_ulong time_end;
2447
2448 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2449 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2450
2451 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2452
2453 uint exec_pos = device_param->exec_pos;
2454
2455 device_param->exec_ms[exec_pos] = exec_time;
2456
2457 exec_pos++;
2458
2459 if (exec_pos == EXEC_CACHE)
2460 {
2461 exec_pos = 0;
2462 }
2463
2464 device_param->exec_pos = exec_pos;
2465 }
2466
2467 hc_clReleaseEvent (data.ocl, event);
2468
2469 hc_clFinish (data.ocl, device_param->command_queue);
2470 }
2471
2472 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2473 {
2474 uint num_elements = num;
2475
2476 switch (kern_run)
2477 {
2478 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2479 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2480 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2481 }
2482
2483 // causes problems with special threads like in bcrypt
2484 // const uint kernel_threads = device_param->kernel_threads;
2485
2486 uint kernel_threads = device_param->kernel_threads;
2487
2488 while (num_elements % kernel_threads) num_elements++;
2489
2490 cl_kernel kernel = NULL;
2491
2492 switch (kern_run)
2493 {
2494 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2495 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2496 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2497 }
2498
2499 switch (kern_run)
2500 {
2501 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2502 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2503 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2504 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2505 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2506 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2507 break;
2508 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2509 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2510 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2511 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2512 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2513 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2514 break;
2515 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2516 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2517 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2518 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2519 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2520 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2521 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2522 break;
2523 }
2524
2525 const size_t global_work_size[3] = { num_elements, 1, 1 };
2526 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2527
2528 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2529
2530 hc_clFlush (data.ocl, device_param->command_queue);
2531
2532 hc_clFinish (data.ocl, device_param->command_queue);
2533 }
2534
2535 static void run_kernel_tm (hc_device_param_t *device_param)
2536 {
2537 const uint num_elements = 1024; // fixed
2538
2539 uint kernel_threads = 32;
2540
2541 cl_kernel kernel = device_param->kernel_tm;
2542
2543 const size_t global_work_size[3] = { num_elements, 1, 1 };
2544 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2545
2546 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2547
2548 hc_clFlush (data.ocl, device_param->command_queue);
2549
2550 hc_clFinish (data.ocl, device_param->command_queue);
2551 }
2552
2553 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2554 {
2555 uint num_elements = num;
2556
2557 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2558 device_param->kernel_params_amp_buf32[6] = num_elements;
2559
2560 // causes problems with special threads like in bcrypt
2561 // const uint kernel_threads = device_param->kernel_threads;
2562
2563 uint kernel_threads = device_param->kernel_threads;
2564
2565 while (num_elements % kernel_threads) num_elements++;
2566
2567 cl_kernel kernel = device_param->kernel_amp;
2568
2569 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2570 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
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_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2583 {
2584 int rc = -1;
2585
2586 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2587 {
2588 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2589
2590 const cl_uchar zero = 0;
2591
2592 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2593 }
2594
2595 if (rc != 0)
2596 {
2597 // NOTE: clEnqueueFillBuffer () always fails with -59
2598 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2599 // How's that possible, OpenCL 1.2 support is advertised??
2600 // We need to workaround...
2601
2602 #define FILLSZ 0x100000
2603
2604 char *tmp = (char *) mymalloc (FILLSZ);
2605
2606 for (size_t i = 0; i < size; i += FILLSZ)
2607 {
2608 const size_t left = size - i;
2609
2610 const size_t fillsz = MIN (FILLSZ, left);
2611
2612 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2613 }
2614
2615 myfree (tmp);
2616 }
2617 }
2618
2619 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)
2620 {
2621 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2622 {
2623 if (attack_mode == ATTACK_MODE_BF)
2624 {
2625 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2626 {
2627 const uint size_tm = 32 * sizeof (bs_word_t);
2628
2629 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2630
2631 run_kernel_tm (device_param);
2632
2633 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);
2634 }
2635 }
2636
2637 if (highest_pw_len < 16)
2638 {
2639 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2640 }
2641 else if (highest_pw_len < 32)
2642 {
2643 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2644 }
2645 else
2646 {
2647 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2648 }
2649 }
2650 else
2651 {
2652 run_kernel_amp (device_param, pws_cnt);
2653
2654 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2655
2656 if (opts_type & OPTS_TYPE_HOOK12)
2657 {
2658 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2659 }
2660
2661 uint iter = salt_buf->salt_iter;
2662
2663 uint loop_step = device_param->kernel_loops;
2664
2665 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2666 {
2667 uint loop_left = iter - loop_pos;
2668
2669 loop_left = MIN (loop_left, loop_step);
2670
2671 device_param->kernel_params_buf32[25] = loop_pos;
2672 device_param->kernel_params_buf32[26] = loop_left;
2673
2674 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2675
2676 if (data.devices_status == STATUS_CRACKED) break;
2677 if (data.devices_status == STATUS_ABORTED) break;
2678 if (data.devices_status == STATUS_QUIT) break;
2679
2680 /**
2681 * speed
2682 */
2683
2684 const float iter_part = (float) (loop_pos + loop_left) / iter;
2685
2686 const u64 perf_sum_all = pws_cnt * iter_part;
2687
2688 double speed_ms;
2689
2690 hc_timer_get (device_param->timer_speed, speed_ms);
2691
2692 const u32 speed_pos = device_param->speed_pos;
2693
2694 device_param->speed_cnt[speed_pos] = perf_sum_all;
2695
2696 device_param->speed_ms[speed_pos] = speed_ms;
2697
2698 if (data.benchmark == 1)
2699 {
2700 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2701 }
2702 }
2703
2704 if (opts_type & OPTS_TYPE_HOOK23)
2705 {
2706 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2707
2708 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);
2709
2710 // do something with data
2711
2712 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);
2713 }
2714
2715 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2716 }
2717 }
2718
2719 static int run_rule_engine (const int rule_len, const char *rule_buf)
2720 {
2721 if (rule_len == 0)
2722 {
2723 return 0;
2724 }
2725 else if (rule_len == 1)
2726 {
2727 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2728 }
2729
2730 return 1;
2731 }
2732
2733 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2734 {
2735 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2736 {
2737 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);
2738 }
2739 else if (data.attack_kern == ATTACK_KERN_COMBI)
2740 {
2741 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2742 {
2743 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2744 {
2745 for (u32 i = 0; i < pws_cnt; i++)
2746 {
2747 const u32 pw_len = device_param->pws_buf[i].pw_len;
2748
2749 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2750
2751 ptr[pw_len] = 0x01;
2752 }
2753 }
2754 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2755 {
2756 for (u32 i = 0; i < pws_cnt; i++)
2757 {
2758 const u32 pw_len = device_param->pws_buf[i].pw_len;
2759
2760 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2761
2762 ptr[pw_len] = 0x80;
2763 }
2764 }
2765 }
2766
2767 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);
2768 }
2769 else if (data.attack_kern == ATTACK_KERN_BF)
2770 {
2771 const u64 off = device_param->words_off;
2772
2773 device_param->kernel_params_mp_l_buf64[3] = off;
2774
2775 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2776 }
2777 }
2778
2779 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2780 {
2781 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2782
2783 device_param->kernel_params_buf32[25] = 0;
2784 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2785 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2786
2787 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2788 {
2789 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2790 }
2791 else
2792 {
2793 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2794 }
2795
2796 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2797
2798 return exec_ms_prev;
2799 }
2800
2801 static void autotune (hc_device_param_t *device_param)
2802 {
2803 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2804
2805 const u32 kernel_accel_min = device_param->kernel_accel_min;
2806 const u32 kernel_accel_max = device_param->kernel_accel_max;
2807
2808 const u32 kernel_loops_min = device_param->kernel_loops_min;
2809 const u32 kernel_loops_max = device_param->kernel_loops_max;
2810
2811 u32 kernel_accel = kernel_accel_min;
2812 u32 kernel_loops = kernel_loops_min;
2813
2814 // init some fake words
2815
2816 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2817
2818 for (u32 i = 0; i < kernel_power_max; i++)
2819 {
2820 device_param->pws_buf[i].i[0] = i;
2821 device_param->pws_buf[i].i[1] = 0x01234567;
2822 device_param->pws_buf[i].pw_len = 7;
2823 }
2824
2825 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);
2826
2827 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2828 {
2829 run_kernel_amp (device_param, kernel_power_max);
2830 }
2831
2832 // begin actual testing
2833
2834 double exec_ms_final = try_run (device_param, kernel_accel, kernel_loops);
2835
2836 if ((kernel_loops_min == kernel_loops_max) || (kernel_accel_min == kernel_accel_max))
2837 {
2838 // we do this in case the user specified a fixed -u and -n on the commandline
2839 // so we have a cached kernel for benchmark
2840
2841 try_run (device_param, kernel_accel, kernel_loops);
2842 try_run (device_param, kernel_accel, kernel_loops);
2843 try_run (device_param, kernel_accel, kernel_loops);
2844 try_run (device_param, kernel_accel, kernel_loops);
2845 try_run (device_param, kernel_accel, kernel_loops);
2846 }
2847
2848 // first find out highest kernel-loops that stays below target_ms
2849
2850 #define STEPS_CNT 10
2851
2852 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
2853 {
2854 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
2855
2856 if (exec_ms < target_ms) break;
2857 }
2858
2859 // now the same for kernel-accel but with the new kernel-loops from previous loop set
2860
2861 if (kernel_accel_min < kernel_accel_max)
2862 {
2863 for (int i = 0; i < STEPS_CNT; i++)
2864 {
2865 const u32 kernel_accel_try = 1 << i;
2866
2867 if (kernel_accel_try < kernel_accel_min) continue;
2868 if (kernel_accel_try > kernel_accel_max) break;
2869
2870 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
2871
2872 if (exec_ms > target_ms) break;
2873
2874 exec_ms_final = exec_ms;
2875
2876 kernel_accel = kernel_accel_try;
2877 }
2878 }
2879
2880 // there's a chance that we have a fixed kernel_loops but not a fixed kernel_accel
2881 // in such a case the above function would not create any change
2882 // we'll use the runtime to find out if we're allow to do last improvement
2883
2884 if (exec_ms_final > 0)
2885 {
2886 if ((exec_ms_final * 2) <= target_ms)
2887 {
2888 const double exec_left = target_ms / exec_ms_final;
2889
2890 const double accel_left = kernel_accel_max / kernel_accel;
2891
2892 const int exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
2893
2894 if (exec_accel_min >= 2)
2895 {
2896 kernel_accel *= exec_accel_min;
2897 }
2898 }
2899 }
2900
2901 // balancing the workload turns out to be very efficient
2902
2903 const u32 kernel_power_balance = kernel_accel * kernel_loops;
2904
2905 u32 sqrtv;
2906
2907 for (sqrtv = 1; sqrtv < 0x100000; sqrtv++)
2908 {
2909 if ((sqrtv * sqrtv) >= kernel_power_balance) break;
2910 }
2911
2912 const u32 kernel_accel_try = sqrtv;
2913 const u32 kernel_loops_try = sqrtv;
2914
2915 if ((kernel_accel_try <= kernel_accel_max) && (kernel_loops_try >= kernel_loops_min))
2916 {
2917 kernel_accel = kernel_accel_try;
2918 kernel_loops = kernel_loops_try;
2919 }
2920
2921 // reset fake words
2922
2923 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
2924
2925 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);
2926 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);
2927
2928 // reset timer
2929
2930 device_param->exec_pos = 0;
2931
2932 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
2933
2934 // store
2935
2936 device_param->kernel_accel = kernel_accel;
2937 device_param->kernel_loops = kernel_loops;
2938
2939 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2940
2941 device_param->kernel_power = kernel_power;
2942
2943 #ifdef DEBUG
2944
2945 if (data.quiet == 0)
2946 {
2947 clear_prompt ();
2948
2949 log_info ("Device #%u: autotuned kernel-accel to %u\n"
2950 "Device #%u: autotuned kernel-loops to %u\n",
2951 device_param->device_id + 1, kernel_accel,
2952 device_param->device_id + 1, kernel_loops);
2953
2954 fprintf (stdout, "%s", PROMPT);
2955
2956 fflush (stdout);
2957 }
2958
2959 #endif
2960 }
2961
2962 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
2963 {
2964 char *line_buf = (char *) mymalloc (HCBUFSIZ);
2965
2966 // init speed timer
2967
2968 uint speed_pos = device_param->speed_pos;
2969
2970 #ifdef _POSIX
2971 if (device_param->timer_speed.tv_sec == 0)
2972 {
2973 hc_timer_set (&device_param->timer_speed);
2974 }
2975 #endif
2976
2977 #ifdef _WIN
2978 if (device_param->timer_speed.QuadPart == 0)
2979 {
2980 hc_timer_set (&device_param->timer_speed);
2981 }
2982 #endif
2983
2984 // find higest password length, this is for optimization stuff
2985
2986 uint highest_pw_len = 0;
2987
2988 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2989 {
2990 }
2991 else if (data.attack_kern == ATTACK_KERN_COMBI)
2992 {
2993 }
2994 else if (data.attack_kern == ATTACK_KERN_BF)
2995 {
2996 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2997 + device_param->kernel_params_mp_l_buf32[5];
2998 }
2999
3000 // iteration type
3001
3002 uint innerloop_step = 0;
3003 uint innerloop_cnt = 0;
3004
3005 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3006 else innerloop_step = 1;
3007
3008 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3009 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3010 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3011
3012 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3013
3014 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3015 {
3016 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3017
3018 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3019
3020 if (data.devices_status == STATUS_CRACKED) break;
3021 if (data.devices_status == STATUS_ABORTED) break;
3022 if (data.devices_status == STATUS_QUIT) break;
3023 if (data.devices_status == STATUS_BYPASS) break;
3024
3025 salt_t *salt_buf = &data.salts_buf[salt_pos];
3026
3027 device_param->kernel_params_buf32[24] = salt_pos;
3028 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3029 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3030
3031 FILE *combs_fp = device_param->combs_fp;
3032
3033 if (data.attack_mode == ATTACK_MODE_COMBI)
3034 {
3035 rewind (combs_fp);
3036 }
3037
3038 // innerloops
3039
3040 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3041 {
3042 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3043
3044 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3045
3046 if (data.devices_status == STATUS_CRACKED) break;
3047 if (data.devices_status == STATUS_ABORTED) break;
3048 if (data.devices_status == STATUS_QUIT) break;
3049 if (data.devices_status == STATUS_BYPASS) break;
3050
3051 uint innerloop_left = innerloop_cnt - innerloop_pos;
3052
3053 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3054
3055 device_param->innerloop_pos = innerloop_pos;
3056 device_param->innerloop_left = innerloop_left;
3057
3058 device_param->kernel_params_buf32[27] = innerloop_left;
3059
3060 // i think we can get rid of this
3061 if (innerloop_left == 0)
3062 {
3063 puts ("bug, how should this happen????\n");
3064
3065 continue;
3066 }
3067
3068 if (data.salts_shown[salt_pos] == 1)
3069 {
3070 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3071
3072 continue;
3073 }
3074
3075 // initialize amplifiers
3076
3077 if (data.attack_mode == ATTACK_MODE_COMBI)
3078 {
3079 uint i = 0;
3080
3081 while (i < innerloop_left)
3082 {
3083 if (feof (combs_fp)) break;
3084
3085 int line_len = fgetl (combs_fp, line_buf);
3086
3087 if (line_len >= PW_MAX1) continue;
3088
3089 line_len = convert_from_hex (line_buf, line_len);
3090
3091 char *line_buf_new = line_buf;
3092
3093 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3094 {
3095 char rule_buf_out[BLOCK_SIZE] = { 0 };
3096
3097 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3098
3099 if (rule_len_out < 0)
3100 {
3101 data.words_progress_rejected[salt_pos] += pws_cnt;
3102
3103 continue;
3104 }
3105
3106 line_len = rule_len_out;
3107
3108 line_buf_new = rule_buf_out;
3109 }
3110
3111 line_len = MIN (line_len, PW_DICTMAX);
3112
3113 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3114
3115 memcpy (ptr, line_buf_new, line_len);
3116
3117 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3118
3119 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3120 {
3121 uppercase (ptr, line_len);
3122 }
3123
3124 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3125 {
3126 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3127 {
3128 ptr[line_len] = 0x80;
3129 }
3130
3131 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3132 {
3133 ptr[line_len] = 0x01;
3134 }
3135 }
3136
3137 device_param->combs_buf[i].pw_len = line_len;
3138
3139 i++;
3140 }
3141
3142 for (uint j = i; j < innerloop_left; j++)
3143 {
3144 device_param->combs_buf[j].i[0] = 0;
3145 device_param->combs_buf[j].i[1] = 0;
3146 device_param->combs_buf[j].i[2] = 0;
3147 device_param->combs_buf[j].i[3] = 0;
3148 device_param->combs_buf[j].i[4] = 0;
3149 device_param->combs_buf[j].i[5] = 0;
3150 device_param->combs_buf[j].i[6] = 0;
3151 device_param->combs_buf[j].i[7] = 0;
3152
3153 device_param->combs_buf[j].pw_len = 0;
3154 }
3155
3156 innerloop_left = i;
3157 }
3158 else if (data.attack_mode == ATTACK_MODE_BF)
3159 {
3160 u64 off = innerloop_pos;
3161
3162 device_param->kernel_params_mp_r_buf64[3] = off;
3163
3164 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3165 }
3166 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3167 {
3168 u64 off = innerloop_pos;
3169
3170 device_param->kernel_params_mp_buf64[3] = off;
3171
3172 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3173 }
3174 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3175 {
3176 u64 off = innerloop_pos;
3177
3178 device_param->kernel_params_mp_buf64[3] = off;
3179
3180 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3181 }
3182
3183 // copy amplifiers
3184
3185 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3186 {
3187 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);
3188 }
3189 else if (data.attack_mode == ATTACK_MODE_COMBI)
3190 {
3191 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);
3192 }
3193 else if (data.attack_mode == ATTACK_MODE_BF)
3194 {
3195 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);
3196 }
3197 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3198 {
3199 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);
3200 }
3201 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3202 {
3203 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);
3204 }
3205
3206 if (data.benchmark == 1)
3207 {
3208 hc_timer_set (&device_param->timer_speed);
3209 }
3210
3211 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3212
3213 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3214
3215 if (data.devices_status == STATUS_CRACKED) break;
3216 if (data.devices_status == STATUS_ABORTED) break;
3217 if (data.devices_status == STATUS_QUIT) break;
3218
3219 /**
3220 * result
3221 */
3222
3223 hc_thread_mutex_lock (mux_display);
3224
3225 check_cracked (device_param, salt_pos);
3226
3227 hc_thread_mutex_unlock (mux_display);
3228
3229 /**
3230 * progress
3231 */
3232
3233 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3234
3235 hc_thread_mutex_lock (mux_counter);
3236
3237 data.words_progress_done[salt_pos] += perf_sum_all;
3238
3239 hc_thread_mutex_unlock (mux_counter);
3240
3241 /**
3242 * speed
3243 */
3244
3245 double speed_ms;
3246
3247 hc_timer_get (device_param->timer_speed, speed_ms);
3248
3249 hc_timer_set (&device_param->timer_speed);
3250
3251 hc_thread_mutex_lock (mux_display);
3252
3253 // current speed
3254
3255 device_param->speed_cnt[speed_pos] = perf_sum_all;
3256
3257 device_param->speed_ms[speed_pos] = speed_ms;
3258
3259 hc_thread_mutex_unlock (mux_display);
3260
3261 speed_pos++;
3262
3263 if (speed_pos == SPEED_CACHE)
3264 {
3265 speed_pos = 0;
3266 }
3267
3268 /**
3269 * benchmark
3270 */
3271
3272 if (data.benchmark == 1) break;
3273 }
3274 }
3275
3276 device_param->speed_pos = speed_pos;
3277
3278 myfree (line_buf);
3279 }
3280
3281 static void load_segment (wl_data_t *wl_data, FILE *fd)
3282 {
3283 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3284
3285 wl_data->pos = 0;
3286
3287 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3288
3289 wl_data->buf[wl_data->cnt] = 0;
3290
3291 if (wl_data->cnt == 0) return;
3292
3293 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3294
3295 while (!feof (fd))
3296 {
3297 if (wl_data->cnt == wl_data->avail)
3298 {
3299 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3300
3301 wl_data->avail += wl_data->incr;
3302 }
3303
3304 const int c = fgetc (fd);
3305
3306 if (c == EOF) break;
3307
3308 wl_data->buf[wl_data->cnt] = (char) c;
3309
3310 wl_data->cnt++;
3311
3312 if (c == '\n') break;
3313 }
3314
3315 // ensure stream ends with a newline
3316
3317 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3318 {
3319 wl_data->cnt++;
3320
3321 wl_data->buf[wl_data->cnt - 1] = '\n';
3322 }
3323
3324 return;
3325 }
3326
3327 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3328 {
3329 char *ptr = buf;
3330
3331 for (u32 i = 0; i < sz; i++, ptr++)
3332 {
3333 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3334
3335 if (i == 7)
3336 {
3337 *off = i;
3338 *len = i;
3339
3340 return;
3341 }
3342
3343 if (*ptr != '\n') continue;
3344
3345 *off = i + 1;
3346
3347 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3348
3349 *len = i;
3350
3351 return;
3352 }
3353
3354 *off = sz;
3355 *len = sz;
3356 }
3357
3358 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3359 {
3360 char *ptr = buf;
3361
3362 for (u32 i = 0; i < sz; i++, ptr++)
3363 {
3364 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3365
3366 if (*ptr != '\n') continue;
3367
3368 *off = i + 1;
3369
3370 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3371
3372 *len = i;
3373
3374 return;
3375 }
3376
3377 *off = sz;
3378 *len = sz;
3379 }
3380
3381 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3382 {
3383 char *ptr = buf;
3384
3385 for (u32 i = 0; i < sz; i++, ptr++)
3386 {
3387 if (*ptr != '\n') continue;
3388
3389 *off = i + 1;
3390
3391 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3392
3393 *len = i;
3394
3395 return;
3396 }
3397
3398 *off = sz;
3399 *len = sz;
3400 }
3401
3402 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3403 {
3404 while (wl_data->pos < wl_data->cnt)
3405 {
3406 uint off;
3407 uint len;
3408
3409 char *ptr = wl_data->buf + wl_data->pos;
3410
3411 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3412
3413 wl_data->pos += off;
3414
3415 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3416 {
3417 char rule_buf_out[BLOCK_SIZE] = { 0 };
3418
3419 int rule_len_out = -1;
3420
3421 if (len < BLOCK_SIZE)
3422 {
3423 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3424 }
3425
3426 if (rule_len_out < 0)
3427 {
3428 continue;
3429 }
3430
3431 if (rule_len_out > PW_MAX)
3432 {
3433 continue;
3434 }
3435 }
3436 else
3437 {
3438 if (len > PW_MAX)
3439 {
3440 continue;
3441 }
3442 }
3443
3444 *out_buf = ptr;
3445 *out_len = len;
3446
3447 return;
3448 }
3449
3450 if (feof (fd))
3451 {
3452 fprintf (stderr, "BUG feof()!!\n");
3453
3454 return;
3455 }
3456
3457 load_segment (wl_data, fd);
3458
3459 get_next_word (wl_data, fd, out_buf, out_len);
3460 }
3461
3462 #ifdef _POSIX
3463 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3464 #endif
3465
3466 #ifdef _WIN
3467 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3468 #endif
3469 {
3470 hc_signal (NULL);
3471
3472 dictstat_t d;
3473
3474 d.cnt = 0;
3475
3476 #ifdef _POSIX
3477 fstat (fileno (fd), &d.stat);
3478 #endif
3479
3480 #ifdef _WIN
3481 _fstat64 (fileno (fd), &d.stat);
3482 #endif
3483
3484 d.stat.st_mode = 0;
3485 d.stat.st_nlink = 0;
3486 d.stat.st_uid = 0;
3487 d.stat.st_gid = 0;
3488 d.stat.st_rdev = 0;
3489 d.stat.st_atime = 0;
3490
3491 #ifdef _POSIX
3492 d.stat.st_blksize = 0;
3493 d.stat.st_blocks = 0;
3494 #endif
3495
3496 if (d.stat.st_size == 0) return 0;
3497
3498 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3499
3500 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3501 {
3502 if (d_cache)
3503 {
3504 u64 cnt = d_cache->cnt;
3505
3506 u64 keyspace = cnt;
3507
3508 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3509 {
3510 keyspace *= data.kernel_rules_cnt;
3511 }
3512 else if (data.attack_kern == ATTACK_KERN_COMBI)
3513 {
3514 keyspace *= data.combs_cnt;
3515 }
3516
3517 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);
3518 if (data.quiet == 0) log_info ("");
3519
3520 hc_signal (sigHandler_default);
3521
3522 return (keyspace);
3523 }
3524 }
3525
3526 time_t now = 0;
3527 time_t prev = 0;
3528
3529 u64 comp = 0;
3530 u64 cnt = 0;
3531 u64 cnt2 = 0;
3532
3533 while (!feof (fd))
3534 {
3535 load_segment (wl_data, fd);
3536
3537 comp += wl_data->cnt;
3538
3539 u32 i = 0;
3540
3541 while (i < wl_data->cnt)
3542 {
3543 u32 len;
3544 u32 off;
3545
3546 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3547
3548 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3549 {
3550 char rule_buf_out[BLOCK_SIZE] = { 0 };
3551
3552 int rule_len_out = -1;
3553
3554 if (len < BLOCK_SIZE)
3555 {
3556 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3557 }
3558
3559 if (rule_len_out < 0)
3560 {
3561 len = PW_MAX1;
3562 }
3563 else
3564 {
3565 len = rule_len_out;
3566 }
3567 }
3568
3569 if (len < PW_MAX1)
3570 {
3571 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3572 {
3573 cnt += data.kernel_rules_cnt;
3574 }
3575 else if (data.attack_kern == ATTACK_KERN_COMBI)
3576 {
3577 cnt += data.combs_cnt;
3578 }
3579
3580 d.cnt++;
3581 }
3582
3583 i += off;
3584
3585 cnt2++;
3586 }
3587
3588 time (&now);
3589
3590 if ((now - prev) == 0) continue;
3591
3592 float percent = (float) comp / (float) d.stat.st_size;
3593
3594 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);
3595
3596 time (&prev);
3597 }
3598
3599 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);
3600 if (data.quiet == 0) log_info ("");
3601
3602 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3603
3604 hc_signal (sigHandler_default);
3605
3606 return (cnt);
3607 }
3608
3609 static void *thread_monitor (void *p)
3610 {
3611 uint runtime_check = 0;
3612 uint remove_check = 0;
3613 uint status_check = 0;
3614 uint restore_check = 0;
3615
3616 uint restore_left = data.restore_timer;
3617 uint remove_left = data.remove_timer;
3618 uint status_left = data.status_timer;
3619
3620 #ifdef HAVE_HWMON
3621 uint hwmon_check = 0;
3622
3623 // these variables are mainly used for fan control (AMD only)
3624
3625 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3626
3627 // temperature controller "loopback" values
3628
3629 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3630 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3631
3632 #ifdef HAVE_ADL
3633 int temp_threshold = 1; // degrees celcius
3634
3635 int fan_speed_min = 15; // in percentage
3636 int fan_speed_max = 100;
3637 #endif // HAVE_ADL
3638
3639 time_t last_temp_check_time;
3640 #endif // HAVE_HWMON
3641
3642 uint sleep_time = 1;
3643
3644 if (data.runtime)
3645 {
3646 runtime_check = 1;
3647 }
3648
3649 if (data.restore_timer)
3650 {
3651 restore_check = 1;
3652 }
3653
3654 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3655 {
3656 remove_check = 1;
3657 }
3658
3659 if (data.status == 1)
3660 {
3661 status_check = 1;
3662 }
3663
3664 #ifdef HAVE_HWMON
3665 if (data.gpu_temp_disable == 0)
3666 {
3667 time (&last_temp_check_time);
3668
3669 hwmon_check = 1;
3670 }
3671 #endif
3672
3673 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3674 {
3675 #ifdef HAVE_HWMON
3676 if (hwmon_check == 0)
3677 #endif
3678 return (p);
3679 }
3680
3681 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3682 {
3683 hc_sleep (sleep_time);
3684
3685 if (data.devices_status != STATUS_RUNNING) continue;
3686
3687 #ifdef HAVE_HWMON
3688 if (hwmon_check == 1)
3689 {
3690 hc_thread_mutex_lock (mux_adl);
3691
3692 time_t temp_check_time;
3693
3694 time (&temp_check_time);
3695
3696 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3697
3698 if (Ta == 0) Ta = 1;
3699
3700 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3701 {
3702 hc_device_param_t *device_param = &data.devices_param[device_id];
3703
3704 if (device_param->skipped) continue;
3705
3706 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3707
3708 const int temperature = hm_get_temperature_with_device_id (device_id);
3709
3710 if (temperature > (int) data.gpu_temp_abort)
3711 {
3712 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3713
3714 if (data.devices_status != STATUS_QUIT) myabort ();
3715
3716 break;
3717 }
3718
3719 #ifdef HAVE_ADL
3720 const int gpu_temp_retain = data.gpu_temp_retain;
3721
3722 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3723 {
3724 if (data.hm_device[device_id].fan_supported == 1)
3725 {
3726 int temp_cur = temperature;
3727
3728 int temp_diff_new = gpu_temp_retain - temp_cur;
3729
3730 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3731
3732 // calculate Ta value (time difference in seconds between the last check and this check)
3733
3734 last_temp_check_time = temp_check_time;
3735
3736 float Kp = 1.8;
3737 float Ki = 0.005;
3738 float Kd = 6;
3739
3740 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3741
3742 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);
3743
3744 if (abs (fan_diff_required) >= temp_threshold)
3745 {
3746 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3747
3748 int fan_speed_level = fan_speed_cur;
3749
3750 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3751
3752 int fan_speed_new = fan_speed_level - fan_diff_required;
3753
3754 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3755 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3756
3757 if (fan_speed_new != fan_speed_cur)
3758 {
3759 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3760 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3761
3762 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3763 {
3764 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3765
3766 fan_speed_chgd[device_id] = 1;
3767 }
3768
3769 temp_diff_old[device_id] = temp_diff_new;
3770 }
3771 }
3772 }
3773 }
3774 #endif // HAVE_ADL
3775 }
3776
3777 hc_thread_mutex_unlock (mux_adl);
3778 }
3779 #endif // HAVE_HWMON
3780
3781 if (restore_check == 1)
3782 {
3783 restore_left--;
3784
3785 if (restore_left == 0)
3786 {
3787 if (data.restore_disable == 0) cycle_restore ();
3788
3789 restore_left = data.restore_timer;
3790 }
3791 }
3792
3793 if ((runtime_check == 1) && (data.runtime_start > 0))
3794 {
3795 time_t runtime_cur;
3796
3797 time (&runtime_cur);
3798
3799 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3800
3801 if (runtime_left <= 0)
3802 {
3803 if (data.benchmark == 0)
3804 {
3805 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3806 }
3807
3808 if (data.devices_status != STATUS_QUIT) myabort ();
3809 }
3810 }
3811
3812 if (remove_check == 1)
3813 {
3814 remove_left--;
3815
3816 if (remove_left == 0)
3817 {
3818 if (data.digests_saved != data.digests_done)
3819 {
3820 data.digests_saved = data.digests_done;
3821
3822 save_hash ();
3823 }
3824
3825 remove_left = data.remove_timer;
3826 }
3827 }
3828
3829 if (status_check == 1)
3830 {
3831 status_left--;
3832
3833 if (status_left == 0)
3834 {
3835 hc_thread_mutex_lock (mux_display);
3836
3837 if (data.quiet == 0) clear_prompt ();
3838
3839 if (data.quiet == 0) log_info ("");
3840
3841 status_display ();
3842
3843 if (data.quiet == 0) log_info ("");
3844
3845 hc_thread_mutex_unlock (mux_display);
3846
3847 status_left = data.status_timer;
3848 }
3849 }
3850 }
3851
3852 #ifdef HAVE_HWMON
3853 myfree (fan_speed_chgd);
3854
3855 myfree (temp_diff_old);
3856 myfree (temp_diff_sum);
3857 #endif
3858
3859 p = NULL;
3860
3861 return (p);
3862 }
3863
3864 static void *thread_outfile_remove (void *p)
3865 {
3866 // some hash-dependent constants
3867 char *outfile_dir = data.outfile_check_directory;
3868 uint dgst_size = data.dgst_size;
3869 uint isSalted = data.isSalted;
3870 uint esalt_size = data.esalt_size;
3871 uint hash_mode = data.hash_mode;
3872
3873 uint outfile_check_timer = data.outfile_check_timer;
3874
3875 char separator = data.separator;
3876
3877 // some hash-dependent functions
3878 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3879 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3880
3881 // buffers
3882 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3883
3884 hash_buf.digest = mymalloc (dgst_size);
3885
3886 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3887
3888 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3889
3890 uint digest_buf[64] = { 0 };
3891
3892 outfile_data_t *out_info = NULL;
3893
3894 char **out_files = NULL;
3895
3896 time_t folder_mtime = 0;
3897
3898 int out_cnt = 0;
3899
3900 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3901
3902 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3903 {
3904 hc_sleep (1);
3905
3906 if (data.devices_status != STATUS_RUNNING) continue;
3907
3908 check_left--;
3909
3910 if (check_left == 0)
3911 {
3912 struct stat outfile_check_stat;
3913
3914 if (stat (outfile_dir, &outfile_check_stat) == 0)
3915 {
3916 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3917
3918 if (is_dir == 1)
3919 {
3920 if (outfile_check_stat.st_mtime > folder_mtime)
3921 {
3922 char **out_files_new = scan_directory (outfile_dir);
3923
3924 int out_cnt_new = count_dictionaries (out_files_new);
3925
3926 outfile_data_t *out_info_new = NULL;
3927
3928 if (out_cnt_new > 0)
3929 {
3930 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3931
3932 for (int i = 0; i < out_cnt_new; i++)
3933 {
3934 out_info_new[i].file_name = out_files_new[i];
3935
3936 // check if there are files that we have seen/checked before (and not changed)
3937
3938 for (int j = 0; j < out_cnt; j++)
3939 {
3940 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3941 {
3942 struct stat outfile_stat;
3943
3944 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3945 {
3946 if (outfile_stat.st_ctime == out_info[j].ctime)
3947 {
3948 out_info_new[i].ctime = out_info[j].ctime;
3949 out_info_new[i].seek = out_info[j].seek;
3950 }
3951 }
3952 }
3953 }
3954 }
3955 }
3956
3957 local_free (out_info);
3958 local_free (out_files);
3959
3960 out_files = out_files_new;
3961 out_cnt = out_cnt_new;
3962 out_info = out_info_new;
3963
3964 folder_mtime = outfile_check_stat.st_mtime;
3965 }
3966
3967 for (int j = 0; j < out_cnt; j++)
3968 {
3969 FILE *fp = fopen (out_info[j].file_name, "rb");
3970
3971 if (fp != NULL)
3972 {
3973 //hc_thread_mutex_lock (mux_display);
3974
3975 #ifdef _POSIX
3976 struct stat outfile_stat;
3977
3978 fstat (fileno (fp), &outfile_stat);
3979 #endif
3980
3981 #ifdef _WIN
3982 struct stat64 outfile_stat;
3983
3984 _fstat64 (fileno (fp), &outfile_stat);
3985 #endif
3986
3987 if (outfile_stat.st_ctime > out_info[j].ctime)
3988 {
3989 out_info[j].ctime = outfile_stat.st_ctime;
3990 out_info[j].seek = 0;
3991 }
3992
3993 fseek (fp, out_info[j].seek, SEEK_SET);
3994
3995 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3996
3997 while (!feof (fp))
3998 {
3999 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4000
4001 if (ptr == NULL) break;
4002
4003 int line_len = strlen (line_buf);
4004
4005 if (line_len <= 0) continue;
4006
4007 int iter = MAX_CUT_TRIES;
4008
4009 for (uint i = line_len - 1; i && iter; i--, line_len--)
4010 {
4011 if (line_buf[i] != separator) continue;
4012
4013 int parser_status = PARSER_OK;
4014
4015 if ((hash_mode != 2500) && (hash_mode != 6800))
4016 {
4017 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4018 }
4019
4020 uint found = 0;
4021
4022 if (parser_status == PARSER_OK)
4023 {
4024 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4025 {
4026 if (data.salts_shown[salt_pos] == 1) continue;
4027
4028 salt_t *salt_buf = &data.salts_buf[salt_pos];
4029
4030 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4031 {
4032 uint idx = salt_buf->digests_offset + digest_pos;
4033
4034 if (data.digests_shown[idx] == 1) continue;
4035
4036 uint cracked = 0;
4037
4038 if (hash_mode == 6800)
4039 {
4040 if (i == salt_buf->salt_len)
4041 {
4042 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4043 }
4044 }
4045 else if (hash_mode == 2500)
4046 {
4047 // BSSID : MAC1 : MAC2 (:plain)
4048 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4049 {
4050 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4051
4052 if (!cracked) continue;
4053
4054 // now compare MAC1 and MAC2 too, since we have this additional info
4055 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4056 char *mac2_pos = mac1_pos + 12 + 1;
4057
4058 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4059 wpa_t *wpa = &wpas[salt_pos];
4060
4061 // compare hex string(s) vs binary MAC address(es)
4062
4063 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4064 {
4065 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4066 {
4067 cracked = 0;
4068
4069 break;
4070 }
4071 }
4072
4073 // early skip ;)
4074 if (!cracked) continue;
4075
4076 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4077 {
4078 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4079 {
4080 cracked = 0;
4081
4082 break;
4083 }
4084 }
4085 }
4086 }
4087 else
4088 {
4089 char *digests_buf_ptr = (char *) data.digests_buf;
4090
4091 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4092
4093 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4094 }
4095
4096 if (cracked == 1)
4097 {
4098 found = 1;
4099
4100 data.digests_shown[idx] = 1;
4101
4102 data.digests_done++;
4103
4104 salt_buf->digests_done++;
4105
4106 if (salt_buf->digests_done == salt_buf->digests_cnt)
4107 {
4108 data.salts_shown[salt_pos] = 1;
4109
4110 data.salts_done++;
4111
4112 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4113 }
4114 }
4115 }
4116
4117 if (data.devices_status == STATUS_CRACKED) break;
4118 }
4119 }
4120
4121 if (found) break;
4122
4123 if (data.devices_status == STATUS_CRACKED) break;
4124
4125 iter--;
4126 }
4127
4128 if (data.devices_status == STATUS_CRACKED) break;
4129 }
4130
4131 myfree (line_buf);
4132
4133 out_info[j].seek = ftell (fp);
4134
4135 //hc_thread_mutex_unlock (mux_display);
4136
4137 fclose (fp);
4138 }
4139 }
4140 }
4141 }
4142
4143 check_left = outfile_check_timer;
4144 }
4145 }
4146
4147 if (esalt_size) local_free (hash_buf.esalt);
4148
4149 if (isSalted) local_free (hash_buf.salt);
4150
4151 local_free (hash_buf.digest);
4152
4153 local_free (out_info);
4154
4155 local_free (out_files);
4156
4157 p = NULL;
4158
4159 return (p);
4160 }
4161
4162 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4163 {
4164 if (device_param->pws_cnt < device_param->kernel_power)
4165 {
4166 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4167
4168 u8 *ptr = (u8 *) pw->i;
4169
4170 memcpy (ptr, pw_buf, pw_len);
4171
4172 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4173
4174 pw->pw_len = pw_len;
4175
4176 device_param->pws_cnt++;
4177 }
4178 else
4179 {
4180 fprintf (stderr, "BUG pw_add()!!\n");
4181
4182 return;
4183 }
4184 }
4185
4186 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4187 {
4188 hc_thread_mutex_lock (mux_dispatcher);
4189
4190 const u64 words_cur = data.words_cur;
4191 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4192
4193 device_param->words_off = words_cur;
4194
4195 const u64 words_left = words_base - words_cur;
4196
4197 if (allow_div)
4198 {
4199 if (data.kernel_power_all > words_left)
4200 {
4201 if (data.kernel_power_div == 0)
4202 {
4203 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4204 }
4205 }
4206
4207 if (data.kernel_power_div)
4208 {
4209 if (device_param->kernel_power == device_param->kernel_power_user)
4210 {
4211 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4212
4213 if (kernel_power_new < device_param->kernel_power)
4214 {
4215 device_param->kernel_power = kernel_power_new;
4216 }
4217 }
4218 }
4219 }
4220
4221 const uint kernel_power = device_param->kernel_power;
4222
4223 uint work = MIN (words_left, kernel_power);
4224
4225 work = MIN (work, max);
4226
4227 data.words_cur += work;
4228
4229 hc_thread_mutex_unlock (mux_dispatcher);
4230
4231 return work;
4232 }
4233
4234 static void *thread_calc_stdin (void *p)
4235 {
4236 hc_device_param_t *device_param = (hc_device_param_t *) p;
4237
4238 if (device_param->skipped) return NULL;
4239
4240 autotune (device_param);
4241
4242 char *buf = (char *) mymalloc (HCBUFSIZ);
4243
4244 const uint attack_kern = data.attack_kern;
4245
4246 const uint kernel_power = device_param->kernel_power;
4247
4248 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4249 {
4250 hc_thread_mutex_lock (mux_dispatcher);
4251
4252 if (feof (stdin) != 0)
4253 {
4254 hc_thread_mutex_unlock (mux_dispatcher);
4255
4256 break;
4257 }
4258
4259 uint words_cur = 0;
4260
4261 while (words_cur < kernel_power)
4262 {
4263 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4264
4265 if (line_buf == NULL) break;
4266
4267 uint line_len = in_superchop (line_buf);
4268
4269 line_len = convert_from_hex (line_buf, line_len);
4270
4271 // post-process rule engine
4272
4273 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4274 {
4275 char rule_buf_out[BLOCK_SIZE] = { 0 };
4276
4277 int rule_len_out = -1;
4278
4279 if (line_len < BLOCK_SIZE)
4280 {
4281 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4282 }
4283
4284 if (rule_len_out < 0) continue;
4285
4286 line_buf = rule_buf_out;
4287 line_len = rule_len_out;
4288 }
4289
4290 if (line_len > PW_MAX)
4291 {
4292 continue;
4293 }
4294
4295 if (attack_kern == ATTACK_KERN_STRAIGHT)
4296 {
4297 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4298 {
4299 hc_thread_mutex_lock (mux_counter);
4300
4301 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4302 {
4303 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4304 }
4305
4306 hc_thread_mutex_unlock (mux_counter);
4307
4308 continue;
4309 }
4310 }
4311 else if (attack_kern == ATTACK_KERN_COMBI)
4312 {
4313 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4314 // since we still need to combine the plains
4315
4316 if (line_len > data.pw_max)
4317 {
4318 hc_thread_mutex_lock (mux_counter);
4319
4320 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4321 {
4322 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4323 }
4324
4325 hc_thread_mutex_unlock (mux_counter);
4326
4327 continue;
4328 }
4329 }
4330
4331 pw_add (device_param, (u8 *) line_buf, line_len);
4332
4333 words_cur++;
4334
4335 if (data.devices_status == STATUS_CRACKED) break;
4336 if (data.devices_status == STATUS_ABORTED) break;
4337 if (data.devices_status == STATUS_QUIT) break;
4338 if (data.devices_status == STATUS_BYPASS) break;
4339 }
4340
4341 hc_thread_mutex_unlock (mux_dispatcher);
4342
4343 if (data.devices_status == STATUS_CRACKED) break;
4344 if (data.devices_status == STATUS_ABORTED) break;
4345 if (data.devices_status == STATUS_QUIT) break;
4346 if (data.devices_status == STATUS_BYPASS) break;
4347
4348 // flush
4349
4350 const uint pws_cnt = device_param->pws_cnt;
4351
4352 if (pws_cnt)
4353 {
4354 run_copy (device_param, pws_cnt);
4355
4356 run_cracker (device_param, pws_cnt);
4357
4358 device_param->pws_cnt = 0;
4359
4360 if (attack_kern == ATTACK_KERN_STRAIGHT)
4361 {
4362 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4363 }
4364 else if (attack_kern == ATTACK_KERN_COMBI)
4365 {
4366 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4367 }
4368 }
4369 }
4370
4371 device_param->kernel_accel = 0;
4372 device_param->kernel_loops = 0;
4373
4374 myfree (buf);
4375
4376 return NULL;
4377 }
4378
4379 static void *thread_calc (void *p)
4380 {
4381 hc_device_param_t *device_param = (hc_device_param_t *) p;
4382
4383 if (device_param->skipped) return NULL;
4384
4385 autotune (device_param);
4386
4387 const uint attack_mode = data.attack_mode;
4388 const uint attack_kern = data.attack_kern;
4389
4390 if (attack_mode == ATTACK_MODE_BF)
4391 {
4392 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4393 {
4394 const uint work = get_work (device_param, -1, true);
4395
4396 if (work == 0) break;
4397
4398 const u64 words_off = device_param->words_off;
4399 const u64 words_fin = words_off + work;
4400
4401 const uint pws_cnt = work;
4402
4403 device_param->pws_cnt = pws_cnt;
4404
4405 if (pws_cnt)
4406 {
4407 run_copy (device_param, pws_cnt);
4408
4409 run_cracker (device_param, pws_cnt);
4410
4411 device_param->pws_cnt = 0;
4412
4413 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4414 }
4415
4416 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4417
4418 if (data.devices_status == STATUS_CRACKED) break;
4419 if (data.devices_status == STATUS_ABORTED) break;
4420 if (data.devices_status == STATUS_QUIT) break;
4421 if (data.devices_status == STATUS_BYPASS) break;
4422
4423 if (data.benchmark == 1) break;
4424
4425 device_param->words_done = words_fin;
4426 }
4427 }
4428 else
4429 {
4430 const uint segment_size = data.segment_size;
4431
4432 char *dictfile = data.dictfile;
4433
4434 if (attack_mode == ATTACK_MODE_COMBI)
4435 {
4436 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4437 {
4438 dictfile = data.dictfile2;
4439 }
4440 }
4441
4442 FILE *fd = fopen (dictfile, "rb");
4443
4444 if (fd == NULL)
4445 {
4446 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4447
4448 return NULL;
4449 }
4450
4451 if (attack_mode == ATTACK_MODE_COMBI)
4452 {
4453 const uint combs_mode = data.combs_mode;
4454
4455 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4456 {
4457 const char *dictfilec = data.dictfile2;
4458
4459 FILE *combs_fp = fopen (dictfilec, "rb");
4460
4461 if (combs_fp == NULL)
4462 {
4463 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4464
4465 fclose (fd);
4466
4467 return NULL;
4468 }
4469
4470 device_param->combs_fp = combs_fp;
4471 }
4472 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4473 {
4474 const char *dictfilec = data.dictfile;
4475
4476 FILE *combs_fp = fopen (dictfilec, "rb");
4477
4478 if (combs_fp == NULL)
4479 {
4480 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4481
4482 fclose (fd);
4483
4484 return NULL;
4485 }
4486
4487 device_param->combs_fp = combs_fp;
4488 }
4489 }
4490
4491 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4492
4493 wl_data->buf = (char *) mymalloc (segment_size);
4494 wl_data->avail = segment_size;
4495 wl_data->incr = segment_size;
4496 wl_data->cnt = 0;
4497 wl_data->pos = 0;
4498
4499 u64 words_cur = 0;
4500
4501 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4502 {
4503 u64 words_off = 0;
4504 u64 words_fin = 0;
4505
4506 bool allow_div = true;
4507
4508 u64 max = -1;
4509
4510 while (max)
4511 {
4512 const uint work = get_work (device_param, max, allow_div);
4513
4514 allow_div = false;
4515
4516 if (work == 0) break;
4517
4518 words_off = device_param->words_off;
4519 words_fin = words_off + work;
4520
4521 char *line_buf;
4522 uint line_len;
4523
4524 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4525
4526 max = 0;
4527
4528 for ( ; words_cur < words_fin; words_cur++)
4529 {
4530 get_next_word (wl_data, fd, &line_buf, &line_len);
4531
4532 line_len = convert_from_hex (line_buf, line_len);
4533
4534 // post-process rule engine
4535
4536 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4537 {
4538 char rule_buf_out[BLOCK_SIZE] = { 0 };
4539
4540 int rule_len_out = -1;
4541
4542 if (line_len < BLOCK_SIZE)
4543 {
4544 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4545 }
4546
4547 if (rule_len_out < 0) continue;
4548
4549 line_buf = rule_buf_out;
4550 line_len = rule_len_out;
4551 }
4552
4553 if (attack_kern == ATTACK_KERN_STRAIGHT)
4554 {
4555 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4556 {
4557 max++;
4558
4559 hc_thread_mutex_lock (mux_counter);
4560
4561 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4562 {
4563 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4564 }
4565
4566 hc_thread_mutex_unlock (mux_counter);
4567
4568 continue;
4569 }
4570 }
4571 else if (attack_kern == ATTACK_KERN_COMBI)
4572 {
4573 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4574 // since we still need to combine the plains
4575
4576 if (line_len > data.pw_max)
4577 {
4578 max++;
4579
4580 hc_thread_mutex_lock (mux_counter);
4581
4582 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4583 {
4584 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4585 }
4586
4587 hc_thread_mutex_unlock (mux_counter);
4588
4589 continue;
4590 }
4591 }
4592
4593 pw_add (device_param, (u8 *) line_buf, line_len);
4594
4595 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4596
4597 if (data.devices_status == STATUS_CRACKED) break;
4598 if (data.devices_status == STATUS_ABORTED) break;
4599 if (data.devices_status == STATUS_QUIT) break;
4600 if (data.devices_status == STATUS_BYPASS) break;
4601 }
4602
4603 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4604
4605 if (data.devices_status == STATUS_CRACKED) break;
4606 if (data.devices_status == STATUS_ABORTED) break;
4607 if (data.devices_status == STATUS_QUIT) break;
4608 if (data.devices_status == STATUS_BYPASS) break;
4609 }
4610
4611 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4612
4613 if (data.devices_status == STATUS_CRACKED) break;
4614 if (data.devices_status == STATUS_ABORTED) break;
4615 if (data.devices_status == STATUS_QUIT) break;
4616 if (data.devices_status == STATUS_BYPASS) break;
4617
4618 //
4619 // flush
4620 //
4621
4622 const uint pws_cnt = device_param->pws_cnt;
4623
4624 if (pws_cnt)
4625 {
4626 run_copy (device_param, pws_cnt);
4627
4628 run_cracker (device_param, pws_cnt);
4629
4630 device_param->pws_cnt = 0;
4631
4632 if (attack_kern == ATTACK_KERN_STRAIGHT)
4633 {
4634 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4635 }
4636 else if (attack_kern == ATTACK_KERN_COMBI)
4637 {
4638 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4639 }
4640 }
4641
4642 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4643
4644 if (data.devices_status == STATUS_CRACKED) break;
4645 if (data.devices_status == STATUS_ABORTED) break;
4646 if (data.devices_status == STATUS_QUIT) break;
4647 if (data.devices_status == STATUS_BYPASS) break;
4648
4649 if (words_fin == 0) break;
4650
4651 device_param->words_done = words_fin;
4652 }
4653
4654 if (attack_mode == ATTACK_MODE_COMBI)
4655 {
4656 fclose (device_param->combs_fp);
4657 }
4658
4659 free (wl_data->buf);
4660 free (wl_data);
4661
4662 fclose (fd);
4663 }
4664
4665 device_param->kernel_accel = 0;
4666 device_param->kernel_loops = 0;
4667
4668 return NULL;
4669 }
4670
4671 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4672 {
4673 if (!device_param)
4674 {
4675 log_error ("ERROR: %s : Invalid argument", __func__);
4676
4677 exit (-1);
4678 }
4679
4680 salt_t *salt_buf = &data.salts_buf[salt_pos];
4681
4682 device_param->kernel_params_buf32[24] = salt_pos;
4683 device_param->kernel_params_buf32[27] = 1;
4684 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4685 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4686 device_param->kernel_params_buf32[30] = 0;
4687 device_param->kernel_params_buf32[31] = 1;
4688
4689 char *dictfile_old = data.dictfile;
4690
4691 const char *weak_hash_check = "weak-hash-check";
4692
4693 data.dictfile = (char *) weak_hash_check;
4694
4695 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4696
4697 data.kernel_rules_buf[0].cmds[0] = 0;
4698
4699 /**
4700 * run the kernel
4701 */
4702
4703 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4704 {
4705 run_kernel (KERN_RUN_1, device_param, 1, false);
4706 }
4707 else
4708 {
4709 run_kernel (KERN_RUN_1, device_param, 1, false);
4710
4711 uint loop_step = 16;
4712
4713 const uint iter = salt_buf->salt_iter;
4714
4715 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4716 {
4717 uint loop_left = iter - loop_pos;
4718
4719 loop_left = MIN (loop_left, loop_step);
4720
4721 device_param->kernel_params_buf32[25] = loop_pos;
4722 device_param->kernel_params_buf32[26] = loop_left;
4723
4724 run_kernel (KERN_RUN_2, device_param, 1, false);
4725 }
4726
4727 run_kernel (KERN_RUN_3, device_param, 1, false);
4728 }
4729
4730 /**
4731 * result
4732 */
4733
4734 check_cracked (device_param, salt_pos);
4735
4736 /**
4737 * cleanup
4738 */
4739
4740 device_param->kernel_params_buf32[24] = 0;
4741 device_param->kernel_params_buf32[25] = 0;
4742 device_param->kernel_params_buf32[26] = 0;
4743 device_param->kernel_params_buf32[27] = 0;
4744 device_param->kernel_params_buf32[28] = 0;
4745 device_param->kernel_params_buf32[29] = 0;
4746 device_param->kernel_params_buf32[30] = 0;
4747 device_param->kernel_params_buf32[31] = 0;
4748
4749 data.dictfile = dictfile_old;
4750
4751 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4752 }
4753
4754 // hlfmt hashcat
4755
4756 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4757 {
4758 if (data.username == 0)
4759 {
4760 *hashbuf_pos = line_buf;
4761 *hashbuf_len = line_len;
4762 }
4763 else
4764 {
4765 char *pos = line_buf;
4766 int len = line_len;
4767
4768 for (int i = 0; i < line_len; i++, pos++, len--)
4769 {
4770 if (line_buf[i] == data.separator)
4771 {
4772 pos++;
4773
4774 len--;
4775
4776 break;
4777 }
4778 }
4779
4780 *hashbuf_pos = pos;
4781 *hashbuf_len = len;
4782 }
4783 }
4784
4785 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4786 {
4787 char *pos = NULL;
4788 int len = 0;
4789
4790 int sep_cnt = 0;
4791
4792 for (int i = 0; i < line_len; i++)
4793 {
4794 if (line_buf[i] == data.separator)
4795 {
4796 sep_cnt++;
4797
4798 continue;
4799 }
4800
4801 if (sep_cnt == 0)
4802 {
4803 if (pos == NULL) pos = line_buf + i;
4804
4805 len++;
4806 }
4807 }
4808
4809 *userbuf_pos = pos;
4810 *userbuf_len = len;
4811 }
4812
4813 // hlfmt pwdump
4814
4815 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4816 {
4817 int sep_cnt = 0;
4818
4819 int sep2_len = 0;
4820 int sep3_len = 0;
4821
4822 for (int i = 0; i < line_len; i++)
4823 {
4824 if (line_buf[i] == ':')
4825 {
4826 sep_cnt++;
4827
4828 continue;
4829 }
4830
4831 if (sep_cnt == 2) sep2_len++;
4832 if (sep_cnt == 3) sep3_len++;
4833 }
4834
4835 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4836
4837 return 0;
4838 }
4839
4840 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4841 {
4842 char *pos = NULL;
4843 int len = 0;
4844
4845 int sep_cnt = 0;
4846
4847 for (int i = 0; i < line_len; i++)
4848 {
4849 if (line_buf[i] == ':')
4850 {
4851 sep_cnt++;
4852
4853 continue;
4854 }
4855
4856 if (data.hash_mode == 1000)
4857 {
4858 if (sep_cnt == 3)
4859 {
4860 if (pos == NULL) pos = line_buf + i;
4861
4862 len++;
4863 }
4864 }
4865 else if (data.hash_mode == 3000)
4866 {
4867 if (sep_cnt == 2)
4868 {
4869 if (pos == NULL) pos = line_buf + i;
4870
4871 len++;
4872 }
4873 }
4874 }
4875
4876 *hashbuf_pos = pos;
4877 *hashbuf_len = len;
4878 }
4879
4880 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4881 {
4882 char *pos = NULL;
4883 int len = 0;
4884
4885 int sep_cnt = 0;
4886
4887 for (int i = 0; i < line_len; i++)
4888 {
4889 if (line_buf[i] == ':')
4890 {
4891 sep_cnt++;
4892
4893 continue;
4894 }
4895
4896 if (sep_cnt == 0)
4897 {
4898 if (pos == NULL) pos = line_buf + i;
4899
4900 len++;
4901 }
4902 }
4903
4904 *userbuf_pos = pos;
4905 *userbuf_len = len;
4906 }
4907
4908 // hlfmt passwd
4909
4910 static int hlfmt_detect_passwd (char *line_buf, int line_len)
4911 {
4912 int sep_cnt = 0;
4913
4914 char sep5_first = 0;
4915 char sep6_first = 0;
4916
4917 for (int i = 0; i < line_len; i++)
4918 {
4919 if (line_buf[i] == ':')
4920 {
4921 sep_cnt++;
4922
4923 continue;
4924 }
4925
4926 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4927 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4928 }
4929
4930 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4931
4932 return 0;
4933 }
4934
4935 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4936 {
4937 char *pos = NULL;
4938 int len = 0;
4939
4940 int sep_cnt = 0;
4941
4942 for (int i = 0; i < line_len; i++)
4943 {
4944 if (line_buf[i] == ':')
4945 {
4946 sep_cnt++;
4947
4948 continue;
4949 }
4950
4951 if (sep_cnt == 1)
4952 {
4953 if (pos == NULL) pos = line_buf + i;
4954
4955 len++;
4956 }
4957 }
4958
4959 *hashbuf_pos = pos;
4960 *hashbuf_len = len;
4961 }
4962
4963 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4964 {
4965 char *pos = NULL;
4966 int len = 0;
4967
4968 int sep_cnt = 0;
4969
4970 for (int i = 0; i < line_len; i++)
4971 {
4972 if (line_buf[i] == ':')
4973 {
4974 sep_cnt++;
4975
4976 continue;
4977 }
4978
4979 if (sep_cnt == 0)
4980 {
4981 if (pos == NULL) pos = line_buf + i;
4982
4983 len++;
4984 }
4985 }
4986
4987 *userbuf_pos = pos;
4988 *userbuf_len = len;
4989 }
4990
4991 // hlfmt shadow
4992
4993 static int hlfmt_detect_shadow (char *line_buf, int line_len)
4994 {
4995 int sep_cnt = 0;
4996
4997 for (int i = 0; i < line_len; i++)
4998 {
4999 if (line_buf[i] == ':') sep_cnt++;
5000 }
5001
5002 if (sep_cnt == 8) return 1;
5003
5004 return 0;
5005 }
5006
5007 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5008 {
5009 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5010 }
5011
5012 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5013 {
5014 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5015 }
5016
5017 // hlfmt main
5018
5019 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5020 {
5021 switch (hashfile_format)
5022 {
5023 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5024 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5025 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5026 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5027 }
5028 }
5029
5030 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5031 {
5032 switch (hashfile_format)
5033 {
5034 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5035 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5036 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5037 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5038 }
5039 }
5040
5041 char *strhlfmt (const uint hashfile_format)
5042 {
5043 switch (hashfile_format)
5044 {
5045 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5046 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5047 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5048 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5049 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5050 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5051 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5052 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5053 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5054 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5055 }
5056
5057 return ((char *) "Unknown");
5058 }
5059
5060 static uint hlfmt_detect (FILE *fp, uint max_check)
5061 {
5062 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5063
5064 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5065 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5066
5067 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5068
5069 uint num_check = 0;
5070
5071 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5072
5073 while (!feof (fp))
5074 {
5075 int line_len = fgetl (fp, line_buf);
5076
5077 if (line_len == 0) continue;
5078
5079 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5080 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5081 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5082
5083 if (num_check == max_check) break;
5084
5085 num_check++;
5086 }
5087
5088 myfree (line_buf);
5089
5090 uint hashlist_format = HLFMT_HASHCAT;
5091
5092 for (int i = 1; i < HLFMTS_CNT; i++)
5093 {
5094 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5095
5096 hashlist_format = i;
5097 }
5098
5099 free (formats_cnt);
5100
5101 return hashlist_format;
5102 }
5103
5104 /**
5105 * some further helper function
5106 */
5107
5108 // wrapper around mymalloc for ADL
5109
5110 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5111 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5112 {
5113 return mymalloc (iSize);
5114 }
5115 #endif
5116
5117 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)
5118 {
5119 u64 collisions = 0;
5120
5121 const uint dgst_pos0 = data.dgst_pos0;
5122 const uint dgst_pos1 = data.dgst_pos1;
5123 const uint dgst_pos2 = data.dgst_pos2;
5124 const uint dgst_pos3 = data.dgst_pos3;
5125
5126 memset (bitmap_a, 0, bitmap_size);
5127 memset (bitmap_b, 0, bitmap_size);
5128 memset (bitmap_c, 0, bitmap_size);
5129 memset (bitmap_d, 0, bitmap_size);
5130
5131 for (uint i = 0; i < digests_cnt; i++)
5132 {
5133 uint *digest_ptr = (uint *) digests_buf_ptr;
5134
5135 digests_buf_ptr += dgst_size;
5136
5137 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5138 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5139 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5140 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5141
5142 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5143 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5144 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5145 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5146
5147 if (bitmap_a[idx0] & val0) collisions++;
5148 if (bitmap_b[idx1] & val1) collisions++;
5149 if (bitmap_c[idx2] & val2) collisions++;
5150 if (bitmap_d[idx3] & val3) collisions++;
5151
5152 bitmap_a[idx0] |= val0;
5153 bitmap_b[idx1] |= val1;
5154 bitmap_c[idx2] |= val2;
5155 bitmap_d[idx3] |= val3;
5156
5157 if (collisions >= collisions_max) return 0x7fffffff;
5158 }
5159
5160 return collisions;
5161 }
5162
5163 /**
5164 * main
5165 */
5166
5167 int main (int argc, char **argv)
5168 {
5169 /**
5170 * To help users a bit
5171 */
5172
5173 char *compute = getenv ("COMPUTE");
5174
5175 if (compute)
5176 {
5177 static char display[100];
5178
5179 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5180
5181 putenv (display);
5182 }
5183 else
5184 {
5185 if (getenv ("DISPLAY") == NULL)
5186 putenv ((char *) "DISPLAY=:0");
5187 }
5188
5189 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5190 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5191
5192 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5193 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5194
5195 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5196 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5197
5198 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5199 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5200
5201 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5202 putenv ((char *) "POCL_KERNEL_CACHE=0");
5203
5204 /**
5205 * Real init
5206 */
5207
5208 memset (&data, 0, sizeof (hc_global_data_t));
5209
5210 time_t proc_start;
5211
5212 time (&proc_start);
5213
5214 data.proc_start = proc_start;
5215
5216 int myargc = argc;
5217 char **myargv = argv;
5218
5219 hc_thread_mutex_init (mux_dispatcher);
5220 hc_thread_mutex_init (mux_counter);
5221 hc_thread_mutex_init (mux_display);
5222 hc_thread_mutex_init (mux_adl);
5223
5224 /**
5225 * commandline parameters
5226 */
5227
5228 uint usage = USAGE;
5229 uint version = VERSION;
5230 uint quiet = QUIET;
5231 uint benchmark = BENCHMARK;
5232 uint show = SHOW;
5233 uint left = LEFT;
5234 uint username = USERNAME;
5235 uint remove = REMOVE;
5236 uint remove_timer = REMOVE_TIMER;
5237 u64 skip = SKIP;
5238 u64 limit = LIMIT;
5239 uint keyspace = KEYSPACE;
5240 uint potfile_disable = POTFILE_DISABLE;
5241 char *potfile_path = NULL;
5242 uint debug_mode = DEBUG_MODE;
5243 char *debug_file = NULL;
5244 char *induction_dir = NULL;
5245 char *outfile_check_dir = NULL;
5246 uint force = FORCE;
5247 uint runtime = RUNTIME;
5248 uint hash_mode = HASH_MODE;
5249 uint attack_mode = ATTACK_MODE;
5250 uint markov_disable = MARKOV_DISABLE;
5251 uint markov_classic = MARKOV_CLASSIC;
5252 uint markov_threshold = MARKOV_THRESHOLD;
5253 char *markov_hcstat = NULL;
5254 char *outfile = NULL;
5255 uint outfile_format = OUTFILE_FORMAT;
5256 uint outfile_autohex = OUTFILE_AUTOHEX;
5257 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5258 uint restore = RESTORE;
5259 uint restore_timer = RESTORE_TIMER;
5260 uint restore_disable = RESTORE_DISABLE;
5261 uint status = STATUS;
5262 uint status_timer = STATUS_TIMER;
5263 uint status_automat = STATUS_AUTOMAT;
5264 uint loopback = LOOPBACK;
5265 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5266 char *session = NULL;
5267 uint hex_charset = HEX_CHARSET;
5268 uint hex_salt = HEX_SALT;
5269 uint hex_wordlist = HEX_WORDLIST;
5270 uint rp_gen = RP_GEN;
5271 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5272 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5273 uint rp_gen_seed = RP_GEN_SEED;
5274 char *rule_buf_l = (char *) RULE_BUF_L;
5275 char *rule_buf_r = (char *) RULE_BUF_R;
5276 uint increment = INCREMENT;
5277 uint increment_min = INCREMENT_MIN;
5278 uint increment_max = INCREMENT_MAX;
5279 char *cpu_affinity = NULL;
5280 OCL_PTR *ocl = NULL;
5281 char *opencl_devices = NULL;
5282 char *opencl_platforms = NULL;
5283 char *opencl_device_types = NULL;
5284 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5285 char *truecrypt_keyfiles = NULL;
5286 uint workload_profile = WORKLOAD_PROFILE;
5287 uint kernel_accel = KERNEL_ACCEL;
5288 uint kernel_loops = KERNEL_LOOPS;
5289 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5290 #ifdef HAVE_HWMON
5291 uint gpu_temp_abort = GPU_TEMP_ABORT;
5292 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5293 #ifdef HAVE_ADL
5294 uint powertune_enable = POWERTUNE_ENABLE;
5295 #endif
5296 #endif
5297 uint logfile_disable = LOGFILE_DISABLE;
5298 uint segment_size = SEGMENT_SIZE;
5299 uint scrypt_tmto = SCRYPT_TMTO;
5300 char separator = SEPARATOR;
5301 uint bitmap_min = BITMAP_MIN;
5302 uint bitmap_max = BITMAP_MAX;
5303 char *custom_charset_1 = NULL;
5304 char *custom_charset_2 = NULL;
5305 char *custom_charset_3 = NULL;
5306 char *custom_charset_4 = NULL;
5307
5308 #define IDX_HELP 'h'
5309 #define IDX_VERSION 'V'
5310 #define IDX_VERSION_LOWER 'v'
5311 #define IDX_QUIET 0xff02
5312 #define IDX_SHOW 0xff03
5313 #define IDX_LEFT 0xff04
5314 #define IDX_REMOVE 0xff05
5315 #define IDX_REMOVE_TIMER 0xff37
5316 #define IDX_SKIP 's'
5317 #define IDX_LIMIT 'l'
5318 #define IDX_KEYSPACE 0xff35
5319 #define IDX_POTFILE_DISABLE 0xff06
5320 #define IDX_POTFILE_PATH 0xffe0
5321 #define IDX_DEBUG_MODE 0xff43
5322 #define IDX_DEBUG_FILE 0xff44
5323 #define IDX_INDUCTION_DIR 0xff46
5324 #define IDX_OUTFILE_CHECK_DIR 0xff47
5325 #define IDX_USERNAME 0xff07
5326 #define IDX_FORCE 0xff08
5327 #define IDX_RUNTIME 0xff09
5328 #define IDX_BENCHMARK 'b'
5329 #define IDX_HASH_MODE 'm'
5330 #define IDX_ATTACK_MODE 'a'
5331 #define IDX_RP_FILE 'r'
5332 #define IDX_RP_GEN 'g'
5333 #define IDX_RP_GEN_FUNC_MIN 0xff10
5334 #define IDX_RP_GEN_FUNC_MAX 0xff11
5335 #define IDX_RP_GEN_SEED 0xff34
5336 #define IDX_RULE_BUF_L 'j'
5337 #define IDX_RULE_BUF_R 'k'
5338 #define IDX_INCREMENT 'i'
5339 #define IDX_INCREMENT_MIN 0xff12
5340 #define IDX_INCREMENT_MAX 0xff13
5341 #define IDX_OUTFILE 'o'
5342 #define IDX_OUTFILE_FORMAT 0xff14
5343 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5344 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5345 #define IDX_RESTORE 0xff15
5346 #define IDX_RESTORE_DISABLE 0xff27
5347 #define IDX_STATUS 0xff17
5348 #define IDX_STATUS_TIMER 0xff18
5349 #define IDX_STATUS_AUTOMAT 0xff50
5350 #define IDX_LOOPBACK 0xff38
5351 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5352 #define IDX_SESSION 0xff19
5353 #define IDX_HEX_CHARSET 0xff20
5354 #define IDX_HEX_SALT 0xff21
5355 #define IDX_HEX_WORDLIST 0xff40
5356 #define IDX_MARKOV_DISABLE 0xff22
5357 #define IDX_MARKOV_CLASSIC 0xff23
5358 #define IDX_MARKOV_THRESHOLD 't'
5359 #define IDX_MARKOV_HCSTAT 0xff24
5360 #define IDX_CPU_AFFINITY 0xff25
5361 #define IDX_OPENCL_DEVICES 'd'
5362 #define IDX_OPENCL_PLATFORMS 0xff72
5363 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5364 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5365 #define IDX_WORKLOAD_PROFILE 'w'
5366 #define IDX_KERNEL_ACCEL 'n'
5367 #define IDX_KERNEL_LOOPS 'u'
5368 #define IDX_GPU_TEMP_DISABLE 0xff29
5369 #define IDX_GPU_TEMP_ABORT 0xff30
5370 #define IDX_GPU_TEMP_RETAIN 0xff31
5371 #define IDX_POWERTUNE_ENABLE 0xff41
5372 #define IDX_LOGFILE_DISABLE 0xff51
5373 #define IDX_TRUECRYPT_KEYFILES 0xff52
5374 #define IDX_SCRYPT_TMTO 0xff61
5375 #define IDX_SEGMENT_SIZE 'c'
5376 #define IDX_SEPARATOR 'p'
5377 #define IDX_BITMAP_MIN 0xff70
5378 #define IDX_BITMAP_MAX 0xff71
5379 #define IDX_CUSTOM_CHARSET_1 '1'
5380 #define IDX_CUSTOM_CHARSET_2 '2'
5381 #define IDX_CUSTOM_CHARSET_3 '3'
5382 #define IDX_CUSTOM_CHARSET_4 '4'
5383
5384 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5385
5386 struct option long_options[] =
5387 {
5388 {"help", no_argument, 0, IDX_HELP},
5389 {"version", no_argument, 0, IDX_VERSION},
5390 {"quiet", no_argument, 0, IDX_QUIET},
5391 {"show", no_argument, 0, IDX_SHOW},
5392 {"left", no_argument, 0, IDX_LEFT},
5393 {"username", no_argument, 0, IDX_USERNAME},
5394 {"remove", no_argument, 0, IDX_REMOVE},
5395 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5396 {"skip", required_argument, 0, IDX_SKIP},
5397 {"limit", required_argument, 0, IDX_LIMIT},
5398 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5399 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5400 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5401 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5402 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5403 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5404 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5405 {"force", no_argument, 0, IDX_FORCE},
5406 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5407 {"restore", no_argument, 0, IDX_RESTORE},
5408 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5409 {"status", no_argument, 0, IDX_STATUS},
5410 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5411 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5412 {"loopback", no_argument, 0, IDX_LOOPBACK},
5413 {"weak-hash-threshold",
5414 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5415 {"session", required_argument, 0, IDX_SESSION},
5416 {"runtime", required_argument, 0, IDX_RUNTIME},
5417 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5418 {"generate-rules-func-min",
5419 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5420 {"generate-rules-func-max",
5421 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5422 {"generate-rules-seed",
5423 required_argument, 0, IDX_RP_GEN_SEED},
5424 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5425 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5426 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5427 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5428 {"rules-file", required_argument, 0, IDX_RP_FILE},
5429 {"outfile", required_argument, 0, IDX_OUTFILE},
5430 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5431 {"outfile-autohex-disable",
5432 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5433 {"outfile-check-timer",
5434 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5435 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5436 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5437 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5438 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5439 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5440 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5441 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5442 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5443 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5444 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5445 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5446 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5447 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5448 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5449 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5450 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5451 #ifdef HAVE_HWMON
5452 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5453 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5454 #ifdef HAVE_ADL
5455 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5456 #endif
5457 #endif // HAVE_HWMON
5458 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5459 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5460 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5461 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5462 // deprecated
5463 {"seperator", required_argument, 0, IDX_SEPARATOR},
5464 {"separator", required_argument, 0, IDX_SEPARATOR},
5465 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5466 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5467 {"increment", no_argument, 0, IDX_INCREMENT},
5468 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5469 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5470 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5471 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5472 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5473 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5474
5475 {0, 0, 0, 0}
5476 };
5477
5478 uint rp_files_cnt = 0;
5479
5480 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5481
5482 int option_index = 0;
5483 int c = -1;
5484
5485 optind = 1;
5486 optopt = 0;
5487
5488 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5489 {
5490 switch (c)
5491 {
5492 case IDX_HELP: usage = 1; break;
5493 case IDX_VERSION:
5494 case IDX_VERSION_LOWER: version = 1; break;
5495 case IDX_RESTORE: restore = 1; break;
5496 case IDX_SESSION: session = optarg; break;
5497 case IDX_SHOW: show = 1; break;
5498 case IDX_LEFT: left = 1; break;
5499 case '?': return (-1);
5500 }
5501 }
5502
5503 if (optopt != 0)
5504 {
5505 log_error ("ERROR: Invalid argument specified");
5506
5507 return (-1);
5508 }
5509
5510 /**
5511 * exit functions
5512 */
5513
5514 if (version)
5515 {
5516 log_info ("%s", VERSION_TAG);
5517
5518 return (0);
5519 }
5520
5521 if (usage)
5522 {
5523 usage_big_print (PROGNAME);
5524
5525 return (0);
5526 }
5527
5528 /**
5529 * session needs to be set, always!
5530 */
5531
5532 if (session == NULL) session = (char *) PROGNAME;
5533
5534 /**
5535 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5536 */
5537
5538 char *exec_path = get_exec_path ();
5539
5540 #ifdef LINUX
5541
5542 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5543 char *resolved_exec_path = realpath (exec_path, NULL);
5544
5545 char *install_dir = get_install_dir (resolved_exec_path);
5546 char *profile_dir = NULL;
5547 char *session_dir = NULL;
5548 char *shared_dir = NULL;
5549
5550 if (strcmp (install_dir, resolved_install_folder) == 0)
5551 {
5552 struct passwd *pw = getpwuid (getuid ());
5553
5554 const char *homedir = pw->pw_dir;
5555
5556 profile_dir = get_profile_dir (homedir);
5557 session_dir = get_session_dir (profile_dir);
5558 shared_dir = strdup (SHARED_FOLDER);
5559
5560 mkdir (profile_dir, 0700);
5561 mkdir (session_dir, 0700);
5562 }
5563 else
5564 {
5565 profile_dir = install_dir;
5566 session_dir = install_dir;
5567 shared_dir = install_dir;
5568 }
5569
5570 myfree (resolved_install_folder);
5571 myfree (resolved_exec_path);
5572
5573 #else
5574
5575 char *install_dir = get_install_dir (exec_path);
5576 char *profile_dir = install_dir;
5577 char *session_dir = install_dir;
5578 char *shared_dir = install_dir;
5579
5580 #endif
5581
5582 data.install_dir = install_dir;
5583 data.profile_dir = profile_dir;
5584 data.session_dir = session_dir;
5585 data.shared_dir = shared_dir;
5586
5587 myfree (exec_path);
5588
5589 /**
5590 * kernel cache, we need to make sure folder exist
5591 */
5592
5593 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5594
5595 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5596
5597 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5598
5599 mkdir (kernels_folder, 0700);
5600
5601 myfree (kernels_folder);
5602
5603 /**
5604 * session
5605 */
5606
5607 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5608
5609 data.session = session;
5610
5611 char *eff_restore_file = (char *) mymalloc (session_size);
5612 char *new_restore_file = (char *) mymalloc (session_size);
5613
5614 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5615 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5616
5617 data.eff_restore_file = eff_restore_file;
5618 data.new_restore_file = new_restore_file;
5619
5620 if (((show == 1) || (left == 1)) && (restore == 1))
5621 {
5622 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5623 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5624
5625 return (-1);
5626 }
5627
5628 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5629 if ((show == 1) || (left == 1))
5630 {
5631 restore_disable = 1;
5632
5633 restore = 0;
5634 }
5635
5636 data.restore_disable = restore_disable;
5637
5638 restore_data_t *rd = init_restore (argc, argv);
5639
5640 data.rd = rd;
5641
5642 /**
5643 * restore file
5644 */
5645
5646 if (restore == 1)
5647 {
5648 read_restore (eff_restore_file, rd);
5649
5650 if (rd->version_bin < RESTORE_MIN)
5651 {
5652 log_error ("ERROR: Incompatible restore-file version");
5653
5654 return (-1);
5655 }
5656
5657 myargc = rd->argc;
5658 myargv = rd->argv;
5659
5660 #ifdef _POSIX
5661 rd->pid = getpid ();
5662 #elif _WIN
5663 rd->pid = GetCurrentProcessId ();
5664 #endif
5665 }
5666
5667 uint hash_mode_chgd = 0;
5668 uint runtime_chgd = 0;
5669 uint kernel_loops_chgd = 0;
5670 uint kernel_accel_chgd = 0;
5671 uint attack_mode_chgd = 0;
5672 uint outfile_format_chgd = 0;
5673 uint rp_gen_seed_chgd = 0;
5674 uint remove_timer_chgd = 0;
5675 uint increment_min_chgd = 0;
5676 uint increment_max_chgd = 0;
5677 uint workload_profile_chgd = 0;
5678 uint opencl_vector_width_chgd = 0;
5679
5680 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5681 uint gpu_temp_retain_chgd = 0;
5682 uint gpu_temp_abort_chgd = 0;
5683 #endif
5684
5685 optind = 1;
5686 optopt = 0;
5687 option_index = 0;
5688
5689 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5690 {
5691 switch (c)
5692 {
5693 //case IDX_HELP: usage = 1; break;
5694 //case IDX_VERSION: version = 1; break;
5695 //case IDX_RESTORE: restore = 1; break;
5696 case IDX_QUIET: quiet = 1; break;
5697 //case IDX_SHOW: show = 1; break;
5698 case IDX_SHOW: break;
5699 //case IDX_LEFT: left = 1; break;
5700 case IDX_LEFT: break;
5701 case IDX_USERNAME: username = 1; break;
5702 case IDX_REMOVE: remove = 1; break;
5703 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5704 remove_timer_chgd = 1; break;
5705 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5706 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5707 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5708 case IDX_DEBUG_FILE: debug_file = optarg; break;
5709 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5710 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5711 case IDX_FORCE: force = 1; break;
5712 case IDX_SKIP: skip = atoll (optarg); break;
5713 case IDX_LIMIT: limit = atoll (optarg); break;
5714 case IDX_KEYSPACE: keyspace = 1; break;
5715 case IDX_BENCHMARK: benchmark = 1; break;
5716 case IDX_RESTORE: break;
5717 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5718 case IDX_STATUS: status = 1; break;
5719 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5720 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5721 case IDX_LOOPBACK: loopback = 1; break;
5722 case IDX_WEAK_HASH_THRESHOLD:
5723 weak_hash_threshold = atoi (optarg); break;
5724 //case IDX_SESSION: session = optarg; break;
5725 case IDX_SESSION: break;
5726 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5727 hash_mode_chgd = 1; break;
5728 case IDX_RUNTIME: runtime = atoi (optarg);
5729 runtime_chgd = 1; break;
5730 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5731 attack_mode_chgd = 1; break;
5732 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5733 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5734 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5735 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5736 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5737 rp_gen_seed_chgd = 1; break;
5738 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5739 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5740 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5741 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5742 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5743 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5744 case IDX_OUTFILE: outfile = optarg; break;
5745 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5746 outfile_format_chgd = 1; break;
5747 case IDX_OUTFILE_AUTOHEX_DISABLE:
5748 outfile_autohex = 0; break;
5749 case IDX_OUTFILE_CHECK_TIMER:
5750 outfile_check_timer = atoi (optarg); break;
5751 case IDX_HEX_CHARSET: hex_charset = 1; break;
5752 case IDX_HEX_SALT: hex_salt = 1; break;
5753 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5754 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5755 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5756 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5757 case IDX_OPENCL_DEVICE_TYPES:
5758 opencl_device_types = optarg; break;
5759 case IDX_OPENCL_VECTOR_WIDTH:
5760 opencl_vector_width = atoi (optarg);
5761 opencl_vector_width_chgd = 1; break;
5762 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5763 workload_profile_chgd = 1; break;
5764 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5765 kernel_accel_chgd = 1; break;
5766 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5767 kernel_loops_chgd = 1; break;
5768 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5769 #ifdef HAVE_HWMON
5770 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5771 #ifdef HAVE_ADL
5772 gpu_temp_abort_chgd = 1;
5773 #endif
5774 break;
5775 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5776 #ifdef HAVE_ADL
5777 gpu_temp_retain_chgd = 1;
5778 #endif
5779 break;
5780 #ifdef HAVE_ADL
5781 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5782 #endif
5783 #endif // HAVE_HWMON
5784 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5785 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5786 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5787 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5788 case IDX_SEPARATOR: separator = optarg[0]; break;
5789 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5790 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5791 case IDX_INCREMENT: increment = 1; break;
5792 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5793 increment_min_chgd = 1; break;
5794 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5795 increment_max_chgd = 1; break;
5796 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5797 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5798 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5799 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5800
5801 default:
5802 log_error ("ERROR: Invalid argument specified");
5803 return (-1);
5804 }
5805 }
5806
5807 if (optopt != 0)
5808 {
5809 log_error ("ERROR: Invalid argument specified");
5810
5811 return (-1);
5812 }
5813
5814 /**
5815 * Inform user things getting started,
5816 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5817 * - we do not need to check algorithm_pos
5818 */
5819
5820 if (quiet == 0)
5821 {
5822 if (benchmark == 1)
5823 {
5824 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
5825 log_info ("");
5826 }
5827 else if (restore == 1)
5828 {
5829 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
5830 log_info ("");
5831 }
5832 else
5833 {
5834 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
5835 log_info ("");
5836 }
5837 }
5838
5839 /**
5840 * sanity check
5841 */
5842
5843 if (attack_mode > 7)
5844 {
5845 log_error ("ERROR: Invalid attack-mode specified");
5846
5847 return (-1);
5848 }
5849
5850 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5851 {
5852 log_error ("ERROR: Invalid runtime specified");
5853
5854 return (-1);
5855 }
5856
5857 if (hash_mode_chgd && hash_mode > 13600) // just added to remove compiler warnings for hash_mode_chgd
5858 {
5859 log_error ("ERROR: Invalid hash-type specified");
5860
5861 return (-1);
5862 }
5863
5864 // renamed hash modes
5865
5866 if (hash_mode_chgd)
5867 {
5868 int n = -1;
5869
5870 switch (hash_mode)
5871 {
5872 case 123: n = 124;
5873 break;
5874 }
5875
5876 if (n >= 0)
5877 {
5878 log_error ("Old -m specified, use -m %d instead", n);
5879
5880 return (-1);
5881 }
5882 }
5883
5884 if (username == 1)
5885 {
5886 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5887 {
5888 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5889
5890 return (-1);
5891 }
5892 }
5893
5894 if (outfile_format > 16)
5895 {
5896 log_error ("ERROR: Invalid outfile-format specified");
5897
5898 return (-1);
5899 }
5900
5901 if (left == 1)
5902 {
5903 if (outfile_format_chgd == 1)
5904 {
5905 if (outfile_format > 1)
5906 {
5907 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5908
5909 return (-1);
5910 }
5911 }
5912 else
5913 {
5914 outfile_format = OUTFILE_FMT_HASH;
5915 }
5916 }
5917
5918 if (show == 1)
5919 {
5920 if (outfile_format_chgd == 1)
5921 {
5922 if ((outfile_format > 7) && (outfile_format < 16))
5923 {
5924 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5925
5926 return (-1);
5927 }
5928 }
5929 }
5930
5931 if (increment_min < INCREMENT_MIN)
5932 {
5933 log_error ("ERROR: Invalid increment-min specified");
5934
5935 return (-1);
5936 }
5937
5938 if (increment_max > INCREMENT_MAX)
5939 {
5940 log_error ("ERROR: Invalid increment-max specified");
5941
5942 return (-1);
5943 }
5944
5945 if (increment_min > increment_max)
5946 {
5947 log_error ("ERROR: Invalid increment-min specified");
5948
5949 return (-1);
5950 }
5951
5952 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5953 {
5954 log_error ("ERROR: increment is not allowed in attack-mode 0");
5955
5956 return (-1);
5957 }
5958
5959 if ((increment == 0) && (increment_min_chgd == 1))
5960 {
5961 log_error ("ERROR: increment-min is only supported together with increment switch");
5962
5963 return (-1);
5964 }
5965
5966 if ((increment == 0) && (increment_max_chgd == 1))
5967 {
5968 log_error ("ERROR: increment-max is only supported together with increment switch");
5969
5970 return (-1);
5971 }
5972
5973 if (rp_files_cnt && rp_gen)
5974 {
5975 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5976
5977 return (-1);
5978 }
5979
5980 if (rp_files_cnt || rp_gen)
5981 {
5982 if (attack_mode != ATTACK_MODE_STRAIGHT)
5983 {
5984 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5985
5986 return (-1);
5987 }
5988 }
5989
5990 if (rp_gen_func_min > rp_gen_func_max)
5991 {
5992 log_error ("ERROR: Invalid rp-gen-func-min specified");
5993
5994 return (-1);
5995 }
5996
5997 if (kernel_accel_chgd == 1)
5998 {
5999 if (kernel_accel < 1)
6000 {
6001 log_error ("ERROR: Invalid kernel-accel specified");
6002
6003 return (-1);
6004 }
6005
6006 if (kernel_accel > 1024)
6007 {
6008 log_error ("ERROR: Invalid kernel-accel specified");
6009
6010 return (-1);
6011 }
6012 }
6013
6014 if (kernel_loops_chgd == 1)
6015 {
6016 if (kernel_loops < 1)
6017 {
6018 log_error ("ERROR: Invalid kernel-loops specified");
6019
6020 return (-1);
6021 }
6022
6023 if (kernel_loops > 1024)
6024 {
6025 log_error ("ERROR: Invalid kernel-loops specified");
6026
6027 return (-1);
6028 }
6029 }
6030
6031 if ((workload_profile < 1) || (workload_profile > 3))
6032 {
6033 log_error ("ERROR: workload-profile %i not available", workload_profile);
6034
6035 return (-1);
6036 }
6037
6038 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6039 {
6040 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6041
6042 return (-1);
6043 }
6044
6045 if (show == 1 || left == 1)
6046 {
6047 attack_mode = ATTACK_MODE_NONE;
6048
6049 if (remove == 1)
6050 {
6051 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6052
6053 return (-1);
6054 }
6055
6056 if (potfile_disable == 1)
6057 {
6058 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6059
6060 return (-1);
6061 }
6062 }
6063
6064 uint attack_kern = ATTACK_KERN_NONE;
6065
6066 switch (attack_mode)
6067 {
6068 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6069 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6070 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6071 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6072 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6073 }
6074
6075 if (benchmark == 0)
6076 {
6077 if (keyspace == 1)
6078 {
6079 int num_additional_params = 1;
6080
6081 if (attack_kern == ATTACK_KERN_COMBI)
6082 {
6083 num_additional_params = 2;
6084 }
6085
6086 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6087
6088 if (keyspace_wordlist_specified == 0) optind--;
6089 }
6090
6091 if (attack_kern == ATTACK_KERN_NONE)
6092 {
6093 if ((optind + 1) != myargc)
6094 {
6095 usage_mini_print (myargv[0]);
6096
6097 return (-1);
6098 }
6099 }
6100 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6101 {
6102 if ((optind + 1) > myargc)
6103 {
6104 usage_mini_print (myargv[0]);
6105
6106 return (-1);
6107 }
6108 }
6109 else if (attack_kern == ATTACK_KERN_COMBI)
6110 {
6111 if ((optind + 3) != myargc)
6112 {
6113 usage_mini_print (myargv[0]);
6114
6115 return (-1);
6116 }
6117 }
6118 else if (attack_kern == ATTACK_KERN_BF)
6119 {
6120 if ((optind + 1) > myargc)
6121 {
6122 usage_mini_print (myargv[0]);
6123
6124 return (-1);
6125 }
6126 }
6127 else
6128 {
6129 usage_mini_print (myargv[0]);
6130
6131 return (-1);
6132 }
6133 }
6134 else
6135 {
6136 if (myargv[optind] != 0)
6137 {
6138 log_error ("ERROR: Invalid argument for benchmark mode specified");
6139
6140 return (-1);
6141 }
6142
6143 if (attack_mode_chgd == 1)
6144 {
6145 if (attack_mode != ATTACK_MODE_BF)
6146 {
6147 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6148
6149 return (-1);
6150 }
6151 }
6152 }
6153
6154 if (skip != 0 && limit != 0)
6155 {
6156 limit += skip;
6157 }
6158
6159 if (keyspace == 1)
6160 {
6161 if (show == 1)
6162 {
6163 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6164
6165 return (-1);
6166 }
6167 else if (left == 1)
6168 {
6169 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6170
6171 return (-1);
6172 }
6173
6174 potfile_disable = 1;
6175
6176 restore_disable = 1;
6177
6178 restore = 0;
6179
6180 weak_hash_threshold = 0;
6181
6182 quiet = 1;
6183 }
6184
6185 if (remove_timer_chgd == 1)
6186 {
6187 if (remove == 0)
6188 {
6189 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6190
6191 return (-1);
6192 }
6193
6194 if (remove_timer < 1)
6195 {
6196 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6197
6198 return (-1);
6199 }
6200 }
6201
6202 if (loopback == 1)
6203 {
6204 if (attack_mode == ATTACK_MODE_STRAIGHT)
6205 {
6206 if ((rp_files_cnt == 0) && (rp_gen == 0))
6207 {
6208 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6209
6210 return (-1);
6211 }
6212 }
6213 else
6214 {
6215 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6216
6217 return (-1);
6218 }
6219 }
6220
6221 if (debug_mode > 0)
6222 {
6223 if (attack_mode != ATTACK_MODE_STRAIGHT)
6224 {
6225 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6226
6227 return (-1);
6228 }
6229
6230 if ((rp_files_cnt == 0) && (rp_gen == 0))
6231 {
6232 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6233
6234 return (-1);
6235 }
6236 }
6237
6238 if (debug_mode > 4)
6239 {
6240 log_error ("ERROR: Invalid debug-mode specified");
6241
6242 return (-1);
6243 }
6244
6245 if (debug_file != NULL)
6246 {
6247 if (debug_mode < 1)
6248 {
6249 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6250
6251 return (-1);
6252 }
6253 }
6254
6255 if (induction_dir != NULL)
6256 {
6257 if (attack_mode == ATTACK_MODE_BF)
6258 {
6259 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6260
6261 return (-1);
6262 }
6263 }
6264
6265 if (attack_mode != ATTACK_MODE_STRAIGHT)
6266 {
6267 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6268 {
6269 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6270
6271 return (-1);
6272 }
6273
6274 weak_hash_threshold = 0;
6275 }
6276
6277 /**
6278 * induction directory
6279 */
6280
6281 char *induction_directory = NULL;
6282
6283 if (attack_mode != ATTACK_MODE_BF)
6284 {
6285 if (induction_dir == NULL)
6286 {
6287 induction_directory = (char *) mymalloc (session_size);
6288
6289 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6290
6291 // create induction folder if it does not already exist
6292
6293 if (keyspace == 0)
6294 {
6295 if (rmdir (induction_directory) == -1)
6296 {
6297 if (errno == ENOENT)
6298 {
6299 // good, we can ignore
6300 }
6301 else if (errno == ENOTEMPTY)
6302 {
6303 char *induction_directory_mv = (char *) mymalloc (session_size);
6304
6305 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6306
6307 if (rename (induction_directory, induction_directory_mv) != 0)
6308 {
6309 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6310
6311 return (-1);
6312 }
6313 }
6314 else
6315 {
6316 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6317
6318 return (-1);
6319 }
6320 }
6321
6322 if (mkdir (induction_directory, 0700) == -1)
6323 {
6324 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6325
6326 return (-1);
6327 }
6328 }
6329 }
6330 else
6331 {
6332 induction_directory = induction_dir;
6333 }
6334 }
6335
6336 data.induction_directory = induction_directory;
6337
6338 /**
6339 * loopback
6340 */
6341
6342 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6343
6344 char *loopback_file = (char *) mymalloc (loopback_size);
6345
6346 /**
6347 * tuning db
6348 */
6349
6350 char tuning_db_file[256] = { 0 };
6351
6352 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6353
6354 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6355
6356 /**
6357 * outfile-check directory
6358 */
6359
6360 char *outfile_check_directory = NULL;
6361
6362 if (outfile_check_dir == NULL)
6363 {
6364 outfile_check_directory = (char *) mymalloc (session_size);
6365
6366 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6367 }
6368 else
6369 {
6370 outfile_check_directory = outfile_check_dir;
6371 }
6372
6373 data.outfile_check_directory = outfile_check_directory;
6374
6375 if (keyspace == 0)
6376 {
6377 struct stat outfile_check_stat;
6378
6379 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6380 {
6381 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6382
6383 if (is_dir == 0)
6384 {
6385 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6386
6387 return (-1);
6388 }
6389 }
6390 else if (outfile_check_dir == NULL)
6391 {
6392 if (mkdir (outfile_check_directory, 0700) == -1)
6393 {
6394 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6395
6396 return (-1);
6397 }
6398 }
6399 }
6400
6401 /**
6402 * special other stuff
6403 */
6404
6405 if (hash_mode == 9710)
6406 {
6407 outfile_format = 5;
6408 outfile_format_chgd = 1;
6409 }
6410
6411 if (hash_mode == 9810)
6412 {
6413 outfile_format = 5;
6414 outfile_format_chgd = 1;
6415 }
6416
6417 if (hash_mode == 10410)
6418 {
6419 outfile_format = 5;
6420 outfile_format_chgd = 1;
6421 }
6422
6423 /**
6424 * store stuff
6425 */
6426
6427 data.hash_mode = hash_mode;
6428 data.restore = restore;
6429 data.restore_timer = restore_timer;
6430 data.restore_disable = restore_disable;
6431 data.status = status;
6432 data.status_timer = status_timer;
6433 data.status_automat = status_automat;
6434 data.loopback = loopback;
6435 data.runtime = runtime;
6436 data.remove = remove;
6437 data.remove_timer = remove_timer;
6438 data.debug_mode = debug_mode;
6439 data.debug_file = debug_file;
6440 data.username = username;
6441 data.quiet = quiet;
6442 data.outfile = outfile;
6443 data.outfile_format = outfile_format;
6444 data.outfile_autohex = outfile_autohex;
6445 data.hex_charset = hex_charset;
6446 data.hex_salt = hex_salt;
6447 data.hex_wordlist = hex_wordlist;
6448 data.separator = separator;
6449 data.rp_files = rp_files;
6450 data.rp_files_cnt = rp_files_cnt;
6451 data.rp_gen = rp_gen;
6452 data.rp_gen_seed = rp_gen_seed;
6453 data.force = force;
6454 data.benchmark = benchmark;
6455 data.skip = skip;
6456 data.limit = limit;
6457 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6458 data.powertune_enable = powertune_enable;
6459 #endif
6460 data.logfile_disable = logfile_disable;
6461 data.truecrypt_keyfiles = truecrypt_keyfiles;
6462 data.scrypt_tmto = scrypt_tmto;
6463 data.workload_profile = workload_profile;
6464
6465 /**
6466 * cpu affinity
6467 */
6468
6469 if (cpu_affinity)
6470 {
6471 set_cpu_affinity (cpu_affinity);
6472 }
6473
6474 if (rp_gen_seed_chgd == 0)
6475 {
6476 srand (proc_start);
6477 }
6478 else
6479 {
6480 srand (rp_gen_seed);
6481 }
6482
6483 /**
6484 * logfile init
6485 */
6486
6487 if (logfile_disable == 0)
6488 {
6489 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6490
6491 char *logfile = (char *) mymalloc (logfile_size);
6492
6493 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6494
6495 data.logfile = logfile;
6496
6497 char *topid = logfile_generate_topid ();
6498
6499 data.topid = topid;
6500 }
6501
6502 // logfile_append() checks for logfile_disable internally to make it easier from here
6503
6504 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6505 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6506 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6507 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6508 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6509 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6510 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6511 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6512 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6513 #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));
6514
6515 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6516 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6517 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6518 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6519 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6520 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6521 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6522 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6523
6524 logfile_top_msg ("START");
6525
6526 logfile_top_uint (attack_mode);
6527 logfile_top_uint (attack_kern);
6528 logfile_top_uint (benchmark);
6529 logfile_top_uint (bitmap_min);
6530 logfile_top_uint (bitmap_max);
6531 logfile_top_uint (debug_mode);
6532 logfile_top_uint (force);
6533 logfile_top_uint (kernel_accel);
6534 logfile_top_uint (kernel_loops);
6535 logfile_top_uint (gpu_temp_disable);
6536 #ifdef HAVE_HWMON
6537 logfile_top_uint (gpu_temp_abort);
6538 logfile_top_uint (gpu_temp_retain);
6539 #endif
6540 logfile_top_uint (hash_mode);
6541 logfile_top_uint (hex_charset);
6542 logfile_top_uint (hex_salt);
6543 logfile_top_uint (hex_wordlist);
6544 logfile_top_uint (increment);
6545 logfile_top_uint (increment_max);
6546 logfile_top_uint (increment_min);
6547 logfile_top_uint (keyspace);
6548 logfile_top_uint (left);
6549 logfile_top_uint (logfile_disable);
6550 logfile_top_uint (loopback);
6551 logfile_top_uint (markov_classic);
6552 logfile_top_uint (markov_disable);
6553 logfile_top_uint (markov_threshold);
6554 logfile_top_uint (outfile_autohex);
6555 logfile_top_uint (outfile_check_timer);
6556 logfile_top_uint (outfile_format);
6557 logfile_top_uint (potfile_disable);
6558 logfile_top_string (potfile_path);
6559 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6560 logfile_top_uint (powertune_enable);
6561 #endif
6562 logfile_top_uint (scrypt_tmto);
6563 logfile_top_uint (quiet);
6564 logfile_top_uint (remove);
6565 logfile_top_uint (remove_timer);
6566 logfile_top_uint (restore);
6567 logfile_top_uint (restore_disable);
6568 logfile_top_uint (restore_timer);
6569 logfile_top_uint (rp_gen);
6570 logfile_top_uint (rp_gen_func_max);
6571 logfile_top_uint (rp_gen_func_min);
6572 logfile_top_uint (rp_gen_seed);
6573 logfile_top_uint (runtime);
6574 logfile_top_uint (segment_size);
6575 logfile_top_uint (show);
6576 logfile_top_uint (status);
6577 logfile_top_uint (status_automat);
6578 logfile_top_uint (status_timer);
6579 logfile_top_uint (usage);
6580 logfile_top_uint (username);
6581 logfile_top_uint (version);
6582 logfile_top_uint (weak_hash_threshold);
6583 logfile_top_uint (workload_profile);
6584 logfile_top_uint64 (limit);
6585 logfile_top_uint64 (skip);
6586 logfile_top_char (separator);
6587 logfile_top_string (cpu_affinity);
6588 logfile_top_string (custom_charset_1);
6589 logfile_top_string (custom_charset_2);
6590 logfile_top_string (custom_charset_3);
6591 logfile_top_string (custom_charset_4);
6592 logfile_top_string (debug_file);
6593 logfile_top_string (opencl_devices);
6594 logfile_top_string (opencl_platforms);
6595 logfile_top_string (opencl_device_types);
6596 logfile_top_uint (opencl_vector_width);
6597 logfile_top_string (induction_dir);
6598 logfile_top_string (markov_hcstat);
6599 logfile_top_string (outfile);
6600 logfile_top_string (outfile_check_dir);
6601 logfile_top_string (rule_buf_l);
6602 logfile_top_string (rule_buf_r);
6603 logfile_top_string (session);
6604 logfile_top_string (truecrypt_keyfiles);
6605
6606 /**
6607 * Init OpenCL library loader
6608 */
6609
6610 if (keyspace == 0)
6611 {
6612 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6613
6614 ocl_init (ocl);
6615
6616 data.ocl = ocl;
6617 }
6618
6619 /**
6620 * OpenCL platform selection
6621 */
6622
6623 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6624
6625 /**
6626 * OpenCL device selection
6627 */
6628
6629 u32 devices_filter = setup_devices_filter (opencl_devices);
6630
6631 /**
6632 * OpenCL device type selection
6633 */
6634
6635 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6636
6637 /**
6638 * benchmark
6639 */
6640
6641 if (benchmark == 1)
6642 {
6643 /**
6644 * disable useless stuff for benchmark
6645 */
6646
6647 status_timer = 0;
6648 restore_timer = 0;
6649 restore_disable = 1;
6650 potfile_disable = 1;
6651 weak_hash_threshold = 0;
6652 gpu_temp_disable = 1;
6653
6654 data.status_timer = status_timer;
6655 data.restore_timer = restore_timer;
6656 data.restore_disable = restore_disable;
6657
6658 /**
6659 * force attack mode to be bruteforce
6660 */
6661
6662 attack_mode = ATTACK_MODE_BF;
6663 attack_kern = ATTACK_KERN_BF;
6664
6665 if (workload_profile_chgd == 0)
6666 {
6667 workload_profile = 3;
6668
6669 data.workload_profile = workload_profile;
6670 }
6671 }
6672
6673 /**
6674 * config
6675 */
6676
6677 uint hash_type = 0;
6678 uint salt_type = 0;
6679 uint attack_exec = 0;
6680 uint opts_type = 0;
6681 uint kern_type = 0;
6682 uint dgst_size = 0;
6683 uint esalt_size = 0;
6684 uint opti_type = 0;
6685 uint dgst_pos0 = -1;
6686 uint dgst_pos1 = -1;
6687 uint dgst_pos2 = -1;
6688 uint dgst_pos3 = -1;
6689
6690 int (*parse_func) (char *, uint, hash_t *);
6691 int (*sort_by_digest) (const void *, const void *);
6692
6693 uint algorithm_pos = 0;
6694 uint algorithm_max = 1;
6695
6696 uint *algorithms = default_benchmark_algorithms;
6697
6698 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6699
6700 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6701 {
6702 /*
6703 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6704 * the following algos are skipped entirely
6705 */
6706
6707 if (algorithm_pos > 0)
6708 {
6709 local_free (rd);
6710
6711 rd = init_restore (argc, argv);
6712
6713 data.rd = rd;
6714 }
6715
6716 /**
6717 * update hash_mode in case of multihash benchmark
6718 */
6719
6720 if (benchmark == 1)
6721 {
6722 if (hash_mode_chgd == 0)
6723 {
6724 hash_mode = algorithms[algorithm_pos];
6725
6726 data.hash_mode = hash_mode;
6727 }
6728
6729 quiet = 1;
6730
6731 data.quiet = quiet;
6732 }
6733
6734 switch (hash_mode)
6735 {
6736 case 0: hash_type = HASH_TYPE_MD5;
6737 salt_type = SALT_TYPE_NONE;
6738 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6739 opts_type = OPTS_TYPE_PT_GENERATE_LE
6740 | OPTS_TYPE_PT_ADD80
6741 | OPTS_TYPE_PT_ADDBITS14;
6742 kern_type = KERN_TYPE_MD5;
6743 dgst_size = DGST_SIZE_4_4;
6744 parse_func = md5_parse_hash;
6745 sort_by_digest = sort_by_digest_4_4;
6746 opti_type = OPTI_TYPE_ZERO_BYTE
6747 | OPTI_TYPE_PRECOMPUTE_INIT
6748 | OPTI_TYPE_PRECOMPUTE_MERKLE
6749 | OPTI_TYPE_MEET_IN_MIDDLE
6750 | OPTI_TYPE_EARLY_SKIP
6751 | OPTI_TYPE_NOT_ITERATED
6752 | OPTI_TYPE_NOT_SALTED
6753 | OPTI_TYPE_RAW_HASH;
6754 dgst_pos0 = 0;
6755 dgst_pos1 = 3;
6756 dgst_pos2 = 2;
6757 dgst_pos3 = 1;
6758 break;
6759
6760 case 10: hash_type = HASH_TYPE_MD5;
6761 salt_type = SALT_TYPE_INTERN;
6762 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6763 opts_type = OPTS_TYPE_PT_GENERATE_LE
6764 | OPTS_TYPE_ST_ADD80
6765 | OPTS_TYPE_ST_ADDBITS14;
6766 kern_type = KERN_TYPE_MD5_PWSLT;
6767 dgst_size = DGST_SIZE_4_4;
6768 parse_func = md5s_parse_hash;
6769 sort_by_digest = sort_by_digest_4_4;
6770 opti_type = OPTI_TYPE_ZERO_BYTE
6771 | OPTI_TYPE_PRECOMPUTE_INIT
6772 | OPTI_TYPE_PRECOMPUTE_MERKLE
6773 | OPTI_TYPE_MEET_IN_MIDDLE
6774 | OPTI_TYPE_EARLY_SKIP
6775 | OPTI_TYPE_NOT_ITERATED
6776 | OPTI_TYPE_APPENDED_SALT
6777 | OPTI_TYPE_RAW_HASH;
6778 dgst_pos0 = 0;
6779 dgst_pos1 = 3;
6780 dgst_pos2 = 2;
6781 dgst_pos3 = 1;
6782 break;
6783
6784 case 11: hash_type = HASH_TYPE_MD5;
6785 salt_type = SALT_TYPE_INTERN;
6786 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6787 opts_type = OPTS_TYPE_PT_GENERATE_LE
6788 | OPTS_TYPE_ST_ADD80
6789 | OPTS_TYPE_ST_ADDBITS14;
6790 kern_type = KERN_TYPE_MD5_PWSLT;
6791 dgst_size = DGST_SIZE_4_4;
6792 parse_func = joomla_parse_hash;
6793 sort_by_digest = sort_by_digest_4_4;
6794 opti_type = OPTI_TYPE_ZERO_BYTE
6795 | OPTI_TYPE_PRECOMPUTE_INIT
6796 | OPTI_TYPE_PRECOMPUTE_MERKLE
6797 | OPTI_TYPE_MEET_IN_MIDDLE
6798 | OPTI_TYPE_EARLY_SKIP
6799 | OPTI_TYPE_NOT_ITERATED
6800 | OPTI_TYPE_APPENDED_SALT
6801 | OPTI_TYPE_RAW_HASH;
6802 dgst_pos0 = 0;
6803 dgst_pos1 = 3;
6804 dgst_pos2 = 2;
6805 dgst_pos3 = 1;
6806 break;
6807
6808 case 12: hash_type = HASH_TYPE_MD5;
6809 salt_type = SALT_TYPE_INTERN;
6810 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6811 opts_type = OPTS_TYPE_PT_GENERATE_LE
6812 | OPTS_TYPE_ST_ADD80
6813 | OPTS_TYPE_ST_ADDBITS14;
6814 kern_type = KERN_TYPE_MD5_PWSLT;
6815 dgst_size = DGST_SIZE_4_4;
6816 parse_func = postgresql_parse_hash;
6817 sort_by_digest = sort_by_digest_4_4;
6818 opti_type = OPTI_TYPE_ZERO_BYTE
6819 | OPTI_TYPE_PRECOMPUTE_INIT
6820 | OPTI_TYPE_PRECOMPUTE_MERKLE
6821 | OPTI_TYPE_MEET_IN_MIDDLE
6822 | OPTI_TYPE_EARLY_SKIP
6823 | OPTI_TYPE_NOT_ITERATED
6824 | OPTI_TYPE_APPENDED_SALT
6825 | OPTI_TYPE_RAW_HASH;
6826 dgst_pos0 = 0;
6827 dgst_pos1 = 3;
6828 dgst_pos2 = 2;
6829 dgst_pos3 = 1;
6830 break;
6831
6832 case 20: hash_type = HASH_TYPE_MD5;
6833 salt_type = SALT_TYPE_INTERN;
6834 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6835 opts_type = OPTS_TYPE_PT_GENERATE_LE
6836 | OPTS_TYPE_PT_ADD80
6837 | OPTS_TYPE_PT_ADDBITS14;
6838 kern_type = KERN_TYPE_MD5_SLTPW;
6839 dgst_size = DGST_SIZE_4_4;
6840 parse_func = md5s_parse_hash;
6841 sort_by_digest = sort_by_digest_4_4;
6842 opti_type = OPTI_TYPE_ZERO_BYTE
6843 | OPTI_TYPE_PRECOMPUTE_INIT
6844 | OPTI_TYPE_PRECOMPUTE_MERKLE
6845 | OPTI_TYPE_EARLY_SKIP
6846 | OPTI_TYPE_NOT_ITERATED
6847 | OPTI_TYPE_PREPENDED_SALT
6848 | OPTI_TYPE_RAW_HASH;
6849 dgst_pos0 = 0;
6850 dgst_pos1 = 3;
6851 dgst_pos2 = 2;
6852 dgst_pos3 = 1;
6853 break;
6854
6855 case 21: hash_type = HASH_TYPE_MD5;
6856 salt_type = SALT_TYPE_INTERN;
6857 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6858 opts_type = OPTS_TYPE_PT_GENERATE_LE
6859 | OPTS_TYPE_PT_ADD80
6860 | OPTS_TYPE_PT_ADDBITS14;
6861 kern_type = KERN_TYPE_MD5_SLTPW;
6862 dgst_size = DGST_SIZE_4_4;
6863 parse_func = osc_parse_hash;
6864 sort_by_digest = sort_by_digest_4_4;
6865 opti_type = OPTI_TYPE_ZERO_BYTE
6866 | OPTI_TYPE_PRECOMPUTE_INIT
6867 | OPTI_TYPE_PRECOMPUTE_MERKLE
6868 | OPTI_TYPE_EARLY_SKIP
6869 | OPTI_TYPE_NOT_ITERATED
6870 | OPTI_TYPE_PREPENDED_SALT
6871 | OPTI_TYPE_RAW_HASH;
6872 dgst_pos0 = 0;
6873 dgst_pos1 = 3;
6874 dgst_pos2 = 2;
6875 dgst_pos3 = 1;
6876 break;
6877
6878 case 22: hash_type = HASH_TYPE_MD5;
6879 salt_type = SALT_TYPE_EMBEDDED;
6880 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6881 opts_type = OPTS_TYPE_PT_GENERATE_LE
6882 | OPTS_TYPE_PT_ADD80
6883 | OPTS_TYPE_PT_ADDBITS14;
6884 kern_type = KERN_TYPE_MD5_SLTPW;
6885 dgst_size = DGST_SIZE_4_4;
6886 parse_func = netscreen_parse_hash;
6887 sort_by_digest = sort_by_digest_4_4;
6888 opti_type = OPTI_TYPE_ZERO_BYTE
6889 | OPTI_TYPE_PRECOMPUTE_INIT
6890 | OPTI_TYPE_PRECOMPUTE_MERKLE
6891 | OPTI_TYPE_EARLY_SKIP
6892 | OPTI_TYPE_NOT_ITERATED
6893 | OPTI_TYPE_PREPENDED_SALT
6894 | OPTI_TYPE_RAW_HASH;
6895 dgst_pos0 = 0;
6896 dgst_pos1 = 3;
6897 dgst_pos2 = 2;
6898 dgst_pos3 = 1;
6899 break;
6900
6901 case 23: hash_type = HASH_TYPE_MD5;
6902 salt_type = SALT_TYPE_EMBEDDED;
6903 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6904 opts_type = OPTS_TYPE_PT_GENERATE_LE
6905 | OPTS_TYPE_PT_ADD80
6906 | OPTS_TYPE_PT_ADDBITS14;
6907 kern_type = KERN_TYPE_MD5_SLTPW;
6908 dgst_size = DGST_SIZE_4_4;
6909 parse_func = skype_parse_hash;
6910 sort_by_digest = sort_by_digest_4_4;
6911 opti_type = OPTI_TYPE_ZERO_BYTE
6912 | OPTI_TYPE_PRECOMPUTE_INIT
6913 | OPTI_TYPE_PRECOMPUTE_MERKLE
6914 | OPTI_TYPE_EARLY_SKIP
6915 | OPTI_TYPE_NOT_ITERATED
6916 | OPTI_TYPE_PREPENDED_SALT
6917 | OPTI_TYPE_RAW_HASH;
6918 dgst_pos0 = 0;
6919 dgst_pos1 = 3;
6920 dgst_pos2 = 2;
6921 dgst_pos3 = 1;
6922 break;
6923
6924 case 30: hash_type = HASH_TYPE_MD5;
6925 salt_type = SALT_TYPE_INTERN;
6926 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6927 opts_type = OPTS_TYPE_PT_GENERATE_LE
6928 | OPTS_TYPE_PT_UNICODE
6929 | OPTS_TYPE_ST_ADD80
6930 | OPTS_TYPE_ST_ADDBITS14;
6931 kern_type = KERN_TYPE_MD5_PWUSLT;
6932 dgst_size = DGST_SIZE_4_4;
6933 parse_func = md5s_parse_hash;
6934 sort_by_digest = sort_by_digest_4_4;
6935 opti_type = OPTI_TYPE_ZERO_BYTE
6936 | OPTI_TYPE_PRECOMPUTE_INIT
6937 | OPTI_TYPE_PRECOMPUTE_MERKLE
6938 | OPTI_TYPE_MEET_IN_MIDDLE
6939 | OPTI_TYPE_EARLY_SKIP
6940 | OPTI_TYPE_NOT_ITERATED
6941 | OPTI_TYPE_APPENDED_SALT
6942 | OPTI_TYPE_RAW_HASH;
6943 dgst_pos0 = 0;
6944 dgst_pos1 = 3;
6945 dgst_pos2 = 2;
6946 dgst_pos3 = 1;
6947 break;
6948
6949 case 40: hash_type = HASH_TYPE_MD5;
6950 salt_type = SALT_TYPE_INTERN;
6951 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6952 opts_type = OPTS_TYPE_PT_GENERATE_LE
6953 | OPTS_TYPE_PT_ADD80
6954 | OPTS_TYPE_PT_ADDBITS14
6955 | OPTS_TYPE_PT_UNICODE;
6956 kern_type = KERN_TYPE_MD5_SLTPWU;
6957 dgst_size = DGST_SIZE_4_4;
6958 parse_func = md5s_parse_hash;
6959 sort_by_digest = sort_by_digest_4_4;
6960 opti_type = OPTI_TYPE_ZERO_BYTE
6961 | OPTI_TYPE_PRECOMPUTE_INIT
6962 | OPTI_TYPE_PRECOMPUTE_MERKLE
6963 | OPTI_TYPE_EARLY_SKIP
6964 | OPTI_TYPE_NOT_ITERATED
6965 | OPTI_TYPE_PREPENDED_SALT
6966 | OPTI_TYPE_RAW_HASH;
6967 dgst_pos0 = 0;
6968 dgst_pos1 = 3;
6969 dgst_pos2 = 2;
6970 dgst_pos3 = 1;
6971 break;
6972
6973 case 50: hash_type = HASH_TYPE_MD5;
6974 salt_type = SALT_TYPE_INTERN;
6975 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6976 opts_type = OPTS_TYPE_PT_GENERATE_LE
6977 | OPTS_TYPE_ST_ADD80
6978 | OPTS_TYPE_ST_ADDBITS14;
6979 kern_type = KERN_TYPE_HMACMD5_PW;
6980 dgst_size = DGST_SIZE_4_4;
6981 parse_func = hmacmd5_parse_hash;
6982 sort_by_digest = sort_by_digest_4_4;
6983 opti_type = OPTI_TYPE_ZERO_BYTE
6984 | OPTI_TYPE_NOT_ITERATED;
6985 dgst_pos0 = 0;
6986 dgst_pos1 = 3;
6987 dgst_pos2 = 2;
6988 dgst_pos3 = 1;
6989 break;
6990
6991 case 60: hash_type = HASH_TYPE_MD5;
6992 salt_type = SALT_TYPE_INTERN;
6993 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6994 opts_type = OPTS_TYPE_PT_GENERATE_LE
6995 | OPTS_TYPE_PT_ADD80
6996 | OPTS_TYPE_PT_ADDBITS14;
6997 kern_type = KERN_TYPE_HMACMD5_SLT;
6998 dgst_size = DGST_SIZE_4_4;
6999 parse_func = hmacmd5_parse_hash;
7000 sort_by_digest = sort_by_digest_4_4;
7001 opti_type = OPTI_TYPE_ZERO_BYTE
7002 | OPTI_TYPE_NOT_ITERATED;
7003 dgst_pos0 = 0;
7004 dgst_pos1 = 3;
7005 dgst_pos2 = 2;
7006 dgst_pos3 = 1;
7007 break;
7008
7009 case 100: hash_type = HASH_TYPE_SHA1;
7010 salt_type = SALT_TYPE_NONE;
7011 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7012 opts_type = OPTS_TYPE_PT_GENERATE_BE
7013 | OPTS_TYPE_PT_ADD80
7014 | OPTS_TYPE_PT_ADDBITS15;
7015 kern_type = KERN_TYPE_SHA1;
7016 dgst_size = DGST_SIZE_4_5;
7017 parse_func = sha1_parse_hash;
7018 sort_by_digest = sort_by_digest_4_5;
7019 opti_type = OPTI_TYPE_ZERO_BYTE
7020 | OPTI_TYPE_PRECOMPUTE_INIT
7021 | OPTI_TYPE_PRECOMPUTE_MERKLE
7022 | OPTI_TYPE_EARLY_SKIP
7023 | OPTI_TYPE_NOT_ITERATED
7024 | OPTI_TYPE_NOT_SALTED
7025 | OPTI_TYPE_RAW_HASH;
7026 dgst_pos0 = 3;
7027 dgst_pos1 = 4;
7028 dgst_pos2 = 2;
7029 dgst_pos3 = 1;
7030 break;
7031
7032 case 101: hash_type = HASH_TYPE_SHA1;
7033 salt_type = SALT_TYPE_NONE;
7034 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7035 opts_type = OPTS_TYPE_PT_GENERATE_BE
7036 | OPTS_TYPE_PT_ADD80
7037 | OPTS_TYPE_PT_ADDBITS15;
7038 kern_type = KERN_TYPE_SHA1;
7039 dgst_size = DGST_SIZE_4_5;
7040 parse_func = sha1b64_parse_hash;
7041 sort_by_digest = sort_by_digest_4_5;
7042 opti_type = OPTI_TYPE_ZERO_BYTE
7043 | OPTI_TYPE_PRECOMPUTE_INIT
7044 | OPTI_TYPE_PRECOMPUTE_MERKLE
7045 | OPTI_TYPE_EARLY_SKIP
7046 | OPTI_TYPE_NOT_ITERATED
7047 | OPTI_TYPE_NOT_SALTED
7048 | OPTI_TYPE_RAW_HASH;
7049 dgst_pos0 = 3;
7050 dgst_pos1 = 4;
7051 dgst_pos2 = 2;
7052 dgst_pos3 = 1;
7053 break;
7054
7055 case 110: hash_type = HASH_TYPE_SHA1;
7056 salt_type = SALT_TYPE_INTERN;
7057 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7058 opts_type = OPTS_TYPE_PT_GENERATE_BE
7059 | OPTS_TYPE_ST_ADD80
7060 | OPTS_TYPE_ST_ADDBITS15;
7061 kern_type = KERN_TYPE_SHA1_PWSLT;
7062 dgst_size = DGST_SIZE_4_5;
7063 parse_func = sha1s_parse_hash;
7064 sort_by_digest = sort_by_digest_4_5;
7065 opti_type = OPTI_TYPE_ZERO_BYTE
7066 | OPTI_TYPE_PRECOMPUTE_INIT
7067 | OPTI_TYPE_PRECOMPUTE_MERKLE
7068 | OPTI_TYPE_EARLY_SKIP
7069 | OPTI_TYPE_NOT_ITERATED
7070 | OPTI_TYPE_APPENDED_SALT
7071 | OPTI_TYPE_RAW_HASH;
7072 dgst_pos0 = 3;
7073 dgst_pos1 = 4;
7074 dgst_pos2 = 2;
7075 dgst_pos3 = 1;
7076 break;
7077
7078 case 111: hash_type = HASH_TYPE_SHA1;
7079 salt_type = SALT_TYPE_EMBEDDED;
7080 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7081 opts_type = OPTS_TYPE_PT_GENERATE_BE
7082 | OPTS_TYPE_ST_ADD80
7083 | OPTS_TYPE_ST_ADDBITS15;
7084 kern_type = KERN_TYPE_SHA1_PWSLT;
7085 dgst_size = DGST_SIZE_4_5;
7086 parse_func = sha1b64s_parse_hash;
7087 sort_by_digest = sort_by_digest_4_5;
7088 opti_type = OPTI_TYPE_ZERO_BYTE
7089 | OPTI_TYPE_PRECOMPUTE_INIT
7090 | OPTI_TYPE_PRECOMPUTE_MERKLE
7091 | OPTI_TYPE_EARLY_SKIP
7092 | OPTI_TYPE_NOT_ITERATED
7093 | OPTI_TYPE_APPENDED_SALT
7094 | OPTI_TYPE_RAW_HASH;
7095 dgst_pos0 = 3;
7096 dgst_pos1 = 4;
7097 dgst_pos2 = 2;
7098 dgst_pos3 = 1;
7099 break;
7100
7101 case 112: hash_type = HASH_TYPE_SHA1;
7102 salt_type = SALT_TYPE_INTERN;
7103 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7104 opts_type = OPTS_TYPE_PT_GENERATE_BE
7105 | OPTS_TYPE_ST_ADD80
7106 | OPTS_TYPE_ST_ADDBITS15
7107 | OPTS_TYPE_ST_HEX;
7108 kern_type = KERN_TYPE_SHA1_PWSLT;
7109 dgst_size = DGST_SIZE_4_5;
7110 parse_func = oracles_parse_hash;
7111 sort_by_digest = sort_by_digest_4_5;
7112 opti_type = OPTI_TYPE_ZERO_BYTE
7113 | OPTI_TYPE_PRECOMPUTE_INIT
7114 | OPTI_TYPE_PRECOMPUTE_MERKLE
7115 | OPTI_TYPE_EARLY_SKIP
7116 | OPTI_TYPE_NOT_ITERATED
7117 | OPTI_TYPE_APPENDED_SALT
7118 | OPTI_TYPE_RAW_HASH;
7119 dgst_pos0 = 3;
7120 dgst_pos1 = 4;
7121 dgst_pos2 = 2;
7122 dgst_pos3 = 1;
7123 break;
7124
7125 case 120: hash_type = HASH_TYPE_SHA1;
7126 salt_type = SALT_TYPE_INTERN;
7127 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7128 opts_type = OPTS_TYPE_PT_GENERATE_BE
7129 | OPTS_TYPE_PT_ADD80
7130 | OPTS_TYPE_PT_ADDBITS15;
7131 kern_type = KERN_TYPE_SHA1_SLTPW;
7132 dgst_size = DGST_SIZE_4_5;
7133 parse_func = sha1s_parse_hash;
7134 sort_by_digest = sort_by_digest_4_5;
7135 opti_type = OPTI_TYPE_ZERO_BYTE
7136 | OPTI_TYPE_PRECOMPUTE_INIT
7137 | OPTI_TYPE_PRECOMPUTE_MERKLE
7138 | OPTI_TYPE_EARLY_SKIP
7139 | OPTI_TYPE_NOT_ITERATED
7140 | OPTI_TYPE_PREPENDED_SALT
7141 | OPTI_TYPE_RAW_HASH;
7142 dgst_pos0 = 3;
7143 dgst_pos1 = 4;
7144 dgst_pos2 = 2;
7145 dgst_pos3 = 1;
7146 break;
7147
7148 case 121: hash_type = HASH_TYPE_SHA1;
7149 salt_type = SALT_TYPE_INTERN;
7150 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7151 opts_type = OPTS_TYPE_PT_GENERATE_BE
7152 | OPTS_TYPE_PT_ADD80
7153 | OPTS_TYPE_PT_ADDBITS15
7154 | OPTS_TYPE_ST_LOWER;
7155 kern_type = KERN_TYPE_SHA1_SLTPW;
7156 dgst_size = DGST_SIZE_4_5;
7157 parse_func = smf_parse_hash;
7158 sort_by_digest = sort_by_digest_4_5;
7159 opti_type = OPTI_TYPE_ZERO_BYTE
7160 | OPTI_TYPE_PRECOMPUTE_INIT
7161 | OPTI_TYPE_PRECOMPUTE_MERKLE
7162 | OPTI_TYPE_EARLY_SKIP
7163 | OPTI_TYPE_NOT_ITERATED
7164 | OPTI_TYPE_PREPENDED_SALT
7165 | OPTI_TYPE_RAW_HASH;
7166 dgst_pos0 = 3;
7167 dgst_pos1 = 4;
7168 dgst_pos2 = 2;
7169 dgst_pos3 = 1;
7170 break;
7171
7172 case 122: hash_type = HASH_TYPE_SHA1;
7173 salt_type = SALT_TYPE_EMBEDDED;
7174 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7175 opts_type = OPTS_TYPE_PT_GENERATE_BE
7176 | OPTS_TYPE_PT_ADD80
7177 | OPTS_TYPE_PT_ADDBITS15
7178 | OPTS_TYPE_ST_HEX;
7179 kern_type = KERN_TYPE_SHA1_SLTPW;
7180 dgst_size = DGST_SIZE_4_5;
7181 parse_func = osx1_parse_hash;
7182 sort_by_digest = sort_by_digest_4_5;
7183 opti_type = OPTI_TYPE_ZERO_BYTE
7184 | OPTI_TYPE_PRECOMPUTE_INIT
7185 | OPTI_TYPE_PRECOMPUTE_MERKLE
7186 | OPTI_TYPE_EARLY_SKIP
7187 | OPTI_TYPE_NOT_ITERATED
7188 | OPTI_TYPE_PREPENDED_SALT
7189 | OPTI_TYPE_RAW_HASH;
7190 dgst_pos0 = 3;
7191 dgst_pos1 = 4;
7192 dgst_pos2 = 2;
7193 dgst_pos3 = 1;
7194 break;
7195
7196 case 124: hash_type = HASH_TYPE_SHA1;
7197 salt_type = SALT_TYPE_EMBEDDED;
7198 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7199 opts_type = OPTS_TYPE_PT_GENERATE_BE
7200 | OPTS_TYPE_PT_ADD80
7201 | OPTS_TYPE_PT_ADDBITS15;
7202 kern_type = KERN_TYPE_SHA1_SLTPW;
7203 dgst_size = DGST_SIZE_4_5;
7204 parse_func = djangosha1_parse_hash;
7205 sort_by_digest = sort_by_digest_4_5;
7206 opti_type = OPTI_TYPE_ZERO_BYTE
7207 | OPTI_TYPE_PRECOMPUTE_INIT
7208 | OPTI_TYPE_PRECOMPUTE_MERKLE
7209 | OPTI_TYPE_EARLY_SKIP
7210 | OPTI_TYPE_NOT_ITERATED
7211 | OPTI_TYPE_PREPENDED_SALT
7212 | OPTI_TYPE_RAW_HASH;
7213 dgst_pos0 = 3;
7214 dgst_pos1 = 4;
7215 dgst_pos2 = 2;
7216 dgst_pos3 = 1;
7217 break;
7218
7219 case 125: hash_type = HASH_TYPE_SHA1;
7220 salt_type = SALT_TYPE_EMBEDDED;
7221 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7222 opts_type = OPTS_TYPE_PT_GENERATE_BE
7223 | OPTS_TYPE_PT_ADD80
7224 | OPTS_TYPE_PT_ADDBITS15
7225 | OPTS_TYPE_ST_HEX;
7226 kern_type = KERN_TYPE_SHA1_SLTPW;
7227 dgst_size = DGST_SIZE_4_5;
7228 parse_func = arubaos_parse_hash;
7229 sort_by_digest = sort_by_digest_4_5;
7230 opti_type = OPTI_TYPE_ZERO_BYTE
7231 | OPTI_TYPE_PRECOMPUTE_INIT
7232 | OPTI_TYPE_PRECOMPUTE_MERKLE
7233 | OPTI_TYPE_EARLY_SKIP
7234 | OPTI_TYPE_NOT_ITERATED
7235 | OPTI_TYPE_PREPENDED_SALT
7236 | OPTI_TYPE_RAW_HASH;
7237 dgst_pos0 = 3;
7238 dgst_pos1 = 4;
7239 dgst_pos2 = 2;
7240 dgst_pos3 = 1;
7241 break;
7242
7243 case 130: hash_type = HASH_TYPE_SHA1;
7244 salt_type = SALT_TYPE_INTERN;
7245 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7246 opts_type = OPTS_TYPE_PT_GENERATE_BE
7247 | OPTS_TYPE_PT_UNICODE
7248 | OPTS_TYPE_ST_ADD80
7249 | OPTS_TYPE_ST_ADDBITS15;
7250 kern_type = KERN_TYPE_SHA1_PWUSLT;
7251 dgst_size = DGST_SIZE_4_5;
7252 parse_func = sha1s_parse_hash;
7253 sort_by_digest = sort_by_digest_4_5;
7254 opti_type = OPTI_TYPE_ZERO_BYTE
7255 | OPTI_TYPE_PRECOMPUTE_INIT
7256 | OPTI_TYPE_PRECOMPUTE_MERKLE
7257 | OPTI_TYPE_EARLY_SKIP
7258 | OPTI_TYPE_NOT_ITERATED
7259 | OPTI_TYPE_APPENDED_SALT
7260 | OPTI_TYPE_RAW_HASH;
7261 dgst_pos0 = 3;
7262 dgst_pos1 = 4;
7263 dgst_pos2 = 2;
7264 dgst_pos3 = 1;
7265 break;
7266
7267 case 131: hash_type = HASH_TYPE_SHA1;
7268 salt_type = SALT_TYPE_EMBEDDED;
7269 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7270 opts_type = OPTS_TYPE_PT_GENERATE_BE
7271 | OPTS_TYPE_PT_UNICODE
7272 | OPTS_TYPE_PT_UPPER
7273 | OPTS_TYPE_ST_ADD80
7274 | OPTS_TYPE_ST_ADDBITS15
7275 | OPTS_TYPE_ST_HEX;
7276 kern_type = KERN_TYPE_SHA1_PWUSLT;
7277 dgst_size = DGST_SIZE_4_5;
7278 parse_func = mssql2000_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_APPENDED_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 132: hash_type = HASH_TYPE_SHA1;
7294 salt_type = SALT_TYPE_EMBEDDED;
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 | OPTS_TYPE_ST_HEX;
7301 kern_type = KERN_TYPE_SHA1_PWUSLT;
7302 dgst_size = DGST_SIZE_4_5;
7303 parse_func = mssql2005_parse_hash;
7304 sort_by_digest = sort_by_digest_4_5;
7305 opti_type = OPTI_TYPE_ZERO_BYTE
7306 | OPTI_TYPE_PRECOMPUTE_INIT
7307 | OPTI_TYPE_PRECOMPUTE_MERKLE
7308 | OPTI_TYPE_EARLY_SKIP
7309 | OPTI_TYPE_NOT_ITERATED
7310 | OPTI_TYPE_APPENDED_SALT
7311 | OPTI_TYPE_RAW_HASH;
7312 dgst_pos0 = 3;
7313 dgst_pos1 = 4;
7314 dgst_pos2 = 2;
7315 dgst_pos3 = 1;
7316 break;
7317
7318 case 133: hash_type = HASH_TYPE_SHA1;
7319 salt_type = SALT_TYPE_EMBEDDED;
7320 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7321 opts_type = OPTS_TYPE_PT_GENERATE_BE
7322 | OPTS_TYPE_PT_UNICODE
7323 | OPTS_TYPE_ST_ADD80
7324 | OPTS_TYPE_ST_ADDBITS15;
7325 kern_type = KERN_TYPE_SHA1_PWUSLT;
7326 dgst_size = DGST_SIZE_4_5;
7327 parse_func = peoplesoft_parse_hash;
7328 sort_by_digest = sort_by_digest_4_5;
7329 opti_type = OPTI_TYPE_ZERO_BYTE
7330 | OPTI_TYPE_PRECOMPUTE_INIT
7331 | OPTI_TYPE_PRECOMPUTE_MERKLE
7332 | OPTI_TYPE_EARLY_SKIP
7333 | OPTI_TYPE_NOT_ITERATED
7334 | OPTI_TYPE_APPENDED_SALT
7335 | OPTI_TYPE_RAW_HASH;
7336 dgst_pos0 = 3;
7337 dgst_pos1 = 4;
7338 dgst_pos2 = 2;
7339 dgst_pos3 = 1;
7340 break;
7341
7342 case 140: hash_type = HASH_TYPE_SHA1;
7343 salt_type = SALT_TYPE_INTERN;
7344 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7345 opts_type = OPTS_TYPE_PT_GENERATE_BE
7346 | OPTS_TYPE_PT_ADD80
7347 | OPTS_TYPE_PT_ADDBITS15
7348 | OPTS_TYPE_PT_UNICODE;
7349 kern_type = KERN_TYPE_SHA1_SLTPWU;
7350 dgst_size = DGST_SIZE_4_5;
7351 parse_func = sha1s_parse_hash;
7352 sort_by_digest = sort_by_digest_4_5;
7353 opti_type = OPTI_TYPE_ZERO_BYTE
7354 | OPTI_TYPE_PRECOMPUTE_INIT
7355 | OPTI_TYPE_PRECOMPUTE_MERKLE
7356 | OPTI_TYPE_EARLY_SKIP
7357 | OPTI_TYPE_NOT_ITERATED
7358 | OPTI_TYPE_PREPENDED_SALT
7359 | OPTI_TYPE_RAW_HASH;
7360 dgst_pos0 = 3;
7361 dgst_pos1 = 4;
7362 dgst_pos2 = 2;
7363 dgst_pos3 = 1;
7364 break;
7365
7366 case 141: hash_type = HASH_TYPE_SHA1;
7367 salt_type = SALT_TYPE_EMBEDDED;
7368 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7369 opts_type = OPTS_TYPE_PT_GENERATE_BE
7370 | OPTS_TYPE_PT_ADD80
7371 | OPTS_TYPE_PT_ADDBITS15
7372 | OPTS_TYPE_PT_UNICODE
7373 | OPTS_TYPE_ST_BASE64;
7374 kern_type = KERN_TYPE_SHA1_SLTPWU;
7375 dgst_size = DGST_SIZE_4_5;
7376 parse_func = episerver_parse_hash;
7377 sort_by_digest = sort_by_digest_4_5;
7378 opti_type = OPTI_TYPE_ZERO_BYTE
7379 | OPTI_TYPE_PRECOMPUTE_INIT
7380 | OPTI_TYPE_PRECOMPUTE_MERKLE
7381 | OPTI_TYPE_EARLY_SKIP
7382 | OPTI_TYPE_NOT_ITERATED
7383 | OPTI_TYPE_PREPENDED_SALT
7384 | OPTI_TYPE_RAW_HASH;
7385 dgst_pos0 = 3;
7386 dgst_pos1 = 4;
7387 dgst_pos2 = 2;
7388 dgst_pos3 = 1;
7389 break;
7390
7391 case 150: hash_type = HASH_TYPE_SHA1;
7392 salt_type = SALT_TYPE_INTERN;
7393 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7394 opts_type = OPTS_TYPE_PT_GENERATE_BE
7395 | OPTS_TYPE_ST_ADD80
7396 | OPTS_TYPE_ST_ADDBITS15;
7397 kern_type = KERN_TYPE_HMACSHA1_PW;
7398 dgst_size = DGST_SIZE_4_5;
7399 parse_func = hmacsha1_parse_hash;
7400 sort_by_digest = sort_by_digest_4_5;
7401 opti_type = OPTI_TYPE_ZERO_BYTE
7402 | OPTI_TYPE_NOT_ITERATED;
7403 dgst_pos0 = 3;
7404 dgst_pos1 = 4;
7405 dgst_pos2 = 2;
7406 dgst_pos3 = 1;
7407 break;
7408
7409 case 160: hash_type = HASH_TYPE_SHA1;
7410 salt_type = SALT_TYPE_INTERN;
7411 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7412 opts_type = OPTS_TYPE_PT_GENERATE_BE
7413 | OPTS_TYPE_PT_ADD80
7414 | OPTS_TYPE_PT_ADDBITS15;
7415 kern_type = KERN_TYPE_HMACSHA1_SLT;
7416 dgst_size = DGST_SIZE_4_5;
7417 parse_func = hmacsha1_parse_hash;
7418 sort_by_digest = sort_by_digest_4_5;
7419 opti_type = OPTI_TYPE_ZERO_BYTE
7420 | OPTI_TYPE_NOT_ITERATED;
7421 dgst_pos0 = 3;
7422 dgst_pos1 = 4;
7423 dgst_pos2 = 2;
7424 dgst_pos3 = 1;
7425 break;
7426
7427 case 190: hash_type = HASH_TYPE_SHA1;
7428 salt_type = SALT_TYPE_NONE;
7429 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7430 opts_type = OPTS_TYPE_PT_GENERATE_BE
7431 | OPTS_TYPE_PT_ADD80
7432 | OPTS_TYPE_PT_ADDBITS15;
7433 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7434 dgst_size = DGST_SIZE_4_5;
7435 parse_func = sha1linkedin_parse_hash;
7436 sort_by_digest = sort_by_digest_4_5;
7437 opti_type = OPTI_TYPE_ZERO_BYTE
7438 | OPTI_TYPE_PRECOMPUTE_INIT
7439 | OPTI_TYPE_EARLY_SKIP
7440 | OPTI_TYPE_NOT_ITERATED
7441 | OPTI_TYPE_NOT_SALTED;
7442 dgst_pos0 = 0;
7443 dgst_pos1 = 4;
7444 dgst_pos2 = 3;
7445 dgst_pos3 = 2;
7446 break;
7447
7448 case 200: hash_type = HASH_TYPE_MYSQL;
7449 salt_type = SALT_TYPE_NONE;
7450 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7451 opts_type = 0;
7452 kern_type = KERN_TYPE_MYSQL;
7453 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7454 parse_func = mysql323_parse_hash;
7455 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7456 opti_type = OPTI_TYPE_ZERO_BYTE;
7457 dgst_pos0 = 0;
7458 dgst_pos1 = 1;
7459 dgst_pos2 = 2;
7460 dgst_pos3 = 3;
7461 break;
7462
7463 case 300: hash_type = HASH_TYPE_SHA1;
7464 salt_type = SALT_TYPE_NONE;
7465 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7466 opts_type = OPTS_TYPE_PT_GENERATE_BE
7467 | OPTS_TYPE_PT_ADD80
7468 | OPTS_TYPE_PT_ADDBITS15;
7469 kern_type = KERN_TYPE_MYSQL41;
7470 dgst_size = DGST_SIZE_4_5;
7471 parse_func = sha1_parse_hash;
7472 sort_by_digest = sort_by_digest_4_5;
7473 opti_type = OPTI_TYPE_ZERO_BYTE
7474 | OPTI_TYPE_PRECOMPUTE_INIT
7475 | OPTI_TYPE_PRECOMPUTE_MERKLE
7476 | OPTI_TYPE_EARLY_SKIP
7477 | OPTI_TYPE_NOT_ITERATED
7478 | OPTI_TYPE_NOT_SALTED;
7479 dgst_pos0 = 3;
7480 dgst_pos1 = 4;
7481 dgst_pos2 = 2;
7482 dgst_pos3 = 1;
7483 break;
7484
7485 case 400: hash_type = HASH_TYPE_MD5;
7486 salt_type = SALT_TYPE_EMBEDDED;
7487 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7488 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7489 kern_type = KERN_TYPE_PHPASS;
7490 dgst_size = DGST_SIZE_4_4;
7491 parse_func = phpass_parse_hash;
7492 sort_by_digest = sort_by_digest_4_4;
7493 opti_type = OPTI_TYPE_ZERO_BYTE
7494 | OPTI_TYPE_SLOW_HASH_SIMD;
7495 dgst_pos0 = 0;
7496 dgst_pos1 = 1;
7497 dgst_pos2 = 2;
7498 dgst_pos3 = 3;
7499 break;
7500
7501 case 500: hash_type = HASH_TYPE_MD5;
7502 salt_type = SALT_TYPE_EMBEDDED;
7503 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7504 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7505 kern_type = KERN_TYPE_MD5CRYPT;
7506 dgst_size = DGST_SIZE_4_4;
7507 parse_func = md5crypt_parse_hash;
7508 sort_by_digest = sort_by_digest_4_4;
7509 opti_type = OPTI_TYPE_ZERO_BYTE;
7510 dgst_pos0 = 0;
7511 dgst_pos1 = 1;
7512 dgst_pos2 = 2;
7513 dgst_pos3 = 3;
7514 break;
7515
7516 case 501: hash_type = HASH_TYPE_MD5;
7517 salt_type = SALT_TYPE_EMBEDDED;
7518 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7519 opts_type = OPTS_TYPE_PT_GENERATE_LE
7520 | OPTS_TYPE_HASH_COPY;
7521 kern_type = KERN_TYPE_MD5CRYPT;
7522 dgst_size = DGST_SIZE_4_4;
7523 parse_func = juniper_parse_hash;
7524 sort_by_digest = sort_by_digest_4_4;
7525 opti_type = OPTI_TYPE_ZERO_BYTE;
7526 dgst_pos0 = 0;
7527 dgst_pos1 = 1;
7528 dgst_pos2 = 2;
7529 dgst_pos3 = 3;
7530 break;
7531
7532 case 900: hash_type = HASH_TYPE_MD4;
7533 salt_type = SALT_TYPE_NONE;
7534 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7535 opts_type = OPTS_TYPE_PT_GENERATE_LE
7536 | OPTS_TYPE_PT_ADD80
7537 | OPTS_TYPE_PT_ADDBITS14;
7538 kern_type = KERN_TYPE_MD4;
7539 dgst_size = DGST_SIZE_4_4;
7540 parse_func = md4_parse_hash;
7541 sort_by_digest = sort_by_digest_4_4;
7542 opti_type = OPTI_TYPE_ZERO_BYTE
7543 | OPTI_TYPE_PRECOMPUTE_INIT
7544 | OPTI_TYPE_PRECOMPUTE_MERKLE
7545 | OPTI_TYPE_MEET_IN_MIDDLE
7546 | OPTI_TYPE_EARLY_SKIP
7547 | OPTI_TYPE_NOT_ITERATED
7548 | OPTI_TYPE_NOT_SALTED
7549 | OPTI_TYPE_RAW_HASH;
7550 dgst_pos0 = 0;
7551 dgst_pos1 = 3;
7552 dgst_pos2 = 2;
7553 dgst_pos3 = 1;
7554 break;
7555
7556 case 1000: hash_type = HASH_TYPE_MD4;
7557 salt_type = SALT_TYPE_NONE;
7558 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7559 opts_type = OPTS_TYPE_PT_GENERATE_LE
7560 | OPTS_TYPE_PT_ADD80
7561 | OPTS_TYPE_PT_ADDBITS14
7562 | OPTS_TYPE_PT_UNICODE;
7563 kern_type = KERN_TYPE_MD4_PWU;
7564 dgst_size = DGST_SIZE_4_4;
7565 parse_func = md4_parse_hash;
7566 sort_by_digest = sort_by_digest_4_4;
7567 opti_type = OPTI_TYPE_ZERO_BYTE
7568 | OPTI_TYPE_PRECOMPUTE_INIT
7569 | OPTI_TYPE_PRECOMPUTE_MERKLE
7570 | OPTI_TYPE_MEET_IN_MIDDLE
7571 | OPTI_TYPE_EARLY_SKIP
7572 | OPTI_TYPE_NOT_ITERATED
7573 | OPTI_TYPE_NOT_SALTED
7574 | OPTI_TYPE_RAW_HASH;
7575 dgst_pos0 = 0;
7576 dgst_pos1 = 3;
7577 dgst_pos2 = 2;
7578 dgst_pos3 = 1;
7579 break;
7580
7581 case 1100: hash_type = HASH_TYPE_MD4;
7582 salt_type = SALT_TYPE_INTERN;
7583 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7584 opts_type = OPTS_TYPE_PT_GENERATE_LE
7585 | OPTS_TYPE_PT_ADD80
7586 | OPTS_TYPE_PT_ADDBITS14
7587 | OPTS_TYPE_PT_UNICODE
7588 | OPTS_TYPE_ST_ADD80
7589 | OPTS_TYPE_ST_UNICODE
7590 | OPTS_TYPE_ST_LOWER;
7591 kern_type = KERN_TYPE_MD44_PWUSLT;
7592 dgst_size = DGST_SIZE_4_4;
7593 parse_func = dcc_parse_hash;
7594 sort_by_digest = sort_by_digest_4_4;
7595 opti_type = OPTI_TYPE_ZERO_BYTE
7596 | OPTI_TYPE_PRECOMPUTE_INIT
7597 | OPTI_TYPE_PRECOMPUTE_MERKLE
7598 | OPTI_TYPE_EARLY_SKIP
7599 | OPTI_TYPE_NOT_ITERATED;
7600 dgst_pos0 = 0;
7601 dgst_pos1 = 3;
7602 dgst_pos2 = 2;
7603 dgst_pos3 = 1;
7604 break;
7605
7606 case 1400: hash_type = HASH_TYPE_SHA256;
7607 salt_type = SALT_TYPE_NONE;
7608 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7609 opts_type = OPTS_TYPE_PT_GENERATE_BE
7610 | OPTS_TYPE_PT_ADD80
7611 | OPTS_TYPE_PT_ADDBITS15;
7612 kern_type = KERN_TYPE_SHA256;
7613 dgst_size = DGST_SIZE_4_8;
7614 parse_func = sha256_parse_hash;
7615 sort_by_digest = sort_by_digest_4_8;
7616 opti_type = OPTI_TYPE_ZERO_BYTE
7617 | OPTI_TYPE_PRECOMPUTE_INIT
7618 | OPTI_TYPE_PRECOMPUTE_MERKLE
7619 | OPTI_TYPE_EARLY_SKIP
7620 | OPTI_TYPE_NOT_ITERATED
7621 | OPTI_TYPE_NOT_SALTED
7622 | OPTI_TYPE_RAW_HASH;
7623 dgst_pos0 = 3;
7624 dgst_pos1 = 7;
7625 dgst_pos2 = 2;
7626 dgst_pos3 = 6;
7627 break;
7628
7629 case 1410: hash_type = HASH_TYPE_SHA256;
7630 salt_type = SALT_TYPE_INTERN;
7631 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7632 opts_type = OPTS_TYPE_PT_GENERATE_BE
7633 | OPTS_TYPE_ST_ADD80
7634 | OPTS_TYPE_ST_ADDBITS15;
7635 kern_type = KERN_TYPE_SHA256_PWSLT;
7636 dgst_size = DGST_SIZE_4_8;
7637 parse_func = sha256s_parse_hash;
7638 sort_by_digest = sort_by_digest_4_8;
7639 opti_type = OPTI_TYPE_ZERO_BYTE
7640 | OPTI_TYPE_PRECOMPUTE_INIT
7641 | OPTI_TYPE_PRECOMPUTE_MERKLE
7642 | OPTI_TYPE_EARLY_SKIP
7643 | OPTI_TYPE_NOT_ITERATED
7644 | OPTI_TYPE_APPENDED_SALT
7645 | OPTI_TYPE_RAW_HASH;
7646 dgst_pos0 = 3;
7647 dgst_pos1 = 7;
7648 dgst_pos2 = 2;
7649 dgst_pos3 = 6;
7650 break;
7651
7652 case 1420: hash_type = HASH_TYPE_SHA256;
7653 salt_type = SALT_TYPE_INTERN;
7654 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7655 opts_type = OPTS_TYPE_PT_GENERATE_BE
7656 | OPTS_TYPE_PT_ADD80
7657 | OPTS_TYPE_PT_ADDBITS15;
7658 kern_type = KERN_TYPE_SHA256_SLTPW;
7659 dgst_size = DGST_SIZE_4_8;
7660 parse_func = sha256s_parse_hash;
7661 sort_by_digest = sort_by_digest_4_8;
7662 opti_type = OPTI_TYPE_ZERO_BYTE
7663 | OPTI_TYPE_PRECOMPUTE_INIT
7664 | OPTI_TYPE_PRECOMPUTE_MERKLE
7665 | OPTI_TYPE_EARLY_SKIP
7666 | OPTI_TYPE_NOT_ITERATED
7667 | OPTI_TYPE_PREPENDED_SALT
7668 | OPTI_TYPE_RAW_HASH;
7669 dgst_pos0 = 3;
7670 dgst_pos1 = 7;
7671 dgst_pos2 = 2;
7672 dgst_pos3 = 6;
7673 break;
7674
7675 case 1421: hash_type = HASH_TYPE_SHA256;
7676 salt_type = SALT_TYPE_EMBEDDED;
7677 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7678 opts_type = OPTS_TYPE_PT_GENERATE_BE
7679 | OPTS_TYPE_PT_ADD80
7680 | OPTS_TYPE_PT_ADDBITS15;
7681 kern_type = KERN_TYPE_SHA256_SLTPW;
7682 dgst_size = DGST_SIZE_4_8;
7683 parse_func = hmailserver_parse_hash;
7684 sort_by_digest = sort_by_digest_4_8;
7685 opti_type = OPTI_TYPE_ZERO_BYTE
7686 | OPTI_TYPE_PRECOMPUTE_INIT
7687 | OPTI_TYPE_PRECOMPUTE_MERKLE
7688 | OPTI_TYPE_EARLY_SKIP
7689 | OPTI_TYPE_NOT_ITERATED
7690 | OPTI_TYPE_PREPENDED_SALT
7691 | OPTI_TYPE_RAW_HASH;
7692 dgst_pos0 = 3;
7693 dgst_pos1 = 7;
7694 dgst_pos2 = 2;
7695 dgst_pos3 = 6;
7696 break;
7697
7698 case 1430: hash_type = HASH_TYPE_SHA256;
7699 salt_type = SALT_TYPE_INTERN;
7700 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7701 opts_type = OPTS_TYPE_PT_GENERATE_BE
7702 | OPTS_TYPE_PT_UNICODE
7703 | OPTS_TYPE_ST_ADD80
7704 | OPTS_TYPE_ST_ADDBITS15;
7705 kern_type = KERN_TYPE_SHA256_PWUSLT;
7706 dgst_size = DGST_SIZE_4_8;
7707 parse_func = sha256s_parse_hash;
7708 sort_by_digest = sort_by_digest_4_8;
7709 opti_type = OPTI_TYPE_ZERO_BYTE
7710 | OPTI_TYPE_PRECOMPUTE_INIT
7711 | OPTI_TYPE_PRECOMPUTE_MERKLE
7712 | OPTI_TYPE_EARLY_SKIP
7713 | OPTI_TYPE_NOT_ITERATED
7714 | OPTI_TYPE_APPENDED_SALT
7715 | OPTI_TYPE_RAW_HASH;
7716 dgst_pos0 = 3;
7717 dgst_pos1 = 7;
7718 dgst_pos2 = 2;
7719 dgst_pos3 = 6;
7720 break;
7721
7722 case 1440: hash_type = HASH_TYPE_SHA256;
7723 salt_type = SALT_TYPE_INTERN;
7724 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7725 opts_type = OPTS_TYPE_PT_GENERATE_BE
7726 | OPTS_TYPE_PT_ADD80
7727 | OPTS_TYPE_PT_ADDBITS15
7728 | OPTS_TYPE_PT_UNICODE;
7729 kern_type = KERN_TYPE_SHA256_SLTPWU;
7730 dgst_size = DGST_SIZE_4_8;
7731 parse_func = sha256s_parse_hash;
7732 sort_by_digest = sort_by_digest_4_8;
7733 opti_type = OPTI_TYPE_ZERO_BYTE
7734 | OPTI_TYPE_PRECOMPUTE_INIT
7735 | OPTI_TYPE_PRECOMPUTE_MERKLE
7736 | OPTI_TYPE_EARLY_SKIP
7737 | OPTI_TYPE_NOT_ITERATED
7738 | OPTI_TYPE_PREPENDED_SALT
7739 | OPTI_TYPE_RAW_HASH;
7740 dgst_pos0 = 3;
7741 dgst_pos1 = 7;
7742 dgst_pos2 = 2;
7743 dgst_pos3 = 6;
7744 break;
7745
7746 case 1441: hash_type = HASH_TYPE_SHA256;
7747 salt_type = SALT_TYPE_EMBEDDED;
7748 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7749 opts_type = OPTS_TYPE_PT_GENERATE_BE
7750 | OPTS_TYPE_PT_ADD80
7751 | OPTS_TYPE_PT_ADDBITS15
7752 | OPTS_TYPE_PT_UNICODE
7753 | OPTS_TYPE_ST_BASE64;
7754 kern_type = KERN_TYPE_SHA256_SLTPWU;
7755 dgst_size = DGST_SIZE_4_8;
7756 parse_func = episerver4_parse_hash;
7757 sort_by_digest = sort_by_digest_4_8;
7758 opti_type = OPTI_TYPE_ZERO_BYTE
7759 | OPTI_TYPE_PRECOMPUTE_INIT
7760 | OPTI_TYPE_PRECOMPUTE_MERKLE
7761 | OPTI_TYPE_EARLY_SKIP
7762 | OPTI_TYPE_NOT_ITERATED
7763 | OPTI_TYPE_PREPENDED_SALT
7764 | OPTI_TYPE_RAW_HASH;
7765 dgst_pos0 = 3;
7766 dgst_pos1 = 7;
7767 dgst_pos2 = 2;
7768 dgst_pos3 = 6;
7769 break;
7770
7771 case 1450: hash_type = HASH_TYPE_SHA256;
7772 salt_type = SALT_TYPE_INTERN;
7773 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7774 opts_type = OPTS_TYPE_PT_GENERATE_BE
7775 | OPTS_TYPE_ST_ADD80;
7776 kern_type = KERN_TYPE_HMACSHA256_PW;
7777 dgst_size = DGST_SIZE_4_8;
7778 parse_func = hmacsha256_parse_hash;
7779 sort_by_digest = sort_by_digest_4_8;
7780 opti_type = OPTI_TYPE_ZERO_BYTE
7781 | OPTI_TYPE_NOT_ITERATED;
7782 dgst_pos0 = 3;
7783 dgst_pos1 = 7;
7784 dgst_pos2 = 2;
7785 dgst_pos3 = 6;
7786 break;
7787
7788 case 1460: hash_type = HASH_TYPE_SHA256;
7789 salt_type = SALT_TYPE_INTERN;
7790 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7791 opts_type = OPTS_TYPE_PT_GENERATE_BE
7792 | OPTS_TYPE_PT_ADD80
7793 | OPTS_TYPE_PT_ADDBITS15;
7794 kern_type = KERN_TYPE_HMACSHA256_SLT;
7795 dgst_size = DGST_SIZE_4_8;
7796 parse_func = hmacsha256_parse_hash;
7797 sort_by_digest = sort_by_digest_4_8;
7798 opti_type = OPTI_TYPE_ZERO_BYTE
7799 | OPTI_TYPE_NOT_ITERATED;
7800 dgst_pos0 = 3;
7801 dgst_pos1 = 7;
7802 dgst_pos2 = 2;
7803 dgst_pos3 = 6;
7804 break;
7805
7806 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7807 salt_type = SALT_TYPE_EMBEDDED;
7808 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7809 opts_type = OPTS_TYPE_PT_GENERATE_LE
7810 | OPTS_TYPE_PT_BITSLICE;
7811 kern_type = KERN_TYPE_DESCRYPT;
7812 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7813 parse_func = descrypt_parse_hash;
7814 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7815 opti_type = OPTI_TYPE_ZERO_BYTE
7816 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7817 dgst_pos0 = 0;
7818 dgst_pos1 = 1;
7819 dgst_pos2 = 2;
7820 dgst_pos3 = 3;
7821 break;
7822
7823 case 1600: hash_type = HASH_TYPE_MD5;
7824 salt_type = SALT_TYPE_EMBEDDED;
7825 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7826 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7827 kern_type = KERN_TYPE_APR1CRYPT;
7828 dgst_size = DGST_SIZE_4_4;
7829 parse_func = md5apr1_parse_hash;
7830 sort_by_digest = sort_by_digest_4_4;
7831 opti_type = OPTI_TYPE_ZERO_BYTE;
7832 dgst_pos0 = 0;
7833 dgst_pos1 = 1;
7834 dgst_pos2 = 2;
7835 dgst_pos3 = 3;
7836 break;
7837
7838 case 1700: hash_type = HASH_TYPE_SHA512;
7839 salt_type = SALT_TYPE_NONE;
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_SHA512;
7845 dgst_size = DGST_SIZE_8_8;
7846 parse_func = sha512_parse_hash;
7847 sort_by_digest = sort_by_digest_8_8;
7848 opti_type = OPTI_TYPE_ZERO_BYTE
7849 | OPTI_TYPE_PRECOMPUTE_INIT
7850 | OPTI_TYPE_PRECOMPUTE_MERKLE
7851 | OPTI_TYPE_EARLY_SKIP
7852 | OPTI_TYPE_NOT_ITERATED
7853 | OPTI_TYPE_NOT_SALTED
7854 | OPTI_TYPE_USES_BITS_64
7855 | OPTI_TYPE_RAW_HASH;
7856 dgst_pos0 = 14;
7857 dgst_pos1 = 15;
7858 dgst_pos2 = 6;
7859 dgst_pos3 = 7;
7860 break;
7861
7862 case 1710: hash_type = HASH_TYPE_SHA512;
7863 salt_type = SALT_TYPE_INTERN;
7864 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7865 opts_type = OPTS_TYPE_PT_GENERATE_BE
7866 | OPTS_TYPE_ST_ADD80
7867 | OPTS_TYPE_ST_ADDBITS15;
7868 kern_type = KERN_TYPE_SHA512_PWSLT;
7869 dgst_size = DGST_SIZE_8_8;
7870 parse_func = sha512s_parse_hash;
7871 sort_by_digest = sort_by_digest_8_8;
7872 opti_type = OPTI_TYPE_ZERO_BYTE
7873 | OPTI_TYPE_PRECOMPUTE_INIT
7874 | OPTI_TYPE_PRECOMPUTE_MERKLE
7875 | OPTI_TYPE_EARLY_SKIP
7876 | OPTI_TYPE_NOT_ITERATED
7877 | OPTI_TYPE_APPENDED_SALT
7878 | OPTI_TYPE_USES_BITS_64
7879 | OPTI_TYPE_RAW_HASH;
7880 dgst_pos0 = 14;
7881 dgst_pos1 = 15;
7882 dgst_pos2 = 6;
7883 dgst_pos3 = 7;
7884 break;
7885
7886 case 1711: hash_type = HASH_TYPE_SHA512;
7887 salt_type = SALT_TYPE_EMBEDDED;
7888 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7889 opts_type = OPTS_TYPE_PT_GENERATE_BE
7890 | OPTS_TYPE_ST_ADD80
7891 | OPTS_TYPE_ST_ADDBITS15;
7892 kern_type = KERN_TYPE_SHA512_PWSLT;
7893 dgst_size = DGST_SIZE_8_8;
7894 parse_func = sha512b64s_parse_hash;
7895 sort_by_digest = sort_by_digest_8_8;
7896 opti_type = OPTI_TYPE_ZERO_BYTE
7897 | OPTI_TYPE_PRECOMPUTE_INIT
7898 | OPTI_TYPE_PRECOMPUTE_MERKLE
7899 | OPTI_TYPE_EARLY_SKIP
7900 | OPTI_TYPE_NOT_ITERATED
7901 | OPTI_TYPE_APPENDED_SALT
7902 | OPTI_TYPE_USES_BITS_64
7903 | OPTI_TYPE_RAW_HASH;
7904 dgst_pos0 = 14;
7905 dgst_pos1 = 15;
7906 dgst_pos2 = 6;
7907 dgst_pos3 = 7;
7908 break;
7909
7910 case 1720: hash_type = HASH_TYPE_SHA512;
7911 salt_type = SALT_TYPE_INTERN;
7912 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7913 opts_type = OPTS_TYPE_PT_GENERATE_BE
7914 | OPTS_TYPE_PT_ADD80
7915 | OPTS_TYPE_PT_ADDBITS15;
7916 kern_type = KERN_TYPE_SHA512_SLTPW;
7917 dgst_size = DGST_SIZE_8_8;
7918 parse_func = sha512s_parse_hash;
7919 sort_by_digest = sort_by_digest_8_8;
7920 opti_type = OPTI_TYPE_ZERO_BYTE
7921 | OPTI_TYPE_PRECOMPUTE_INIT
7922 | OPTI_TYPE_PRECOMPUTE_MERKLE
7923 | OPTI_TYPE_EARLY_SKIP
7924 | OPTI_TYPE_NOT_ITERATED
7925 | OPTI_TYPE_PREPENDED_SALT
7926 | OPTI_TYPE_USES_BITS_64
7927 | OPTI_TYPE_RAW_HASH;
7928 dgst_pos0 = 14;
7929 dgst_pos1 = 15;
7930 dgst_pos2 = 6;
7931 dgst_pos3 = 7;
7932 break;
7933
7934 case 1722: hash_type = HASH_TYPE_SHA512;
7935 salt_type = SALT_TYPE_EMBEDDED;
7936 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7937 opts_type = OPTS_TYPE_PT_GENERATE_BE
7938 | OPTS_TYPE_PT_ADD80
7939 | OPTS_TYPE_PT_ADDBITS15
7940 | OPTS_TYPE_ST_HEX;
7941 kern_type = KERN_TYPE_SHA512_SLTPW;
7942 dgst_size = DGST_SIZE_8_8;
7943 parse_func = osx512_parse_hash;
7944 sort_by_digest = sort_by_digest_8_8;
7945 opti_type = OPTI_TYPE_ZERO_BYTE
7946 | OPTI_TYPE_PRECOMPUTE_INIT
7947 | OPTI_TYPE_PRECOMPUTE_MERKLE
7948 | OPTI_TYPE_EARLY_SKIP
7949 | OPTI_TYPE_NOT_ITERATED
7950 | OPTI_TYPE_PREPENDED_SALT
7951 | OPTI_TYPE_USES_BITS_64
7952 | OPTI_TYPE_RAW_HASH;
7953 dgst_pos0 = 14;
7954 dgst_pos1 = 15;
7955 dgst_pos2 = 6;
7956 dgst_pos3 = 7;
7957 break;
7958
7959 case 1730: hash_type = HASH_TYPE_SHA512;
7960 salt_type = SALT_TYPE_INTERN;
7961 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7962 opts_type = OPTS_TYPE_PT_GENERATE_BE
7963 | OPTS_TYPE_PT_UNICODE
7964 | OPTS_TYPE_ST_ADD80
7965 | OPTS_TYPE_ST_ADDBITS15;
7966 kern_type = KERN_TYPE_SHA512_PWSLTU;
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_APPENDED_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 1731: 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_UNICODE
7989 | OPTS_TYPE_ST_ADD80
7990 | OPTS_TYPE_ST_ADDBITS15
7991 | OPTS_TYPE_ST_HEX;
7992 kern_type = KERN_TYPE_SHA512_PWSLTU;
7993 dgst_size = DGST_SIZE_8_8;
7994 parse_func = mssql2012_parse_hash;
7995 sort_by_digest = sort_by_digest_8_8;
7996 opti_type = OPTI_TYPE_ZERO_BYTE
7997 | OPTI_TYPE_PRECOMPUTE_INIT
7998 | OPTI_TYPE_PRECOMPUTE_MERKLE
7999 | OPTI_TYPE_EARLY_SKIP
8000 | OPTI_TYPE_NOT_ITERATED
8001 | OPTI_TYPE_APPENDED_SALT
8002 | OPTI_TYPE_USES_BITS_64
8003 | OPTI_TYPE_RAW_HASH;
8004 dgst_pos0 = 14;
8005 dgst_pos1 = 15;
8006 dgst_pos2 = 6;
8007 dgst_pos3 = 7;
8008 break;
8009
8010 case 1740: hash_type = HASH_TYPE_SHA512;
8011 salt_type = SALT_TYPE_INTERN;
8012 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8013 opts_type = OPTS_TYPE_PT_GENERATE_BE
8014 | OPTS_TYPE_PT_ADD80
8015 | OPTS_TYPE_PT_ADDBITS15
8016 | OPTS_TYPE_PT_UNICODE;
8017 kern_type = KERN_TYPE_SHA512_SLTPWU;
8018 dgst_size = DGST_SIZE_8_8;
8019 parse_func = sha512s_parse_hash;
8020 sort_by_digest = sort_by_digest_8_8;
8021 opti_type = OPTI_TYPE_ZERO_BYTE
8022 | OPTI_TYPE_PRECOMPUTE_INIT
8023 | OPTI_TYPE_PRECOMPUTE_MERKLE
8024 | OPTI_TYPE_EARLY_SKIP
8025 | OPTI_TYPE_NOT_ITERATED
8026 | OPTI_TYPE_PREPENDED_SALT
8027 | OPTI_TYPE_USES_BITS_64
8028 | OPTI_TYPE_RAW_HASH;
8029 dgst_pos0 = 14;
8030 dgst_pos1 = 15;
8031 dgst_pos2 = 6;
8032 dgst_pos3 = 7;
8033 break;
8034
8035 case 1750: hash_type = HASH_TYPE_SHA512;
8036 salt_type = SALT_TYPE_INTERN;
8037 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8038 opts_type = OPTS_TYPE_PT_GENERATE_BE
8039 | OPTS_TYPE_ST_ADD80;
8040 kern_type = KERN_TYPE_HMACSHA512_PW;
8041 dgst_size = DGST_SIZE_8_8;
8042 parse_func = hmacsha512_parse_hash;
8043 sort_by_digest = sort_by_digest_8_8;
8044 opti_type = OPTI_TYPE_ZERO_BYTE
8045 | OPTI_TYPE_USES_BITS_64
8046 | OPTI_TYPE_NOT_ITERATED;
8047 dgst_pos0 = 14;
8048 dgst_pos1 = 15;
8049 dgst_pos2 = 6;
8050 dgst_pos3 = 7;
8051 break;
8052
8053 case 1760: hash_type = HASH_TYPE_SHA512;
8054 salt_type = SALT_TYPE_INTERN;
8055 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8056 opts_type = OPTS_TYPE_PT_GENERATE_BE
8057 | OPTS_TYPE_PT_ADD80
8058 | OPTS_TYPE_PT_ADDBITS15;
8059 kern_type = KERN_TYPE_HMACSHA512_SLT;
8060 dgst_size = DGST_SIZE_8_8;
8061 parse_func = hmacsha512_parse_hash;
8062 sort_by_digest = sort_by_digest_8_8;
8063 opti_type = OPTI_TYPE_ZERO_BYTE
8064 | OPTI_TYPE_USES_BITS_64
8065 | OPTI_TYPE_NOT_ITERATED;
8066 dgst_pos0 = 14;
8067 dgst_pos1 = 15;
8068 dgst_pos2 = 6;
8069 dgst_pos3 = 7;
8070 break;
8071
8072 case 1800: hash_type = HASH_TYPE_SHA512;
8073 salt_type = SALT_TYPE_EMBEDDED;
8074 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8075 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8076 kern_type = KERN_TYPE_SHA512CRYPT;
8077 dgst_size = DGST_SIZE_8_8;
8078 parse_func = sha512crypt_parse_hash;
8079 sort_by_digest = sort_by_digest_8_8;
8080 opti_type = OPTI_TYPE_ZERO_BYTE
8081 | OPTI_TYPE_USES_BITS_64;
8082 dgst_pos0 = 0;
8083 dgst_pos1 = 1;
8084 dgst_pos2 = 2;
8085 dgst_pos3 = 3;
8086 break;
8087
8088 case 2100: hash_type = HASH_TYPE_DCC2;
8089 salt_type = SALT_TYPE_EMBEDDED;
8090 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8091 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8092 | OPTS_TYPE_ST_LOWER
8093 | OPTS_TYPE_ST_UNICODE;
8094 kern_type = KERN_TYPE_DCC2;
8095 dgst_size = DGST_SIZE_4_4;
8096 parse_func = dcc2_parse_hash;
8097 sort_by_digest = sort_by_digest_4_4;
8098 opti_type = OPTI_TYPE_ZERO_BYTE
8099 | OPTI_TYPE_SLOW_HASH_SIMD;
8100 dgst_pos0 = 0;
8101 dgst_pos1 = 1;
8102 dgst_pos2 = 2;
8103 dgst_pos3 = 3;
8104 break;
8105
8106 case 2400: hash_type = HASH_TYPE_MD5;
8107 salt_type = SALT_TYPE_NONE;
8108 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8109 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8110 kern_type = KERN_TYPE_MD5PIX;
8111 dgst_size = DGST_SIZE_4_4;
8112 parse_func = md5pix_parse_hash;
8113 sort_by_digest = sort_by_digest_4_4;
8114 opti_type = OPTI_TYPE_ZERO_BYTE
8115 | OPTI_TYPE_PRECOMPUTE_INIT
8116 | OPTI_TYPE_PRECOMPUTE_MERKLE
8117 | OPTI_TYPE_EARLY_SKIP
8118 | OPTI_TYPE_NOT_ITERATED
8119 | OPTI_TYPE_NOT_SALTED;
8120 dgst_pos0 = 0;
8121 dgst_pos1 = 3;
8122 dgst_pos2 = 2;
8123 dgst_pos3 = 1;
8124 break;
8125
8126 case 2410: hash_type = HASH_TYPE_MD5;
8127 salt_type = SALT_TYPE_INTERN;
8128 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8129 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8130 kern_type = KERN_TYPE_MD5ASA;
8131 dgst_size = DGST_SIZE_4_4;
8132 parse_func = md5asa_parse_hash;
8133 sort_by_digest = sort_by_digest_4_4;
8134 opti_type = OPTI_TYPE_ZERO_BYTE
8135 | OPTI_TYPE_PRECOMPUTE_INIT
8136 | OPTI_TYPE_PRECOMPUTE_MERKLE
8137 | OPTI_TYPE_EARLY_SKIP
8138 | OPTI_TYPE_NOT_ITERATED;
8139 dgst_pos0 = 0;
8140 dgst_pos1 = 3;
8141 dgst_pos2 = 2;
8142 dgst_pos3 = 1;
8143 break;
8144
8145 case 2500: hash_type = HASH_TYPE_WPA;
8146 salt_type = SALT_TYPE_EMBEDDED;
8147 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8148 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8149 kern_type = KERN_TYPE_WPA;
8150 dgst_size = DGST_SIZE_4_4;
8151 parse_func = wpa_parse_hash;
8152 sort_by_digest = sort_by_digest_4_4;
8153 opti_type = OPTI_TYPE_ZERO_BYTE
8154 | OPTI_TYPE_SLOW_HASH_SIMD;
8155 dgst_pos0 = 0;
8156 dgst_pos1 = 1;
8157 dgst_pos2 = 2;
8158 dgst_pos3 = 3;
8159 break;
8160
8161 case 2600: hash_type = HASH_TYPE_MD5;
8162 salt_type = SALT_TYPE_VIRTUAL;
8163 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8164 opts_type = OPTS_TYPE_PT_GENERATE_LE
8165 | OPTS_TYPE_PT_ADD80
8166 | OPTS_TYPE_PT_ADDBITS14
8167 | OPTS_TYPE_ST_ADD80;
8168 kern_type = KERN_TYPE_MD55_PWSLT1;
8169 dgst_size = DGST_SIZE_4_4;
8170 parse_func = md5md5_parse_hash;
8171 sort_by_digest = sort_by_digest_4_4;
8172 opti_type = OPTI_TYPE_ZERO_BYTE
8173 | OPTI_TYPE_PRECOMPUTE_INIT
8174 | OPTI_TYPE_PRECOMPUTE_MERKLE
8175 | OPTI_TYPE_EARLY_SKIP;
8176 dgst_pos0 = 0;
8177 dgst_pos1 = 3;
8178 dgst_pos2 = 2;
8179 dgst_pos3 = 1;
8180 break;
8181
8182 case 2611: hash_type = HASH_TYPE_MD5;
8183 salt_type = SALT_TYPE_INTERN;
8184 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8185 opts_type = OPTS_TYPE_PT_GENERATE_LE
8186 | OPTS_TYPE_PT_ADD80
8187 | OPTS_TYPE_PT_ADDBITS14
8188 | OPTS_TYPE_ST_ADD80;
8189 kern_type = KERN_TYPE_MD55_PWSLT1;
8190 dgst_size = DGST_SIZE_4_4;
8191 parse_func = vb3_parse_hash;
8192 sort_by_digest = sort_by_digest_4_4;
8193 opti_type = OPTI_TYPE_ZERO_BYTE
8194 | OPTI_TYPE_PRECOMPUTE_INIT
8195 | OPTI_TYPE_PRECOMPUTE_MERKLE
8196 | OPTI_TYPE_EARLY_SKIP;
8197 dgst_pos0 = 0;
8198 dgst_pos1 = 3;
8199 dgst_pos2 = 2;
8200 dgst_pos3 = 1;
8201 break;
8202
8203 case 2612: hash_type = HASH_TYPE_MD5;
8204 salt_type = SALT_TYPE_EMBEDDED;
8205 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8206 opts_type = OPTS_TYPE_PT_GENERATE_LE
8207 | OPTS_TYPE_PT_ADD80
8208 | OPTS_TYPE_PT_ADDBITS14
8209 | OPTS_TYPE_ST_ADD80
8210 | OPTS_TYPE_ST_HEX;
8211 kern_type = KERN_TYPE_MD55_PWSLT1;
8212 dgst_size = DGST_SIZE_4_4;
8213 parse_func = phps_parse_hash;
8214 sort_by_digest = sort_by_digest_4_4;
8215 opti_type = OPTI_TYPE_ZERO_BYTE
8216 | OPTI_TYPE_PRECOMPUTE_INIT
8217 | OPTI_TYPE_PRECOMPUTE_MERKLE
8218 | OPTI_TYPE_EARLY_SKIP;
8219 dgst_pos0 = 0;
8220 dgst_pos1 = 3;
8221 dgst_pos2 = 2;
8222 dgst_pos3 = 1;
8223 break;
8224
8225 case 2711: hash_type = HASH_TYPE_MD5;
8226 salt_type = SALT_TYPE_INTERN;
8227 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8228 opts_type = OPTS_TYPE_PT_GENERATE_LE
8229 | OPTS_TYPE_PT_ADD80
8230 | OPTS_TYPE_PT_ADDBITS14
8231 | OPTS_TYPE_ST_ADD80;
8232 kern_type = KERN_TYPE_MD55_PWSLT2;
8233 dgst_size = DGST_SIZE_4_4;
8234 parse_func = vb30_parse_hash;
8235 sort_by_digest = sort_by_digest_4_4;
8236 opti_type = OPTI_TYPE_ZERO_BYTE
8237 | OPTI_TYPE_PRECOMPUTE_INIT
8238 | OPTI_TYPE_EARLY_SKIP;
8239 dgst_pos0 = 0;
8240 dgst_pos1 = 3;
8241 dgst_pos2 = 2;
8242 dgst_pos3 = 1;
8243 break;
8244
8245 case 2811: hash_type = HASH_TYPE_MD5;
8246 salt_type = SALT_TYPE_INTERN;
8247 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8248 opts_type = OPTS_TYPE_PT_GENERATE_LE
8249 | OPTS_TYPE_PT_ADD80
8250 | OPTS_TYPE_PT_ADDBITS14;
8251 kern_type = KERN_TYPE_MD55_SLTPW;
8252 dgst_size = DGST_SIZE_4_4;
8253 parse_func = ipb2_parse_hash;
8254 sort_by_digest = sort_by_digest_4_4;
8255 opti_type = OPTI_TYPE_ZERO_BYTE
8256 | OPTI_TYPE_PRECOMPUTE_INIT
8257 | OPTI_TYPE_EARLY_SKIP;
8258 dgst_pos0 = 0;
8259 dgst_pos1 = 3;
8260 dgst_pos2 = 2;
8261 dgst_pos3 = 1;
8262 break;
8263
8264 case 3000: hash_type = HASH_TYPE_LM;
8265 salt_type = SALT_TYPE_NONE;
8266 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8267 opts_type = OPTS_TYPE_PT_GENERATE_LE
8268 | OPTS_TYPE_PT_UPPER
8269 | OPTS_TYPE_PT_BITSLICE;
8270 kern_type = KERN_TYPE_LM;
8271 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8272 parse_func = lm_parse_hash;
8273 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8274 opti_type = OPTI_TYPE_ZERO_BYTE
8275 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8276 dgst_pos0 = 0;
8277 dgst_pos1 = 1;
8278 dgst_pos2 = 2;
8279 dgst_pos3 = 3;
8280 break;
8281
8282 case 3100: hash_type = HASH_TYPE_ORACLEH;
8283 salt_type = SALT_TYPE_INTERN;
8284 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8285 opts_type = OPTS_TYPE_PT_GENERATE_LE
8286 | OPTS_TYPE_PT_UPPER
8287 | OPTS_TYPE_ST_UPPER;
8288 kern_type = KERN_TYPE_ORACLEH;
8289 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8290 parse_func = oracleh_parse_hash;
8291 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8292 opti_type = OPTI_TYPE_ZERO_BYTE;
8293 dgst_pos0 = 0;
8294 dgst_pos1 = 1;
8295 dgst_pos2 = 2;
8296 dgst_pos3 = 3;
8297 break;
8298
8299 case 3200: hash_type = HASH_TYPE_BCRYPT;
8300 salt_type = SALT_TYPE_EMBEDDED;
8301 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8302 opts_type = OPTS_TYPE_PT_GENERATE_LE
8303 | OPTS_TYPE_ST_GENERATE_LE;
8304 kern_type = KERN_TYPE_BCRYPT;
8305 dgst_size = DGST_SIZE_4_6;
8306 parse_func = bcrypt_parse_hash;
8307 sort_by_digest = sort_by_digest_4_6;
8308 opti_type = OPTI_TYPE_ZERO_BYTE;
8309 dgst_pos0 = 0;
8310 dgst_pos1 = 1;
8311 dgst_pos2 = 2;
8312 dgst_pos3 = 3;
8313 break;
8314
8315 case 3710: hash_type = HASH_TYPE_MD5;
8316 salt_type = SALT_TYPE_INTERN;
8317 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8318 opts_type = OPTS_TYPE_PT_GENERATE_LE
8319 | OPTS_TYPE_PT_ADD80
8320 | OPTS_TYPE_PT_ADDBITS14;
8321 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8322 dgst_size = DGST_SIZE_4_4;
8323 parse_func = md5s_parse_hash;
8324 sort_by_digest = sort_by_digest_4_4;
8325 opti_type = OPTI_TYPE_ZERO_BYTE
8326 | OPTI_TYPE_PRECOMPUTE_INIT
8327 | OPTI_TYPE_PRECOMPUTE_MERKLE
8328 | OPTI_TYPE_EARLY_SKIP;
8329 dgst_pos0 = 0;
8330 dgst_pos1 = 3;
8331 dgst_pos2 = 2;
8332 dgst_pos3 = 1;
8333 break;
8334
8335 case 3711: hash_type = HASH_TYPE_MD5;
8336 salt_type = SALT_TYPE_EMBEDDED;
8337 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8338 opts_type = OPTS_TYPE_PT_GENERATE_LE
8339 | OPTS_TYPE_PT_ADD80
8340 | OPTS_TYPE_PT_ADDBITS14;
8341 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8342 dgst_size = DGST_SIZE_4_4;
8343 parse_func = mediawiki_b_parse_hash;
8344 sort_by_digest = sort_by_digest_4_4;
8345 opti_type = OPTI_TYPE_ZERO_BYTE
8346 | OPTI_TYPE_PRECOMPUTE_INIT
8347 | OPTI_TYPE_PRECOMPUTE_MERKLE
8348 | OPTI_TYPE_EARLY_SKIP;
8349 dgst_pos0 = 0;
8350 dgst_pos1 = 3;
8351 dgst_pos2 = 2;
8352 dgst_pos3 = 1;
8353 break;
8354
8355 case 3800: hash_type = HASH_TYPE_MD5;
8356 salt_type = SALT_TYPE_INTERN;
8357 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8358 opts_type = OPTS_TYPE_PT_GENERATE_LE
8359 | OPTS_TYPE_ST_ADDBITS14;
8360 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8361 dgst_size = DGST_SIZE_4_4;
8362 parse_func = md5s_parse_hash;
8363 sort_by_digest = sort_by_digest_4_4;
8364 opti_type = OPTI_TYPE_ZERO_BYTE
8365 | OPTI_TYPE_PRECOMPUTE_INIT
8366 | OPTI_TYPE_PRECOMPUTE_MERKLE
8367 | OPTI_TYPE_EARLY_SKIP
8368 | OPTI_TYPE_NOT_ITERATED
8369 | OPTI_TYPE_RAW_HASH;
8370 dgst_pos0 = 0;
8371 dgst_pos1 = 3;
8372 dgst_pos2 = 2;
8373 dgst_pos3 = 1;
8374 break;
8375
8376 case 4300: hash_type = HASH_TYPE_MD5;
8377 salt_type = SALT_TYPE_VIRTUAL;
8378 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8379 opts_type = OPTS_TYPE_PT_GENERATE_LE
8380 | OPTS_TYPE_PT_ADD80
8381 | OPTS_TYPE_PT_ADDBITS14
8382 | OPTS_TYPE_ST_ADD80;
8383 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8384 dgst_size = DGST_SIZE_4_4;
8385 parse_func = md5md5_parse_hash;
8386 sort_by_digest = sort_by_digest_4_4;
8387 opti_type = OPTI_TYPE_ZERO_BYTE
8388 | OPTI_TYPE_PRECOMPUTE_INIT
8389 | OPTI_TYPE_PRECOMPUTE_MERKLE
8390 | OPTI_TYPE_EARLY_SKIP;
8391 dgst_pos0 = 0;
8392 dgst_pos1 = 3;
8393 dgst_pos2 = 2;
8394 dgst_pos3 = 1;
8395 break;
8396
8397
8398 case 4400: hash_type = HASH_TYPE_MD5;
8399 salt_type = SALT_TYPE_NONE;
8400 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8401 opts_type = OPTS_TYPE_PT_GENERATE_BE
8402 | OPTS_TYPE_PT_ADD80
8403 | OPTS_TYPE_PT_ADDBITS15;
8404 kern_type = KERN_TYPE_MD5_SHA1;
8405 dgst_size = DGST_SIZE_4_4;
8406 parse_func = md5_parse_hash;
8407 sort_by_digest = sort_by_digest_4_4;
8408 opti_type = OPTI_TYPE_ZERO_BYTE
8409 | OPTI_TYPE_PRECOMPUTE_INIT
8410 | OPTI_TYPE_PRECOMPUTE_MERKLE
8411 | OPTI_TYPE_EARLY_SKIP
8412 | OPTI_TYPE_NOT_ITERATED
8413 | OPTI_TYPE_NOT_SALTED
8414 | OPTI_TYPE_RAW_HASH;
8415 dgst_pos0 = 0;
8416 dgst_pos1 = 3;
8417 dgst_pos2 = 2;
8418 dgst_pos3 = 1;
8419 break;
8420
8421 case 4500: hash_type = HASH_TYPE_SHA1;
8422 salt_type = SALT_TYPE_NONE;
8423 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8424 opts_type = OPTS_TYPE_PT_GENERATE_BE
8425 | OPTS_TYPE_PT_ADD80
8426 | OPTS_TYPE_PT_ADDBITS15;
8427 kern_type = KERN_TYPE_SHA11;
8428 dgst_size = DGST_SIZE_4_5;
8429 parse_func = sha1_parse_hash;
8430 sort_by_digest = sort_by_digest_4_5;
8431 opti_type = OPTI_TYPE_ZERO_BYTE
8432 | OPTI_TYPE_PRECOMPUTE_INIT
8433 | OPTI_TYPE_PRECOMPUTE_MERKLE
8434 | OPTI_TYPE_EARLY_SKIP
8435 | OPTI_TYPE_NOT_SALTED;
8436 dgst_pos0 = 3;
8437 dgst_pos1 = 4;
8438 dgst_pos2 = 2;
8439 dgst_pos3 = 1;
8440 break;
8441
8442 case 4700: hash_type = HASH_TYPE_SHA1;
8443 salt_type = SALT_TYPE_NONE;
8444 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8445 opts_type = OPTS_TYPE_PT_GENERATE_LE
8446 | OPTS_TYPE_PT_ADD80
8447 | OPTS_TYPE_PT_ADDBITS14;
8448 kern_type = KERN_TYPE_SHA1_MD5;
8449 dgst_size = DGST_SIZE_4_5;
8450 parse_func = sha1_parse_hash;
8451 sort_by_digest = sort_by_digest_4_5;
8452 opti_type = OPTI_TYPE_ZERO_BYTE
8453 | OPTI_TYPE_PRECOMPUTE_INIT
8454 | OPTI_TYPE_PRECOMPUTE_MERKLE
8455 | OPTI_TYPE_EARLY_SKIP
8456 | OPTI_TYPE_NOT_ITERATED
8457 | OPTI_TYPE_NOT_SALTED
8458 | OPTI_TYPE_RAW_HASH;
8459 dgst_pos0 = 3;
8460 dgst_pos1 = 4;
8461 dgst_pos2 = 2;
8462 dgst_pos3 = 1;
8463 break;
8464
8465 case 4800: hash_type = HASH_TYPE_MD5;
8466 salt_type = SALT_TYPE_EMBEDDED;
8467 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8468 opts_type = OPTS_TYPE_PT_GENERATE_LE
8469 | OPTS_TYPE_PT_ADDBITS14;
8470 kern_type = KERN_TYPE_MD5_CHAP;
8471 dgst_size = DGST_SIZE_4_4;
8472 parse_func = chap_parse_hash;
8473 sort_by_digest = sort_by_digest_4_4;
8474 opti_type = OPTI_TYPE_ZERO_BYTE
8475 | OPTI_TYPE_PRECOMPUTE_INIT
8476 | OPTI_TYPE_PRECOMPUTE_MERKLE
8477 | OPTI_TYPE_MEET_IN_MIDDLE
8478 | OPTI_TYPE_EARLY_SKIP
8479 | OPTI_TYPE_NOT_ITERATED
8480 | OPTI_TYPE_RAW_HASH;
8481 dgst_pos0 = 0;
8482 dgst_pos1 = 3;
8483 dgst_pos2 = 2;
8484 dgst_pos3 = 1;
8485 break;
8486
8487 case 4900: hash_type = HASH_TYPE_SHA1;
8488 salt_type = SALT_TYPE_INTERN;
8489 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8490 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8491 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8492 dgst_size = DGST_SIZE_4_5;
8493 parse_func = sha1s_parse_hash;
8494 sort_by_digest = sort_by_digest_4_5;
8495 opti_type = OPTI_TYPE_ZERO_BYTE
8496 | OPTI_TYPE_PRECOMPUTE_INIT
8497 | OPTI_TYPE_PRECOMPUTE_MERKLE
8498 | OPTI_TYPE_EARLY_SKIP;
8499 dgst_pos0 = 3;
8500 dgst_pos1 = 4;
8501 dgst_pos2 = 2;
8502 dgst_pos3 = 1;
8503 break;
8504
8505 case 5000: hash_type = HASH_TYPE_KECCAK;
8506 salt_type = SALT_TYPE_EMBEDDED;
8507 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8508 opts_type = OPTS_TYPE_PT_GENERATE_LE
8509 | OPTS_TYPE_PT_ADD01;
8510 kern_type = KERN_TYPE_KECCAK;
8511 dgst_size = DGST_SIZE_8_25;
8512 parse_func = keccak_parse_hash;
8513 sort_by_digest = sort_by_digest_8_25;
8514 opti_type = OPTI_TYPE_ZERO_BYTE
8515 | OPTI_TYPE_USES_BITS_64
8516 | OPTI_TYPE_RAW_HASH;
8517 dgst_pos0 = 2;
8518 dgst_pos1 = 3;
8519 dgst_pos2 = 4;
8520 dgst_pos3 = 5;
8521 break;
8522
8523 case 5100: hash_type = HASH_TYPE_MD5H;
8524 salt_type = SALT_TYPE_NONE;
8525 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8526 opts_type = OPTS_TYPE_PT_GENERATE_LE
8527 | OPTS_TYPE_PT_ADD80
8528 | OPTS_TYPE_PT_ADDBITS14;
8529 kern_type = KERN_TYPE_MD5H;
8530 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8531 parse_func = md5half_parse_hash;
8532 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8533 opti_type = OPTI_TYPE_ZERO_BYTE
8534 | OPTI_TYPE_RAW_HASH;
8535 dgst_pos0 = 0;
8536 dgst_pos1 = 1;
8537 dgst_pos2 = 2;
8538 dgst_pos3 = 3;
8539 break;
8540
8541 case 5200: hash_type = HASH_TYPE_SHA256;
8542 salt_type = SALT_TYPE_EMBEDDED;
8543 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8544 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8545 kern_type = KERN_TYPE_PSAFE3;
8546 dgst_size = DGST_SIZE_4_8;
8547 parse_func = psafe3_parse_hash;
8548 sort_by_digest = sort_by_digest_4_8;
8549 opti_type = OPTI_TYPE_ZERO_BYTE;
8550 dgst_pos0 = 0;
8551 dgst_pos1 = 1;
8552 dgst_pos2 = 2;
8553 dgst_pos3 = 3;
8554 break;
8555
8556 case 5300: hash_type = HASH_TYPE_MD5;
8557 salt_type = SALT_TYPE_EMBEDDED;
8558 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8559 opts_type = OPTS_TYPE_PT_GENERATE_LE
8560 | OPTS_TYPE_ST_ADD80;
8561 kern_type = KERN_TYPE_IKEPSK_MD5;
8562 dgst_size = DGST_SIZE_4_4;
8563 parse_func = ikepsk_md5_parse_hash;
8564 sort_by_digest = sort_by_digest_4_4;
8565 opti_type = OPTI_TYPE_ZERO_BYTE;
8566 dgst_pos0 = 0;
8567 dgst_pos1 = 3;
8568 dgst_pos2 = 2;
8569 dgst_pos3 = 1;
8570 break;
8571
8572 case 5400: hash_type = HASH_TYPE_SHA1;
8573 salt_type = SALT_TYPE_EMBEDDED;
8574 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8575 opts_type = OPTS_TYPE_PT_GENERATE_BE
8576 | OPTS_TYPE_ST_ADD80;
8577 kern_type = KERN_TYPE_IKEPSK_SHA1;
8578 dgst_size = DGST_SIZE_4_5;
8579 parse_func = ikepsk_sha1_parse_hash;
8580 sort_by_digest = sort_by_digest_4_5;
8581 opti_type = OPTI_TYPE_ZERO_BYTE;
8582 dgst_pos0 = 3;
8583 dgst_pos1 = 4;
8584 dgst_pos2 = 2;
8585 dgst_pos3 = 1;
8586 break;
8587
8588 case 5500: hash_type = HASH_TYPE_NETNTLM;
8589 salt_type = SALT_TYPE_EMBEDDED;
8590 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8591 opts_type = OPTS_TYPE_PT_GENERATE_LE
8592 | OPTS_TYPE_PT_ADD80
8593 | OPTS_TYPE_PT_ADDBITS14
8594 | OPTS_TYPE_PT_UNICODE
8595 | OPTS_TYPE_ST_HEX;
8596 kern_type = KERN_TYPE_NETNTLMv1;
8597 dgst_size = DGST_SIZE_4_4;
8598 parse_func = netntlmv1_parse_hash;
8599 sort_by_digest = sort_by_digest_4_4;
8600 opti_type = OPTI_TYPE_ZERO_BYTE
8601 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8602 dgst_pos0 = 0;
8603 dgst_pos1 = 1;
8604 dgst_pos2 = 2;
8605 dgst_pos3 = 3;
8606 break;
8607
8608 case 5600: hash_type = HASH_TYPE_MD5;
8609 salt_type = SALT_TYPE_EMBEDDED;
8610 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8611 opts_type = OPTS_TYPE_PT_GENERATE_LE
8612 | OPTS_TYPE_PT_ADD80
8613 | OPTS_TYPE_PT_ADDBITS14
8614 | OPTS_TYPE_PT_UNICODE;
8615 kern_type = KERN_TYPE_NETNTLMv2;
8616 dgst_size = DGST_SIZE_4_4;
8617 parse_func = netntlmv2_parse_hash;
8618 sort_by_digest = sort_by_digest_4_4;
8619 opti_type = OPTI_TYPE_ZERO_BYTE;
8620 dgst_pos0 = 0;
8621 dgst_pos1 = 3;
8622 dgst_pos2 = 2;
8623 dgst_pos3 = 1;
8624 break;
8625
8626 case 5700: hash_type = HASH_TYPE_SHA256;
8627 salt_type = SALT_TYPE_NONE;
8628 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8629 opts_type = OPTS_TYPE_PT_GENERATE_BE
8630 | OPTS_TYPE_PT_ADD80
8631 | OPTS_TYPE_PT_ADDBITS15;
8632 kern_type = KERN_TYPE_SHA256;
8633 dgst_size = DGST_SIZE_4_8;
8634 parse_func = cisco4_parse_hash;
8635 sort_by_digest = sort_by_digest_4_8;
8636 opti_type = OPTI_TYPE_ZERO_BYTE
8637 | OPTI_TYPE_PRECOMPUTE_INIT
8638 | OPTI_TYPE_PRECOMPUTE_MERKLE
8639 | OPTI_TYPE_EARLY_SKIP
8640 | OPTI_TYPE_NOT_ITERATED
8641 | OPTI_TYPE_NOT_SALTED
8642 | OPTI_TYPE_RAW_HASH;
8643 dgst_pos0 = 3;
8644 dgst_pos1 = 7;
8645 dgst_pos2 = 2;
8646 dgst_pos3 = 6;
8647 break;
8648
8649 case 5800: hash_type = HASH_TYPE_SHA1;
8650 salt_type = SALT_TYPE_INTERN;
8651 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8652 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8653 | OPTS_TYPE_ST_ADD80;
8654 kern_type = KERN_TYPE_ANDROIDPIN;
8655 dgst_size = DGST_SIZE_4_5;
8656 parse_func = androidpin_parse_hash;
8657 sort_by_digest = sort_by_digest_4_5;
8658 opti_type = OPTI_TYPE_ZERO_BYTE;
8659 dgst_pos0 = 0;
8660 dgst_pos1 = 1;
8661 dgst_pos2 = 2;
8662 dgst_pos3 = 3;
8663 break;
8664
8665 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8666 salt_type = SALT_TYPE_NONE;
8667 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8668 opts_type = OPTS_TYPE_PT_GENERATE_LE
8669 | OPTS_TYPE_PT_ADD80;
8670 kern_type = KERN_TYPE_RIPEMD160;
8671 dgst_size = DGST_SIZE_4_5;
8672 parse_func = ripemd160_parse_hash;
8673 sort_by_digest = sort_by_digest_4_5;
8674 opti_type = OPTI_TYPE_ZERO_BYTE;
8675 dgst_pos0 = 0;
8676 dgst_pos1 = 1;
8677 dgst_pos2 = 2;
8678 dgst_pos3 = 3;
8679 break;
8680
8681 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8682 salt_type = SALT_TYPE_NONE;
8683 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8684 opts_type = OPTS_TYPE_PT_GENERATE_BE
8685 | OPTS_TYPE_PT_ADD80;
8686 kern_type = KERN_TYPE_WHIRLPOOL;
8687 dgst_size = DGST_SIZE_4_16;
8688 parse_func = whirlpool_parse_hash;
8689 sort_by_digest = sort_by_digest_4_16;
8690 opti_type = OPTI_TYPE_ZERO_BYTE;
8691 dgst_pos0 = 0;
8692 dgst_pos1 = 1;
8693 dgst_pos2 = 2;
8694 dgst_pos3 = 3;
8695 break;
8696
8697 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8698 salt_type = SALT_TYPE_EMBEDDED;
8699 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8700 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8701 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8702 dgst_size = DGST_SIZE_4_5;
8703 parse_func = truecrypt_parse_hash_2k;
8704 sort_by_digest = sort_by_digest_4_5;
8705 opti_type = OPTI_TYPE_ZERO_BYTE;
8706 dgst_pos0 = 0;
8707 dgst_pos1 = 1;
8708 dgst_pos2 = 2;
8709 dgst_pos3 = 3;
8710 break;
8711
8712 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8713 salt_type = SALT_TYPE_EMBEDDED;
8714 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8715 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8716 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8717 dgst_size = DGST_SIZE_4_5;
8718 parse_func = truecrypt_parse_hash_2k;
8719 sort_by_digest = sort_by_digest_4_5;
8720 opti_type = OPTI_TYPE_ZERO_BYTE;
8721 dgst_pos0 = 0;
8722 dgst_pos1 = 1;
8723 dgst_pos2 = 2;
8724 dgst_pos3 = 3;
8725 break;
8726
8727 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8728 salt_type = SALT_TYPE_EMBEDDED;
8729 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8730 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8731 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8732 dgst_size = DGST_SIZE_4_5;
8733 parse_func = truecrypt_parse_hash_2k;
8734 sort_by_digest = sort_by_digest_4_5;
8735 opti_type = OPTI_TYPE_ZERO_BYTE;
8736 dgst_pos0 = 0;
8737 dgst_pos1 = 1;
8738 dgst_pos2 = 2;
8739 dgst_pos3 = 3;
8740 break;
8741
8742 case 6221: hash_type = HASH_TYPE_SHA512;
8743 salt_type = SALT_TYPE_EMBEDDED;
8744 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8745 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8746 kern_type = KERN_TYPE_TCSHA512_XTS512;
8747 dgst_size = DGST_SIZE_8_8;
8748 parse_func = truecrypt_parse_hash_1k;
8749 sort_by_digest = sort_by_digest_8_8;
8750 opti_type = OPTI_TYPE_ZERO_BYTE
8751 | OPTI_TYPE_USES_BITS_64;
8752 dgst_pos0 = 0;
8753 dgst_pos1 = 1;
8754 dgst_pos2 = 2;
8755 dgst_pos3 = 3;
8756 break;
8757
8758 case 6222: hash_type = HASH_TYPE_SHA512;
8759 salt_type = SALT_TYPE_EMBEDDED;
8760 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8761 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8762 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8763 dgst_size = DGST_SIZE_8_8;
8764 parse_func = truecrypt_parse_hash_1k;
8765 sort_by_digest = sort_by_digest_8_8;
8766 opti_type = OPTI_TYPE_ZERO_BYTE
8767 | OPTI_TYPE_USES_BITS_64;
8768 dgst_pos0 = 0;
8769 dgst_pos1 = 1;
8770 dgst_pos2 = 2;
8771 dgst_pos3 = 3;
8772 break;
8773
8774 case 6223: hash_type = HASH_TYPE_SHA512;
8775 salt_type = SALT_TYPE_EMBEDDED;
8776 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8777 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8778 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8779 dgst_size = DGST_SIZE_8_8;
8780 parse_func = truecrypt_parse_hash_1k;
8781 sort_by_digest = sort_by_digest_8_8;
8782 opti_type = OPTI_TYPE_ZERO_BYTE
8783 | OPTI_TYPE_USES_BITS_64;
8784 dgst_pos0 = 0;
8785 dgst_pos1 = 1;
8786 dgst_pos2 = 2;
8787 dgst_pos3 = 3;
8788 break;
8789
8790 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8791 salt_type = SALT_TYPE_EMBEDDED;
8792 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8793 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8794 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8795 dgst_size = DGST_SIZE_4_8;
8796 parse_func = truecrypt_parse_hash_1k;
8797 sort_by_digest = sort_by_digest_4_8;
8798 opti_type = OPTI_TYPE_ZERO_BYTE;
8799 dgst_pos0 = 0;
8800 dgst_pos1 = 1;
8801 dgst_pos2 = 2;
8802 dgst_pos3 = 3;
8803 break;
8804
8805 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8806 salt_type = SALT_TYPE_EMBEDDED;
8807 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8808 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8809 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8810 dgst_size = DGST_SIZE_4_8;
8811 parse_func = truecrypt_parse_hash_1k;
8812 sort_by_digest = sort_by_digest_4_8;
8813 opti_type = OPTI_TYPE_ZERO_BYTE;
8814 dgst_pos0 = 0;
8815 dgst_pos1 = 1;
8816 dgst_pos2 = 2;
8817 dgst_pos3 = 3;
8818 break;
8819
8820 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8821 salt_type = SALT_TYPE_EMBEDDED;
8822 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8823 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8824 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8825 dgst_size = DGST_SIZE_4_8;
8826 parse_func = truecrypt_parse_hash_1k;
8827 sort_by_digest = sort_by_digest_4_8;
8828 opti_type = OPTI_TYPE_ZERO_BYTE;
8829 dgst_pos0 = 0;
8830 dgst_pos1 = 1;
8831 dgst_pos2 = 2;
8832 dgst_pos3 = 3;
8833 break;
8834
8835 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8836 salt_type = SALT_TYPE_EMBEDDED;
8837 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8838 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8839 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8840 dgst_size = DGST_SIZE_4_5;
8841 parse_func = truecrypt_parse_hash_1k;
8842 sort_by_digest = sort_by_digest_4_5;
8843 opti_type = OPTI_TYPE_ZERO_BYTE;
8844 dgst_pos0 = 0;
8845 dgst_pos1 = 1;
8846 dgst_pos2 = 2;
8847 dgst_pos3 = 3;
8848 break;
8849
8850 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8851 salt_type = SALT_TYPE_EMBEDDED;
8852 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8853 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8854 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8855 dgst_size = DGST_SIZE_4_5;
8856 parse_func = truecrypt_parse_hash_1k;
8857 sort_by_digest = sort_by_digest_4_5;
8858 opti_type = OPTI_TYPE_ZERO_BYTE;
8859 dgst_pos0 = 0;
8860 dgst_pos1 = 1;
8861 dgst_pos2 = 2;
8862 dgst_pos3 = 3;
8863 break;
8864
8865 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8866 salt_type = SALT_TYPE_EMBEDDED;
8867 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8868 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8869 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8870 dgst_size = DGST_SIZE_4_5;
8871 parse_func = truecrypt_parse_hash_1k;
8872 sort_by_digest = sort_by_digest_4_5;
8873 opti_type = OPTI_TYPE_ZERO_BYTE;
8874 dgst_pos0 = 0;
8875 dgst_pos1 = 1;
8876 dgst_pos2 = 2;
8877 dgst_pos3 = 3;
8878 break;
8879
8880 case 6300: hash_type = HASH_TYPE_MD5;
8881 salt_type = SALT_TYPE_EMBEDDED;
8882 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8883 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8884 kern_type = KERN_TYPE_MD5AIX;
8885 dgst_size = DGST_SIZE_4_4;
8886 parse_func = md5aix_parse_hash;
8887 sort_by_digest = sort_by_digest_4_4;
8888 opti_type = OPTI_TYPE_ZERO_BYTE;
8889 dgst_pos0 = 0;
8890 dgst_pos1 = 1;
8891 dgst_pos2 = 2;
8892 dgst_pos3 = 3;
8893 break;
8894
8895 case 6400: hash_type = HASH_TYPE_SHA256;
8896 salt_type = SALT_TYPE_EMBEDDED;
8897 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8898 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8899 kern_type = KERN_TYPE_SHA256AIX;
8900 dgst_size = DGST_SIZE_4_8;
8901 parse_func = sha256aix_parse_hash;
8902 sort_by_digest = sort_by_digest_4_8;
8903 opti_type = OPTI_TYPE_ZERO_BYTE;
8904 dgst_pos0 = 0;
8905 dgst_pos1 = 1;
8906 dgst_pos2 = 2;
8907 dgst_pos3 = 3;
8908 break;
8909
8910 case 6500: hash_type = HASH_TYPE_SHA512;
8911 salt_type = SALT_TYPE_EMBEDDED;
8912 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8913 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8914 kern_type = KERN_TYPE_SHA512AIX;
8915 dgst_size = DGST_SIZE_8_8;
8916 parse_func = sha512aix_parse_hash;
8917 sort_by_digest = sort_by_digest_8_8;
8918 opti_type = OPTI_TYPE_ZERO_BYTE
8919 | OPTI_TYPE_USES_BITS_64;
8920 dgst_pos0 = 0;
8921 dgst_pos1 = 1;
8922 dgst_pos2 = 2;
8923 dgst_pos3 = 3;
8924 break;
8925
8926 case 6600: hash_type = HASH_TYPE_AES;
8927 salt_type = SALT_TYPE_EMBEDDED;
8928 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8929 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8930 kern_type = KERN_TYPE_AGILEKEY;
8931 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8932 parse_func = agilekey_parse_hash;
8933 sort_by_digest = sort_by_digest_4_5;
8934 opti_type = OPTI_TYPE_ZERO_BYTE;
8935 dgst_pos0 = 0;
8936 dgst_pos1 = 1;
8937 dgst_pos2 = 2;
8938 dgst_pos3 = 3;
8939 break;
8940
8941 case 6700: hash_type = HASH_TYPE_SHA1;
8942 salt_type = SALT_TYPE_EMBEDDED;
8943 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8944 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8945 kern_type = KERN_TYPE_SHA1AIX;
8946 dgst_size = DGST_SIZE_4_5;
8947 parse_func = sha1aix_parse_hash;
8948 sort_by_digest = sort_by_digest_4_5;
8949 opti_type = OPTI_TYPE_ZERO_BYTE;
8950 dgst_pos0 = 0;
8951 dgst_pos1 = 1;
8952 dgst_pos2 = 2;
8953 dgst_pos3 = 3;
8954 break;
8955
8956 case 6800: hash_type = HASH_TYPE_AES;
8957 salt_type = SALT_TYPE_EMBEDDED;
8958 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8959 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8960 kern_type = KERN_TYPE_LASTPASS;
8961 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8962 parse_func = lastpass_parse_hash;
8963 sort_by_digest = sort_by_digest_4_8;
8964 opti_type = OPTI_TYPE_ZERO_BYTE;
8965 dgst_pos0 = 0;
8966 dgst_pos1 = 1;
8967 dgst_pos2 = 2;
8968 dgst_pos3 = 3;
8969 break;
8970
8971 case 6900: hash_type = HASH_TYPE_GOST;
8972 salt_type = SALT_TYPE_NONE;
8973 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8974 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8975 kern_type = KERN_TYPE_GOST;
8976 dgst_size = DGST_SIZE_4_8;
8977 parse_func = gost_parse_hash;
8978 sort_by_digest = sort_by_digest_4_8;
8979 opti_type = OPTI_TYPE_ZERO_BYTE;
8980 dgst_pos0 = 0;
8981 dgst_pos1 = 1;
8982 dgst_pos2 = 2;
8983 dgst_pos3 = 3;
8984 break;
8985
8986 case 7100: hash_type = HASH_TYPE_SHA512;
8987 salt_type = SALT_TYPE_EMBEDDED;
8988 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8989 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8990 kern_type = KERN_TYPE_PBKDF2_SHA512;
8991 dgst_size = DGST_SIZE_8_16;
8992 parse_func = sha512osx_parse_hash;
8993 sort_by_digest = sort_by_digest_8_16;
8994 opti_type = OPTI_TYPE_ZERO_BYTE
8995 | OPTI_TYPE_USES_BITS_64
8996 | OPTI_TYPE_SLOW_HASH_SIMD;
8997 dgst_pos0 = 0;
8998 dgst_pos1 = 1;
8999 dgst_pos2 = 2;
9000 dgst_pos3 = 3;
9001 break;
9002
9003 case 7200: hash_type = HASH_TYPE_SHA512;
9004 salt_type = SALT_TYPE_EMBEDDED;
9005 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9006 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9007 kern_type = KERN_TYPE_PBKDF2_SHA512;
9008 dgst_size = DGST_SIZE_8_16;
9009 parse_func = sha512grub_parse_hash;
9010 sort_by_digest = sort_by_digest_8_16;
9011 opti_type = OPTI_TYPE_ZERO_BYTE
9012 | OPTI_TYPE_USES_BITS_64
9013 | OPTI_TYPE_SLOW_HASH_SIMD;
9014 dgst_pos0 = 0;
9015 dgst_pos1 = 1;
9016 dgst_pos2 = 2;
9017 dgst_pos3 = 3;
9018 break;
9019
9020 case 7300: hash_type = HASH_TYPE_SHA1;
9021 salt_type = SALT_TYPE_EMBEDDED;
9022 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9023 opts_type = OPTS_TYPE_PT_GENERATE_BE
9024 | OPTS_TYPE_ST_ADD80
9025 | OPTS_TYPE_ST_ADDBITS15;
9026 kern_type = KERN_TYPE_RAKP;
9027 dgst_size = DGST_SIZE_4_5;
9028 parse_func = rakp_parse_hash;
9029 sort_by_digest = sort_by_digest_4_5;
9030 opti_type = OPTI_TYPE_ZERO_BYTE
9031 | OPTI_TYPE_NOT_ITERATED;
9032 dgst_pos0 = 3;
9033 dgst_pos1 = 4;
9034 dgst_pos2 = 2;
9035 dgst_pos3 = 1;
9036 break;
9037
9038 case 7400: hash_type = HASH_TYPE_SHA256;
9039 salt_type = SALT_TYPE_EMBEDDED;
9040 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9041 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9042 kern_type = KERN_TYPE_SHA256CRYPT;
9043 dgst_size = DGST_SIZE_4_8;
9044 parse_func = sha256crypt_parse_hash;
9045 sort_by_digest = sort_by_digest_4_8;
9046 opti_type = OPTI_TYPE_ZERO_BYTE;
9047 dgst_pos0 = 0;
9048 dgst_pos1 = 1;
9049 dgst_pos2 = 2;
9050 dgst_pos3 = 3;
9051 break;
9052
9053 case 7500: hash_type = HASH_TYPE_KRB5PA;
9054 salt_type = SALT_TYPE_EMBEDDED;
9055 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9056 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9057 kern_type = KERN_TYPE_KRB5PA;
9058 dgst_size = DGST_SIZE_4_4;
9059 parse_func = krb5pa_parse_hash;
9060 sort_by_digest = sort_by_digest_4_4;
9061 opti_type = OPTI_TYPE_ZERO_BYTE
9062 | OPTI_TYPE_NOT_ITERATED;
9063 dgst_pos0 = 0;
9064 dgst_pos1 = 1;
9065 dgst_pos2 = 2;
9066 dgst_pos3 = 3;
9067 break;
9068
9069 case 7600: hash_type = HASH_TYPE_SHA1;
9070 salt_type = SALT_TYPE_INTERN;
9071 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9072 opts_type = OPTS_TYPE_PT_GENERATE_BE
9073 | OPTS_TYPE_PT_ADD80
9074 | OPTS_TYPE_PT_ADDBITS15;
9075 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9076 dgst_size = DGST_SIZE_4_5;
9077 parse_func = redmine_parse_hash;
9078 sort_by_digest = sort_by_digest_4_5;
9079 opti_type = OPTI_TYPE_ZERO_BYTE
9080 | OPTI_TYPE_PRECOMPUTE_INIT
9081 | OPTI_TYPE_EARLY_SKIP
9082 | OPTI_TYPE_NOT_ITERATED
9083 | OPTI_TYPE_PREPENDED_SALT;
9084 dgst_pos0 = 3;
9085 dgst_pos1 = 4;
9086 dgst_pos2 = 2;
9087 dgst_pos3 = 1;
9088 break;
9089
9090 case 7700: hash_type = HASH_TYPE_SAPB;
9091 salt_type = SALT_TYPE_EMBEDDED;
9092 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9093 opts_type = OPTS_TYPE_PT_GENERATE_LE
9094 | OPTS_TYPE_PT_UPPER
9095 | OPTS_TYPE_ST_UPPER;
9096 kern_type = KERN_TYPE_SAPB;
9097 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9098 parse_func = sapb_parse_hash;
9099 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9100 opti_type = OPTI_TYPE_ZERO_BYTE
9101 | OPTI_TYPE_PRECOMPUTE_INIT
9102 | OPTI_TYPE_NOT_ITERATED;
9103 dgst_pos0 = 0;
9104 dgst_pos1 = 1;
9105 dgst_pos2 = 2;
9106 dgst_pos3 = 3;
9107 break;
9108
9109 case 7800: hash_type = HASH_TYPE_SAPG;
9110 salt_type = SALT_TYPE_EMBEDDED;
9111 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9112 opts_type = OPTS_TYPE_PT_GENERATE_BE
9113 | OPTS_TYPE_ST_ADD80
9114 | OPTS_TYPE_ST_UPPER;
9115 kern_type = KERN_TYPE_SAPG;
9116 dgst_size = DGST_SIZE_4_5;
9117 parse_func = sapg_parse_hash;
9118 sort_by_digest = sort_by_digest_4_5;
9119 opti_type = OPTI_TYPE_ZERO_BYTE
9120 | OPTI_TYPE_PRECOMPUTE_INIT
9121 | OPTI_TYPE_NOT_ITERATED;
9122 dgst_pos0 = 3;
9123 dgst_pos1 = 4;
9124 dgst_pos2 = 2;
9125 dgst_pos3 = 1;
9126 break;
9127
9128 case 7900: hash_type = HASH_TYPE_SHA512;
9129 salt_type = SALT_TYPE_EMBEDDED;
9130 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9131 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9132 kern_type = KERN_TYPE_DRUPAL7;
9133 dgst_size = DGST_SIZE_8_8;
9134 parse_func = drupal7_parse_hash;
9135 sort_by_digest = sort_by_digest_8_8;
9136 opti_type = OPTI_TYPE_ZERO_BYTE
9137 | OPTI_TYPE_USES_BITS_64;
9138 dgst_pos0 = 0;
9139 dgst_pos1 = 1;
9140 dgst_pos2 = 2;
9141 dgst_pos3 = 3;
9142 break;
9143
9144 case 8000: hash_type = HASH_TYPE_SHA256;
9145 salt_type = SALT_TYPE_EMBEDDED;
9146 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9147 opts_type = OPTS_TYPE_PT_GENERATE_BE
9148 | OPTS_TYPE_PT_UNICODE
9149 | OPTS_TYPE_ST_ADD80
9150 | OPTS_TYPE_ST_HEX;
9151 kern_type = KERN_TYPE_SYBASEASE;
9152 dgst_size = DGST_SIZE_4_8;
9153 parse_func = sybasease_parse_hash;
9154 sort_by_digest = sort_by_digest_4_8;
9155 opti_type = OPTI_TYPE_ZERO_BYTE
9156 | OPTI_TYPE_PRECOMPUTE_INIT
9157 | OPTI_TYPE_EARLY_SKIP
9158 | OPTI_TYPE_NOT_ITERATED
9159 | OPTI_TYPE_RAW_HASH;
9160 dgst_pos0 = 3;
9161 dgst_pos1 = 7;
9162 dgst_pos2 = 2;
9163 dgst_pos3 = 6;
9164 break;
9165
9166 case 8100: hash_type = HASH_TYPE_SHA1;
9167 salt_type = SALT_TYPE_EMBEDDED;
9168 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9169 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9170 kern_type = KERN_TYPE_NETSCALER;
9171 dgst_size = DGST_SIZE_4_5;
9172 parse_func = netscaler_parse_hash;
9173 sort_by_digest = sort_by_digest_4_5;
9174 opti_type = OPTI_TYPE_ZERO_BYTE
9175 | OPTI_TYPE_PRECOMPUTE_INIT
9176 | OPTI_TYPE_PRECOMPUTE_MERKLE
9177 | OPTI_TYPE_EARLY_SKIP
9178 | OPTI_TYPE_NOT_ITERATED
9179 | OPTI_TYPE_PREPENDED_SALT
9180 | OPTI_TYPE_RAW_HASH;
9181 dgst_pos0 = 3;
9182 dgst_pos1 = 4;
9183 dgst_pos2 = 2;
9184 dgst_pos3 = 1;
9185 break;
9186
9187 case 8200: hash_type = HASH_TYPE_SHA256;
9188 salt_type = SALT_TYPE_EMBEDDED;
9189 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9190 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9191 kern_type = KERN_TYPE_CLOUDKEY;
9192 dgst_size = DGST_SIZE_4_8;
9193 parse_func = cloudkey_parse_hash;
9194 sort_by_digest = sort_by_digest_4_8;
9195 opti_type = OPTI_TYPE_ZERO_BYTE;
9196 dgst_pos0 = 0;
9197 dgst_pos1 = 1;
9198 dgst_pos2 = 2;
9199 dgst_pos3 = 3;
9200 break;
9201
9202 case 8300: hash_type = HASH_TYPE_SHA1;
9203 salt_type = SALT_TYPE_EMBEDDED;
9204 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9205 opts_type = OPTS_TYPE_PT_GENERATE_BE
9206 | OPTS_TYPE_ST_HEX
9207 | OPTS_TYPE_ST_ADD80;
9208 kern_type = KERN_TYPE_NSEC3;
9209 dgst_size = DGST_SIZE_4_5;
9210 parse_func = nsec3_parse_hash;
9211 sort_by_digest = sort_by_digest_4_5;
9212 opti_type = OPTI_TYPE_ZERO_BYTE;
9213 dgst_pos0 = 3;
9214 dgst_pos1 = 4;
9215 dgst_pos2 = 2;
9216 dgst_pos3 = 1;
9217 break;
9218
9219 case 8400: hash_type = HASH_TYPE_SHA1;
9220 salt_type = SALT_TYPE_INTERN;
9221 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9222 opts_type = OPTS_TYPE_PT_GENERATE_BE
9223 | OPTS_TYPE_PT_ADD80
9224 | OPTS_TYPE_PT_ADDBITS15;
9225 kern_type = KERN_TYPE_WBB3;
9226 dgst_size = DGST_SIZE_4_5;
9227 parse_func = wbb3_parse_hash;
9228 sort_by_digest = sort_by_digest_4_5;
9229 opti_type = OPTI_TYPE_ZERO_BYTE
9230 | OPTI_TYPE_PRECOMPUTE_INIT
9231 | OPTI_TYPE_NOT_ITERATED;
9232 dgst_pos0 = 3;
9233 dgst_pos1 = 4;
9234 dgst_pos2 = 2;
9235 dgst_pos3 = 1;
9236 break;
9237
9238 case 8500: hash_type = HASH_TYPE_DESRACF;
9239 salt_type = SALT_TYPE_EMBEDDED;
9240 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9241 opts_type = OPTS_TYPE_PT_GENERATE_LE
9242 | OPTS_TYPE_ST_UPPER;
9243 kern_type = KERN_TYPE_RACF;
9244 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9245 parse_func = racf_parse_hash;
9246 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9247 opti_type = OPTI_TYPE_ZERO_BYTE
9248 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9249 dgst_pos0 = 0;
9250 dgst_pos1 = 1;
9251 dgst_pos2 = 2;
9252 dgst_pos3 = 3;
9253 break;
9254
9255 case 8600: hash_type = HASH_TYPE_LOTUS5;
9256 salt_type = SALT_TYPE_NONE;
9257 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9258 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9259 kern_type = KERN_TYPE_LOTUS5;
9260 dgst_size = DGST_SIZE_4_4;
9261 parse_func = lotus5_parse_hash;
9262 sort_by_digest = sort_by_digest_4_4;
9263 opti_type = OPTI_TYPE_EARLY_SKIP
9264 | OPTI_TYPE_NOT_ITERATED
9265 | OPTI_TYPE_NOT_SALTED
9266 | OPTI_TYPE_RAW_HASH;
9267 dgst_pos0 = 0;
9268 dgst_pos1 = 1;
9269 dgst_pos2 = 2;
9270 dgst_pos3 = 3;
9271 break;
9272
9273 case 8700: hash_type = HASH_TYPE_LOTUS6;
9274 salt_type = SALT_TYPE_EMBEDDED;
9275 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9276 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9277 kern_type = KERN_TYPE_LOTUS6;
9278 dgst_size = DGST_SIZE_4_4;
9279 parse_func = lotus6_parse_hash;
9280 sort_by_digest = sort_by_digest_4_4;
9281 opti_type = OPTI_TYPE_EARLY_SKIP
9282 | OPTI_TYPE_NOT_ITERATED
9283 | OPTI_TYPE_RAW_HASH;
9284 dgst_pos0 = 0;
9285 dgst_pos1 = 1;
9286 dgst_pos2 = 2;
9287 dgst_pos3 = 3;
9288 break;
9289
9290 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9291 salt_type = SALT_TYPE_EMBEDDED;
9292 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9293 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9294 kern_type = KERN_TYPE_ANDROIDFDE;
9295 dgst_size = DGST_SIZE_4_4;
9296 parse_func = androidfde_parse_hash;
9297 sort_by_digest = sort_by_digest_4_4;
9298 opti_type = OPTI_TYPE_ZERO_BYTE;
9299 dgst_pos0 = 0;
9300 dgst_pos1 = 1;
9301 dgst_pos2 = 2;
9302 dgst_pos3 = 3;
9303 break;
9304
9305 case 8900: hash_type = HASH_TYPE_SCRYPT;
9306 salt_type = SALT_TYPE_EMBEDDED;
9307 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9308 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9309 kern_type = KERN_TYPE_SCRYPT;
9310 dgst_size = DGST_SIZE_4_8;
9311 parse_func = scrypt_parse_hash;
9312 sort_by_digest = sort_by_digest_4_8;
9313 opti_type = OPTI_TYPE_ZERO_BYTE;
9314 dgst_pos0 = 0;
9315 dgst_pos1 = 1;
9316 dgst_pos2 = 2;
9317 dgst_pos3 = 3;
9318 break;
9319
9320 case 9000: hash_type = HASH_TYPE_SHA1;
9321 salt_type = SALT_TYPE_EMBEDDED;
9322 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9323 opts_type = OPTS_TYPE_PT_GENERATE_LE
9324 | OPTS_TYPE_ST_GENERATE_LE;
9325 kern_type = KERN_TYPE_PSAFE2;
9326 dgst_size = DGST_SIZE_4_5;
9327 parse_func = psafe2_parse_hash;
9328 sort_by_digest = sort_by_digest_4_5;
9329 opti_type = OPTI_TYPE_ZERO_BYTE;
9330 dgst_pos0 = 0;
9331 dgst_pos1 = 1;
9332 dgst_pos2 = 2;
9333 dgst_pos3 = 3;
9334 break;
9335
9336 case 9100: hash_type = HASH_TYPE_LOTUS8;
9337 salt_type = SALT_TYPE_EMBEDDED;
9338 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9339 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9340 kern_type = KERN_TYPE_LOTUS8;
9341 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9342 parse_func = lotus8_parse_hash;
9343 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9344 opti_type = OPTI_TYPE_ZERO_BYTE;
9345 dgst_pos0 = 0;
9346 dgst_pos1 = 1;
9347 dgst_pos2 = 2;
9348 dgst_pos3 = 3;
9349 break;
9350
9351 case 9200: hash_type = HASH_TYPE_SHA256;
9352 salt_type = SALT_TYPE_EMBEDDED;
9353 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9354 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9355 kern_type = KERN_TYPE_PBKDF2_SHA256;
9356 dgst_size = DGST_SIZE_4_32;
9357 parse_func = cisco8_parse_hash;
9358 sort_by_digest = sort_by_digest_4_32;
9359 opti_type = OPTI_TYPE_ZERO_BYTE
9360 | OPTI_TYPE_SLOW_HASH_SIMD;
9361 dgst_pos0 = 0;
9362 dgst_pos1 = 1;
9363 dgst_pos2 = 2;
9364 dgst_pos3 = 3;
9365 break;
9366
9367 case 9300: hash_type = HASH_TYPE_SCRYPT;
9368 salt_type = SALT_TYPE_EMBEDDED;
9369 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9370 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9371 kern_type = KERN_TYPE_SCRYPT;
9372 dgst_size = DGST_SIZE_4_8;
9373 parse_func = cisco9_parse_hash;
9374 sort_by_digest = sort_by_digest_4_8;
9375 opti_type = OPTI_TYPE_ZERO_BYTE;
9376 dgst_pos0 = 0;
9377 dgst_pos1 = 1;
9378 dgst_pos2 = 2;
9379 dgst_pos3 = 3;
9380 break;
9381
9382 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9383 salt_type = SALT_TYPE_EMBEDDED;
9384 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9385 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9386 kern_type = KERN_TYPE_OFFICE2007;
9387 dgst_size = DGST_SIZE_4_4;
9388 parse_func = office2007_parse_hash;
9389 sort_by_digest = sort_by_digest_4_4;
9390 opti_type = OPTI_TYPE_ZERO_BYTE;
9391 dgst_pos0 = 0;
9392 dgst_pos1 = 1;
9393 dgst_pos2 = 2;
9394 dgst_pos3 = 3;
9395 break;
9396
9397 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9398 salt_type = SALT_TYPE_EMBEDDED;
9399 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9400 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9401 kern_type = KERN_TYPE_OFFICE2010;
9402 dgst_size = DGST_SIZE_4_4;
9403 parse_func = office2010_parse_hash;
9404 sort_by_digest = sort_by_digest_4_4;
9405 opti_type = OPTI_TYPE_ZERO_BYTE;
9406 dgst_pos0 = 0;
9407 dgst_pos1 = 1;
9408 dgst_pos2 = 2;
9409 dgst_pos3 = 3;
9410 break;
9411
9412 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9413 salt_type = SALT_TYPE_EMBEDDED;
9414 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9415 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9416 kern_type = KERN_TYPE_OFFICE2013;
9417 dgst_size = DGST_SIZE_4_4;
9418 parse_func = office2013_parse_hash;
9419 sort_by_digest = sort_by_digest_4_4;
9420 opti_type = OPTI_TYPE_ZERO_BYTE;
9421 dgst_pos0 = 0;
9422 dgst_pos1 = 1;
9423 dgst_pos2 = 2;
9424 dgst_pos3 = 3;
9425 break;
9426
9427 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9428 salt_type = SALT_TYPE_EMBEDDED;
9429 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9430 opts_type = OPTS_TYPE_PT_GENERATE_LE
9431 | OPTS_TYPE_PT_ADD80
9432 | OPTS_TYPE_PT_UNICODE;
9433 kern_type = KERN_TYPE_OLDOFFICE01;
9434 dgst_size = DGST_SIZE_4_4;
9435 parse_func = oldoffice01_parse_hash;
9436 sort_by_digest = sort_by_digest_4_4;
9437 opti_type = OPTI_TYPE_ZERO_BYTE
9438 | OPTI_TYPE_PRECOMPUTE_INIT
9439 | OPTI_TYPE_NOT_ITERATED;
9440 dgst_pos0 = 0;
9441 dgst_pos1 = 1;
9442 dgst_pos2 = 2;
9443 dgst_pos3 = 3;
9444 break;
9445
9446 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9447 salt_type = SALT_TYPE_EMBEDDED;
9448 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9449 opts_type = OPTS_TYPE_PT_GENERATE_LE
9450 | OPTS_TYPE_PT_ADD80;
9451 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9452 dgst_size = DGST_SIZE_4_4;
9453 parse_func = oldoffice01cm1_parse_hash;
9454 sort_by_digest = sort_by_digest_4_4;
9455 opti_type = OPTI_TYPE_ZERO_BYTE
9456 | OPTI_TYPE_PRECOMPUTE_INIT
9457 | OPTI_TYPE_NOT_ITERATED;
9458 dgst_pos0 = 0;
9459 dgst_pos1 = 1;
9460 dgst_pos2 = 2;
9461 dgst_pos3 = 3;
9462 break;
9463
9464 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9465 salt_type = SALT_TYPE_EMBEDDED;
9466 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9467 opts_type = OPTS_TYPE_PT_GENERATE_LE
9468 | OPTS_TYPE_PT_ADD80
9469 | OPTS_TYPE_PT_UNICODE
9470 | OPTS_TYPE_PT_NEVERCRACK;
9471 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9472 dgst_size = DGST_SIZE_4_4;
9473 parse_func = oldoffice01cm2_parse_hash;
9474 sort_by_digest = sort_by_digest_4_4;
9475 opti_type = OPTI_TYPE_ZERO_BYTE
9476 | OPTI_TYPE_PRECOMPUTE_INIT
9477 | OPTI_TYPE_NOT_ITERATED;
9478 dgst_pos0 = 0;
9479 dgst_pos1 = 1;
9480 dgst_pos2 = 2;
9481 dgst_pos3 = 3;
9482 break;
9483
9484 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9485 salt_type = SALT_TYPE_EMBEDDED;
9486 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9487 opts_type = OPTS_TYPE_PT_GENERATE_BE
9488 | OPTS_TYPE_PT_ADD80
9489 | OPTS_TYPE_PT_UNICODE;
9490 kern_type = KERN_TYPE_OLDOFFICE34;
9491 dgst_size = DGST_SIZE_4_4;
9492 parse_func = oldoffice34_parse_hash;
9493 sort_by_digest = sort_by_digest_4_4;
9494 opti_type = OPTI_TYPE_ZERO_BYTE
9495 | OPTI_TYPE_PRECOMPUTE_INIT
9496 | OPTI_TYPE_NOT_ITERATED;
9497 dgst_pos0 = 0;
9498 dgst_pos1 = 1;
9499 dgst_pos2 = 2;
9500 dgst_pos3 = 3;
9501 break;
9502
9503 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9504 salt_type = SALT_TYPE_EMBEDDED;
9505 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9506 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9507 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9508 dgst_size = DGST_SIZE_4_4;
9509 parse_func = oldoffice34cm1_parse_hash;
9510 sort_by_digest = sort_by_digest_4_4;
9511 opti_type = OPTI_TYPE_ZERO_BYTE
9512 | OPTI_TYPE_PRECOMPUTE_INIT
9513 | OPTI_TYPE_NOT_ITERATED;
9514 dgst_pos0 = 0;
9515 dgst_pos1 = 1;
9516 dgst_pos2 = 2;
9517 dgst_pos3 = 3;
9518 break;
9519
9520 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9521 salt_type = SALT_TYPE_EMBEDDED;
9522 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9523 opts_type = OPTS_TYPE_PT_GENERATE_BE
9524 | OPTS_TYPE_PT_ADD80
9525 | OPTS_TYPE_PT_UNICODE
9526 | OPTS_TYPE_PT_NEVERCRACK;
9527 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9528 dgst_size = DGST_SIZE_4_4;
9529 parse_func = oldoffice34cm2_parse_hash;
9530 sort_by_digest = sort_by_digest_4_4;
9531 opti_type = OPTI_TYPE_ZERO_BYTE
9532 | OPTI_TYPE_PRECOMPUTE_INIT
9533 | OPTI_TYPE_NOT_ITERATED;
9534 dgst_pos0 = 0;
9535 dgst_pos1 = 1;
9536 dgst_pos2 = 2;
9537 dgst_pos3 = 3;
9538 break;
9539
9540 case 9900: hash_type = HASH_TYPE_MD5;
9541 salt_type = SALT_TYPE_NONE;
9542 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9543 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9544 kern_type = KERN_TYPE_RADMIN2;
9545 dgst_size = DGST_SIZE_4_4;
9546 parse_func = radmin2_parse_hash;
9547 sort_by_digest = sort_by_digest_4_4;
9548 opti_type = OPTI_TYPE_ZERO_BYTE
9549 | OPTI_TYPE_PRECOMPUTE_INIT
9550 | OPTI_TYPE_EARLY_SKIP
9551 | OPTI_TYPE_NOT_ITERATED
9552 | OPTI_TYPE_NOT_SALTED;
9553 dgst_pos0 = 0;
9554 dgst_pos1 = 3;
9555 dgst_pos2 = 2;
9556 dgst_pos3 = 1;
9557 break;
9558
9559 case 10000: hash_type = HASH_TYPE_SHA256;
9560 salt_type = SALT_TYPE_EMBEDDED;
9561 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9562 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9563 kern_type = KERN_TYPE_PBKDF2_SHA256;
9564 dgst_size = DGST_SIZE_4_32;
9565 parse_func = djangopbkdf2_parse_hash;
9566 sort_by_digest = sort_by_digest_4_32;
9567 opti_type = OPTI_TYPE_ZERO_BYTE
9568 | OPTI_TYPE_SLOW_HASH_SIMD;
9569 dgst_pos0 = 0;
9570 dgst_pos1 = 1;
9571 dgst_pos2 = 2;
9572 dgst_pos3 = 3;
9573 break;
9574
9575 case 10100: hash_type = HASH_TYPE_SIPHASH;
9576 salt_type = SALT_TYPE_EMBEDDED;
9577 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9578 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9579 kern_type = KERN_TYPE_SIPHASH;
9580 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9581 parse_func = siphash_parse_hash;
9582 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9583 opti_type = OPTI_TYPE_ZERO_BYTE
9584 | OPTI_TYPE_NOT_ITERATED
9585 | OPTI_TYPE_RAW_HASH;
9586 dgst_pos0 = 0;
9587 dgst_pos1 = 1;
9588 dgst_pos2 = 2;
9589 dgst_pos3 = 3;
9590 break;
9591
9592 case 10200: hash_type = HASH_TYPE_MD5;
9593 salt_type = SALT_TYPE_EMBEDDED;
9594 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9595 opts_type = OPTS_TYPE_PT_GENERATE_LE
9596 | OPTS_TYPE_ST_ADD80
9597 | OPTS_TYPE_ST_ADDBITS14;
9598 kern_type = KERN_TYPE_HMACMD5_PW;
9599 dgst_size = DGST_SIZE_4_4;
9600 parse_func = crammd5_parse_hash;
9601 sort_by_digest = sort_by_digest_4_4;
9602 opti_type = OPTI_TYPE_ZERO_BYTE
9603 | OPTI_TYPE_NOT_ITERATED;
9604 dgst_pos0 = 0;
9605 dgst_pos1 = 3;
9606 dgst_pos2 = 2;
9607 dgst_pos3 = 1;
9608 break;
9609
9610 case 10300: hash_type = HASH_TYPE_SHA1;
9611 salt_type = SALT_TYPE_EMBEDDED;
9612 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9613 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9614 kern_type = KERN_TYPE_SAPH_SHA1;
9615 dgst_size = DGST_SIZE_4_5;
9616 parse_func = saph_sha1_parse_hash;
9617 sort_by_digest = sort_by_digest_4_5;
9618 opti_type = OPTI_TYPE_ZERO_BYTE;
9619 dgst_pos0 = 0;
9620 dgst_pos1 = 1;
9621 dgst_pos2 = 2;
9622 dgst_pos3 = 3;
9623 break;
9624
9625 case 10400: hash_type = HASH_TYPE_PDFU16;
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_PDF11;
9630 dgst_size = DGST_SIZE_4_4;
9631 parse_func = pdf11_parse_hash;
9632 sort_by_digest = sort_by_digest_4_4;
9633 opti_type = OPTI_TYPE_ZERO_BYTE
9634 | OPTI_TYPE_NOT_ITERATED;
9635 dgst_pos0 = 0;
9636 dgst_pos1 = 1;
9637 dgst_pos2 = 2;
9638 dgst_pos3 = 3;
9639 break;
9640
9641 case 10410: hash_type = HASH_TYPE_PDFU16;
9642 salt_type = SALT_TYPE_EMBEDDED;
9643 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9644 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9645 kern_type = KERN_TYPE_PDF11CM1;
9646 dgst_size = DGST_SIZE_4_4;
9647 parse_func = pdf11cm1_parse_hash;
9648 sort_by_digest = sort_by_digest_4_4;
9649 opti_type = OPTI_TYPE_ZERO_BYTE
9650 | OPTI_TYPE_NOT_ITERATED;
9651 dgst_pos0 = 0;
9652 dgst_pos1 = 1;
9653 dgst_pos2 = 2;
9654 dgst_pos3 = 3;
9655 break;
9656
9657 case 10420: hash_type = HASH_TYPE_PDFU16;
9658 salt_type = SALT_TYPE_EMBEDDED;
9659 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9660 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9661 kern_type = KERN_TYPE_PDF11CM2;
9662 dgst_size = DGST_SIZE_4_4;
9663 parse_func = pdf11cm2_parse_hash;
9664 sort_by_digest = sort_by_digest_4_4;
9665 opti_type = OPTI_TYPE_ZERO_BYTE
9666 | OPTI_TYPE_NOT_ITERATED;
9667 dgst_pos0 = 0;
9668 dgst_pos1 = 1;
9669 dgst_pos2 = 2;
9670 dgst_pos3 = 3;
9671 break;
9672
9673 case 10500: hash_type = HASH_TYPE_PDFU16;
9674 salt_type = SALT_TYPE_EMBEDDED;
9675 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9676 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9677 kern_type = KERN_TYPE_PDF14;
9678 dgst_size = DGST_SIZE_4_4;
9679 parse_func = pdf14_parse_hash;
9680 sort_by_digest = sort_by_digest_4_4;
9681 opti_type = OPTI_TYPE_ZERO_BYTE
9682 | OPTI_TYPE_NOT_ITERATED;
9683 dgst_pos0 = 0;
9684 dgst_pos1 = 1;
9685 dgst_pos2 = 2;
9686 dgst_pos3 = 3;
9687 break;
9688
9689 case 10600: hash_type = HASH_TYPE_SHA256;
9690 salt_type = SALT_TYPE_EMBEDDED;
9691 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9692 opts_type = OPTS_TYPE_PT_GENERATE_BE
9693 | OPTS_TYPE_ST_ADD80
9694 | OPTS_TYPE_ST_ADDBITS15
9695 | OPTS_TYPE_HASH_COPY;
9696 kern_type = KERN_TYPE_SHA256_PWSLT;
9697 dgst_size = DGST_SIZE_4_8;
9698 parse_func = pdf17l3_parse_hash;
9699 sort_by_digest = sort_by_digest_4_8;
9700 opti_type = OPTI_TYPE_ZERO_BYTE
9701 | OPTI_TYPE_PRECOMPUTE_INIT
9702 | OPTI_TYPE_PRECOMPUTE_MERKLE
9703 | OPTI_TYPE_EARLY_SKIP
9704 | OPTI_TYPE_NOT_ITERATED
9705 | OPTI_TYPE_APPENDED_SALT
9706 | OPTI_TYPE_RAW_HASH;
9707 dgst_pos0 = 3;
9708 dgst_pos1 = 7;
9709 dgst_pos2 = 2;
9710 dgst_pos3 = 6;
9711 break;
9712
9713 case 10700: hash_type = HASH_TYPE_PDFU32;
9714 salt_type = SALT_TYPE_EMBEDDED;
9715 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9716 opts_type = OPTS_TYPE_PT_GENERATE_LE
9717 | OPTS_TYPE_HASH_COPY;
9718 kern_type = KERN_TYPE_PDF17L8;
9719 dgst_size = DGST_SIZE_4_8;
9720 parse_func = pdf17l8_parse_hash;
9721 sort_by_digest = sort_by_digest_4_8;
9722 opti_type = OPTI_TYPE_ZERO_BYTE
9723 | OPTI_TYPE_NOT_ITERATED;
9724 dgst_pos0 = 0;
9725 dgst_pos1 = 1;
9726 dgst_pos2 = 2;
9727 dgst_pos3 = 3;
9728 break;
9729
9730 case 10800: hash_type = HASH_TYPE_SHA384;
9731 salt_type = SALT_TYPE_NONE;
9732 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9733 opts_type = OPTS_TYPE_PT_GENERATE_BE
9734 | OPTS_TYPE_PT_ADD80
9735 | OPTS_TYPE_PT_ADDBITS15;
9736 kern_type = KERN_TYPE_SHA384;
9737 dgst_size = DGST_SIZE_8_8;
9738 parse_func = sha384_parse_hash;
9739 sort_by_digest = sort_by_digest_8_8;
9740 opti_type = OPTI_TYPE_ZERO_BYTE
9741 | OPTI_TYPE_PRECOMPUTE_INIT
9742 | OPTI_TYPE_PRECOMPUTE_MERKLE
9743 | OPTI_TYPE_EARLY_SKIP
9744 | OPTI_TYPE_NOT_ITERATED
9745 | OPTI_TYPE_NOT_SALTED
9746 | OPTI_TYPE_USES_BITS_64
9747 | OPTI_TYPE_RAW_HASH;
9748 dgst_pos0 = 6;
9749 dgst_pos1 = 7;
9750 dgst_pos2 = 4;
9751 dgst_pos3 = 5;
9752 break;
9753
9754 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9755 salt_type = SALT_TYPE_EMBEDDED;
9756 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9757 opts_type = OPTS_TYPE_PT_GENERATE_LE
9758 | OPTS_TYPE_ST_BASE64
9759 | OPTS_TYPE_HASH_COPY;
9760 kern_type = KERN_TYPE_PBKDF2_SHA256;
9761 dgst_size = DGST_SIZE_4_32;
9762 parse_func = pbkdf2_sha256_parse_hash;
9763 sort_by_digest = sort_by_digest_4_32;
9764 opti_type = OPTI_TYPE_ZERO_BYTE
9765 | OPTI_TYPE_SLOW_HASH_SIMD;
9766 dgst_pos0 = 0;
9767 dgst_pos1 = 1;
9768 dgst_pos2 = 2;
9769 dgst_pos3 = 3;
9770 break;
9771
9772 case 11000: hash_type = HASH_TYPE_MD5;
9773 salt_type = SALT_TYPE_INTERN;
9774 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9775 opts_type = OPTS_TYPE_PT_GENERATE_LE
9776 | OPTS_TYPE_PT_ADD80;
9777 kern_type = KERN_TYPE_PRESTASHOP;
9778 dgst_size = DGST_SIZE_4_4;
9779 parse_func = prestashop_parse_hash;
9780 sort_by_digest = sort_by_digest_4_4;
9781 opti_type = OPTI_TYPE_ZERO_BYTE
9782 | OPTI_TYPE_PRECOMPUTE_INIT
9783 | OPTI_TYPE_NOT_ITERATED
9784 | OPTI_TYPE_PREPENDED_SALT;
9785 dgst_pos0 = 0;
9786 dgst_pos1 = 3;
9787 dgst_pos2 = 2;
9788 dgst_pos3 = 1;
9789 break;
9790
9791 case 11100: hash_type = HASH_TYPE_MD5;
9792 salt_type = SALT_TYPE_EMBEDDED;
9793 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9794 opts_type = OPTS_TYPE_PT_GENERATE_LE
9795 | OPTS_TYPE_ST_ADD80;
9796 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9797 dgst_size = DGST_SIZE_4_4;
9798 parse_func = postgresql_auth_parse_hash;
9799 sort_by_digest = sort_by_digest_4_4;
9800 opti_type = OPTI_TYPE_ZERO_BYTE
9801 | OPTI_TYPE_PRECOMPUTE_INIT
9802 | OPTI_TYPE_PRECOMPUTE_MERKLE
9803 | OPTI_TYPE_EARLY_SKIP;
9804 dgst_pos0 = 0;
9805 dgst_pos1 = 3;
9806 dgst_pos2 = 2;
9807 dgst_pos3 = 1;
9808 break;
9809
9810 case 11200: hash_type = HASH_TYPE_SHA1;
9811 salt_type = SALT_TYPE_EMBEDDED;
9812 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9813 opts_type = OPTS_TYPE_PT_GENERATE_BE
9814 | OPTS_TYPE_PT_ADD80
9815 | OPTS_TYPE_ST_HEX;
9816 kern_type = KERN_TYPE_MYSQL_AUTH;
9817 dgst_size = DGST_SIZE_4_5;
9818 parse_func = mysql_auth_parse_hash;
9819 sort_by_digest = sort_by_digest_4_5;
9820 opti_type = OPTI_TYPE_ZERO_BYTE
9821 | OPTI_TYPE_EARLY_SKIP;
9822 dgst_pos0 = 3;
9823 dgst_pos1 = 4;
9824 dgst_pos2 = 2;
9825 dgst_pos3 = 1;
9826 break;
9827
9828 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9829 salt_type = SALT_TYPE_EMBEDDED;
9830 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9831 opts_type = OPTS_TYPE_PT_GENERATE_LE
9832 | OPTS_TYPE_ST_HEX
9833 | OPTS_TYPE_ST_ADD80;
9834 kern_type = KERN_TYPE_BITCOIN_WALLET;
9835 dgst_size = DGST_SIZE_4_4;
9836 parse_func = bitcoin_wallet_parse_hash;
9837 sort_by_digest = sort_by_digest_4_4;
9838 opti_type = OPTI_TYPE_ZERO_BYTE;
9839 dgst_pos0 = 0;
9840 dgst_pos1 = 1;
9841 dgst_pos2 = 2;
9842 dgst_pos3 = 3;
9843 break;
9844
9845 case 11400: hash_type = HASH_TYPE_MD5;
9846 salt_type = SALT_TYPE_EMBEDDED;
9847 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9848 opts_type = OPTS_TYPE_PT_GENERATE_LE
9849 | OPTS_TYPE_PT_ADD80
9850 | OPTS_TYPE_HASH_COPY;
9851 kern_type = KERN_TYPE_SIP_AUTH;
9852 dgst_size = DGST_SIZE_4_4;
9853 parse_func = sip_auth_parse_hash;
9854 sort_by_digest = sort_by_digest_4_4;
9855 opti_type = OPTI_TYPE_ZERO_BYTE;
9856 dgst_pos0 = 0;
9857 dgst_pos1 = 3;
9858 dgst_pos2 = 2;
9859 dgst_pos3 = 1;
9860 break;
9861
9862 case 11500: hash_type = HASH_TYPE_CRC32;
9863 salt_type = SALT_TYPE_INTERN;
9864 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9865 opts_type = OPTS_TYPE_PT_GENERATE_LE
9866 | OPTS_TYPE_ST_GENERATE_LE
9867 | OPTS_TYPE_ST_HEX;
9868 kern_type = KERN_TYPE_CRC32;
9869 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9870 parse_func = crc32_parse_hash;
9871 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9872 opti_type = OPTI_TYPE_ZERO_BYTE;
9873 dgst_pos0 = 0;
9874 dgst_pos1 = 1;
9875 dgst_pos2 = 2;
9876 dgst_pos3 = 3;
9877 break;
9878
9879 case 11600: hash_type = HASH_TYPE_AES;
9880 salt_type = SALT_TYPE_EMBEDDED;
9881 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9882 opts_type = OPTS_TYPE_PT_GENERATE_LE
9883 | OPTS_TYPE_PT_NEVERCRACK;
9884 kern_type = KERN_TYPE_SEVEN_ZIP;
9885 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9886 parse_func = seven_zip_parse_hash;
9887 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
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 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9896 salt_type = SALT_TYPE_NONE;
9897 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9898 opts_type = OPTS_TYPE_PT_GENERATE_LE
9899 | OPTS_TYPE_PT_ADD01;
9900 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9901 dgst_size = DGST_SIZE_4_8;
9902 parse_func = gost2012sbog_256_parse_hash;
9903 sort_by_digest = sort_by_digest_4_8;
9904 opti_type = OPTI_TYPE_ZERO_BYTE;
9905 dgst_pos0 = 0;
9906 dgst_pos1 = 1;
9907 dgst_pos2 = 2;
9908 dgst_pos3 = 3;
9909 break;
9910
9911 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9912 salt_type = SALT_TYPE_NONE;
9913 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9914 opts_type = OPTS_TYPE_PT_GENERATE_LE
9915 | OPTS_TYPE_PT_ADD01;
9916 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9917 dgst_size = DGST_SIZE_4_16;
9918 parse_func = gost2012sbog_512_parse_hash;
9919 sort_by_digest = sort_by_digest_4_16;
9920 opti_type = OPTI_TYPE_ZERO_BYTE;
9921 dgst_pos0 = 0;
9922 dgst_pos1 = 1;
9923 dgst_pos2 = 2;
9924 dgst_pos3 = 3;
9925 break;
9926
9927 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9928 salt_type = SALT_TYPE_EMBEDDED;
9929 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9930 opts_type = OPTS_TYPE_PT_GENERATE_LE
9931 | OPTS_TYPE_ST_BASE64
9932 | OPTS_TYPE_HASH_COPY;
9933 kern_type = KERN_TYPE_PBKDF2_MD5;
9934 dgst_size = DGST_SIZE_4_32;
9935 parse_func = pbkdf2_md5_parse_hash;
9936 sort_by_digest = sort_by_digest_4_32;
9937 opti_type = OPTI_TYPE_ZERO_BYTE
9938 | OPTI_TYPE_SLOW_HASH_SIMD;
9939 dgst_pos0 = 0;
9940 dgst_pos1 = 1;
9941 dgst_pos2 = 2;
9942 dgst_pos3 = 3;
9943 break;
9944
9945 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9946 salt_type = SALT_TYPE_EMBEDDED;
9947 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9948 opts_type = OPTS_TYPE_PT_GENERATE_LE
9949 | OPTS_TYPE_ST_BASE64
9950 | OPTS_TYPE_HASH_COPY;
9951 kern_type = KERN_TYPE_PBKDF2_SHA1;
9952 dgst_size = DGST_SIZE_4_32;
9953 parse_func = pbkdf2_sha1_parse_hash;
9954 sort_by_digest = sort_by_digest_4_32;
9955 opti_type = OPTI_TYPE_ZERO_BYTE
9956 | OPTI_TYPE_SLOW_HASH_SIMD;
9957 dgst_pos0 = 0;
9958 dgst_pos1 = 1;
9959 dgst_pos2 = 2;
9960 dgst_pos3 = 3;
9961 break;
9962
9963 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9964 salt_type = SALT_TYPE_EMBEDDED;
9965 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9966 opts_type = OPTS_TYPE_PT_GENERATE_LE
9967 | OPTS_TYPE_ST_BASE64
9968 | OPTS_TYPE_HASH_COPY;
9969 kern_type = KERN_TYPE_PBKDF2_SHA512;
9970 dgst_size = DGST_SIZE_8_16;
9971 parse_func = pbkdf2_sha512_parse_hash;
9972 sort_by_digest = sort_by_digest_8_16;
9973 opti_type = OPTI_TYPE_ZERO_BYTE
9974 | OPTI_TYPE_USES_BITS_64
9975 | OPTI_TYPE_SLOW_HASH_SIMD;
9976 dgst_pos0 = 0;
9977 dgst_pos1 = 1;
9978 dgst_pos2 = 2;
9979 dgst_pos3 = 3;
9980 break;
9981
9982 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9983 salt_type = SALT_TYPE_EMBEDDED;
9984 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9985 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9986 kern_type = KERN_TYPE_ECRYPTFS;
9987 dgst_size = DGST_SIZE_8_8;
9988 parse_func = ecryptfs_parse_hash;
9989 sort_by_digest = sort_by_digest_8_8;
9990 opti_type = OPTI_TYPE_ZERO_BYTE
9991 | OPTI_TYPE_USES_BITS_64;
9992 dgst_pos0 = 0;
9993 dgst_pos1 = 1;
9994 dgst_pos2 = 2;
9995 dgst_pos3 = 3;
9996 break;
9997
9998 case 12300: hash_type = HASH_TYPE_ORACLET;
9999 salt_type = SALT_TYPE_EMBEDDED;
10000 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10001 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10002 kern_type = KERN_TYPE_ORACLET;
10003 dgst_size = DGST_SIZE_8_16;
10004 parse_func = oraclet_parse_hash;
10005 sort_by_digest = sort_by_digest_8_16;
10006 opti_type = OPTI_TYPE_ZERO_BYTE
10007 | OPTI_TYPE_USES_BITS_64;
10008 dgst_pos0 = 0;
10009 dgst_pos1 = 1;
10010 dgst_pos2 = 2;
10011 dgst_pos3 = 3;
10012 break;
10013
10014 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10015 salt_type = SALT_TYPE_EMBEDDED;
10016 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10017 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10018 kern_type = KERN_TYPE_BSDICRYPT;
10019 dgst_size = DGST_SIZE_4_4;
10020 parse_func = bsdicrypt_parse_hash;
10021 sort_by_digest = sort_by_digest_4_4;
10022 opti_type = OPTI_TYPE_ZERO_BYTE
10023 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10024 dgst_pos0 = 0;
10025 dgst_pos1 = 1;
10026 dgst_pos2 = 2;
10027 dgst_pos3 = 3;
10028 break;
10029
10030 case 12500: hash_type = HASH_TYPE_RAR3HP;
10031 salt_type = SALT_TYPE_EMBEDDED;
10032 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10033 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10034 kern_type = KERN_TYPE_RAR3;
10035 dgst_size = DGST_SIZE_4_4;
10036 parse_func = rar3hp_parse_hash;
10037 sort_by_digest = sort_by_digest_4_4;
10038 opti_type = OPTI_TYPE_ZERO_BYTE;
10039 dgst_pos0 = 0;
10040 dgst_pos1 = 1;
10041 dgst_pos2 = 2;
10042 dgst_pos3 = 3;
10043 break;
10044
10045 case 12600: hash_type = HASH_TYPE_SHA256;
10046 salt_type = SALT_TYPE_INTERN;
10047 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10048 opts_type = OPTS_TYPE_PT_GENERATE_BE
10049 | OPTS_TYPE_PT_ADD80;
10050 kern_type = KERN_TYPE_CF10;
10051 dgst_size = DGST_SIZE_4_8;
10052 parse_func = cf10_parse_hash;
10053 sort_by_digest = sort_by_digest_4_8;
10054 opti_type = OPTI_TYPE_ZERO_BYTE
10055 | OPTI_TYPE_PRECOMPUTE_INIT
10056 | OPTI_TYPE_EARLY_SKIP
10057 | OPTI_TYPE_NOT_ITERATED;
10058 dgst_pos0 = 3;
10059 dgst_pos1 = 7;
10060 dgst_pos2 = 2;
10061 dgst_pos3 = 6;
10062 break;
10063
10064 case 12700: hash_type = HASH_TYPE_AES;
10065 salt_type = SALT_TYPE_EMBEDDED;
10066 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10067 opts_type = OPTS_TYPE_PT_GENERATE_LE
10068 | OPTS_TYPE_HASH_COPY;
10069 kern_type = KERN_TYPE_MYWALLET;
10070 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10071 parse_func = mywallet_parse_hash;
10072 sort_by_digest = sort_by_digest_4_5;
10073 opti_type = OPTI_TYPE_ZERO_BYTE;
10074 dgst_pos0 = 0;
10075 dgst_pos1 = 1;
10076 dgst_pos2 = 2;
10077 dgst_pos3 = 3;
10078 break;
10079
10080 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
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_MS_DRSR;
10085 dgst_size = DGST_SIZE_4_8;
10086 parse_func = ms_drsr_parse_hash;
10087 sort_by_digest = sort_by_digest_4_8;
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 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10096 salt_type = SALT_TYPE_EMBEDDED;
10097 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10098 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10099 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10100 dgst_size = DGST_SIZE_4_8;
10101 parse_func = androidfde_samsung_parse_hash;
10102 sort_by_digest = sort_by_digest_4_8;
10103 opti_type = OPTI_TYPE_ZERO_BYTE;
10104 dgst_pos0 = 0;
10105 dgst_pos1 = 1;
10106 dgst_pos2 = 2;
10107 dgst_pos3 = 3;
10108 break;
10109
10110 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10111 salt_type = SALT_TYPE_EMBEDDED;
10112 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10113 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10114 kern_type = KERN_TYPE_RAR5;
10115 dgst_size = DGST_SIZE_4_4;
10116 parse_func = rar5_parse_hash;
10117 sort_by_digest = sort_by_digest_4_4;
10118 opti_type = OPTI_TYPE_ZERO_BYTE;
10119 dgst_pos0 = 0;
10120 dgst_pos1 = 1;
10121 dgst_pos2 = 2;
10122 dgst_pos3 = 3;
10123 break;
10124
10125 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10126 salt_type = SALT_TYPE_EMBEDDED;
10127 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10128 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10129 kern_type = KERN_TYPE_KRB5TGS;
10130 dgst_size = DGST_SIZE_4_4;
10131 parse_func = krb5tgs_parse_hash;
10132 sort_by_digest = sort_by_digest_4_4;
10133 opti_type = OPTI_TYPE_ZERO_BYTE
10134 | OPTI_TYPE_NOT_ITERATED;
10135 dgst_pos0 = 0;
10136 dgst_pos1 = 1;
10137 dgst_pos2 = 2;
10138 dgst_pos3 = 3;
10139 break;
10140
10141 case 13200: hash_type = HASH_TYPE_AES;
10142 salt_type = SALT_TYPE_EMBEDDED;
10143 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10144 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10145 kern_type = KERN_TYPE_AXCRYPT;
10146 dgst_size = DGST_SIZE_4_4;
10147 parse_func = axcrypt_parse_hash;
10148 sort_by_digest = sort_by_digest_4_4;
10149 opti_type = OPTI_TYPE_ZERO_BYTE;
10150 dgst_pos0 = 0;
10151 dgst_pos1 = 1;
10152 dgst_pos2 = 2;
10153 dgst_pos3 = 3;
10154 break;
10155
10156 case 13300: hash_type = HASH_TYPE_SHA1;
10157 salt_type = SALT_TYPE_NONE;
10158 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10159 opts_type = OPTS_TYPE_PT_GENERATE_BE
10160 | OPTS_TYPE_PT_ADD80
10161 | OPTS_TYPE_PT_ADDBITS15;
10162 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10163 dgst_size = DGST_SIZE_4_5;
10164 parse_func = sha1axcrypt_parse_hash;
10165 sort_by_digest = sort_by_digest_4_5;
10166 opti_type = OPTI_TYPE_ZERO_BYTE
10167 | OPTI_TYPE_PRECOMPUTE_INIT
10168 | OPTI_TYPE_EARLY_SKIP
10169 | OPTI_TYPE_NOT_ITERATED
10170 | OPTI_TYPE_NOT_SALTED;
10171 dgst_pos0 = 0;
10172 dgst_pos1 = 4;
10173 dgst_pos2 = 3;
10174 dgst_pos3 = 2;
10175 break;
10176
10177 case 13400: hash_type = HASH_TYPE_AES;
10178 salt_type = SALT_TYPE_EMBEDDED;
10179 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10180 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10181 kern_type = KERN_TYPE_KEEPASS;
10182 dgst_size = DGST_SIZE_4_4;
10183 parse_func = keepass_parse_hash;
10184 sort_by_digest = sort_by_digest_4_4;
10185 opti_type = OPTI_TYPE_ZERO_BYTE;
10186 dgst_pos0 = 0;
10187 dgst_pos1 = 1;
10188 dgst_pos2 = 2;
10189 dgst_pos3 = 3;
10190 break;
10191
10192 case 13500: hash_type = HASH_TYPE_SHA1;
10193 salt_type = SALT_TYPE_EMBEDDED;
10194 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10195 opts_type = OPTS_TYPE_PT_GENERATE_BE
10196 | OPTS_TYPE_PT_UNICODE
10197 | OPTS_TYPE_PT_ADD80;
10198 kern_type = KERN_TYPE_PSTOKEN;
10199 dgst_size = DGST_SIZE_4_5;
10200 parse_func = pstoken_parse_hash;
10201 sort_by_digest = sort_by_digest_4_5;
10202 opti_type = OPTI_TYPE_ZERO_BYTE
10203 | OPTI_TYPE_PRECOMPUTE_INIT
10204 | OPTI_TYPE_EARLY_SKIP
10205 | OPTI_TYPE_NOT_ITERATED
10206 | OPTI_TYPE_PREPENDED_SALT
10207 | OPTI_TYPE_RAW_HASH;
10208 dgst_pos0 = 3;
10209 dgst_pos1 = 4;
10210 dgst_pos2 = 2;
10211 dgst_pos3 = 1;
10212 break;
10213
10214 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10215 salt_type = SALT_TYPE_EMBEDDED;
10216 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10217 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10218 kern_type = KERN_TYPE_ZIP2;
10219 dgst_size = DGST_SIZE_4_4;
10220 parse_func = zip2_parse_hash;
10221 sort_by_digest = sort_by_digest_4_4;
10222 opti_type = OPTI_TYPE_ZERO_BYTE;
10223 dgst_pos0 = 0;
10224 dgst_pos1 = 1;
10225 dgst_pos2 = 2;
10226 dgst_pos3 = 3;
10227 break;
10228
10229 default: usage_mini_print (PROGNAME); return (-1);
10230 }
10231
10232 /**
10233 * parser
10234 */
10235
10236 data.parse_func = parse_func;
10237
10238 /**
10239 * misc stuff
10240 */
10241
10242 if (hex_salt)
10243 {
10244 if (salt_type == SALT_TYPE_INTERN)
10245 {
10246 opts_type |= OPTS_TYPE_ST_HEX;
10247 }
10248 else
10249 {
10250 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10251
10252 return (-1);
10253 }
10254 }
10255
10256 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10257 | (salt_type == SALT_TYPE_EXTERN)
10258 | (salt_type == SALT_TYPE_EMBEDDED)
10259 | (salt_type == SALT_TYPE_VIRTUAL));
10260
10261 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10262
10263 data.hash_type = hash_type;
10264 data.attack_mode = attack_mode;
10265 data.attack_kern = attack_kern;
10266 data.attack_exec = attack_exec;
10267 data.kern_type = kern_type;
10268 data.opts_type = opts_type;
10269 data.dgst_size = dgst_size;
10270 data.salt_type = salt_type;
10271 data.isSalted = isSalted;
10272 data.sort_by_digest = sort_by_digest;
10273 data.dgst_pos0 = dgst_pos0;
10274 data.dgst_pos1 = dgst_pos1;
10275 data.dgst_pos2 = dgst_pos2;
10276 data.dgst_pos3 = dgst_pos3;
10277
10278 esalt_size = 0;
10279
10280 switch (hash_mode)
10281 {
10282 case 2500: esalt_size = sizeof (wpa_t); break;
10283 case 5300: esalt_size = sizeof (ikepsk_t); break;
10284 case 5400: esalt_size = sizeof (ikepsk_t); break;
10285 case 5500: esalt_size = sizeof (netntlm_t); break;
10286 case 5600: esalt_size = sizeof (netntlm_t); break;
10287 case 6211: esalt_size = sizeof (tc_t); break;
10288 case 6212: esalt_size = sizeof (tc_t); break;
10289 case 6213: esalt_size = sizeof (tc_t); break;
10290 case 6221: esalt_size = sizeof (tc_t); break;
10291 case 6222: esalt_size = sizeof (tc_t); break;
10292 case 6223: esalt_size = sizeof (tc_t); break;
10293 case 6231: esalt_size = sizeof (tc_t); break;
10294 case 6232: esalt_size = sizeof (tc_t); break;
10295 case 6233: esalt_size = sizeof (tc_t); break;
10296 case 6241: esalt_size = sizeof (tc_t); break;
10297 case 6242: esalt_size = sizeof (tc_t); break;
10298 case 6243: esalt_size = sizeof (tc_t); break;
10299 case 6600: esalt_size = sizeof (agilekey_t); break;
10300 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10301 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10302 case 7300: esalt_size = sizeof (rakp_t); break;
10303 case 7500: esalt_size = sizeof (krb5pa_t); break;
10304 case 8200: esalt_size = sizeof (cloudkey_t); break;
10305 case 8800: esalt_size = sizeof (androidfde_t); break;
10306 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10307 case 9400: esalt_size = sizeof (office2007_t); break;
10308 case 9500: esalt_size = sizeof (office2010_t); break;
10309 case 9600: esalt_size = sizeof (office2013_t); break;
10310 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10311 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10312 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10313 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10314 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10315 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10316 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10317 case 10200: esalt_size = sizeof (cram_md5_t); break;
10318 case 10400: esalt_size = sizeof (pdf_t); break;
10319 case 10410: esalt_size = sizeof (pdf_t); break;
10320 case 10420: esalt_size = sizeof (pdf_t); break;
10321 case 10500: esalt_size = sizeof (pdf_t); break;
10322 case 10600: esalt_size = sizeof (pdf_t); break;
10323 case 10700: esalt_size = sizeof (pdf_t); break;
10324 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10325 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10326 case 11400: esalt_size = sizeof (sip_t); break;
10327 case 11600: esalt_size = sizeof (seven_zip_t); break;
10328 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10329 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10330 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10331 case 13000: esalt_size = sizeof (rar5_t); break;
10332 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10333 case 13400: esalt_size = sizeof (keepass_t); break;
10334 case 13500: esalt_size = sizeof (pstoken_t); break;
10335 case 13600: esalt_size = sizeof (zip2_t); break;
10336 }
10337
10338 data.esalt_size = esalt_size;
10339
10340 /**
10341 * choose dictionary parser
10342 */
10343
10344 if (hash_type == HASH_TYPE_LM)
10345 {
10346 get_next_word_func = get_next_word_lm;
10347 }
10348 else if (opts_type & OPTS_TYPE_PT_UPPER)
10349 {
10350 get_next_word_func = get_next_word_uc;
10351 }
10352 else
10353 {
10354 get_next_word_func = get_next_word_std;
10355 }
10356
10357 /**
10358 * dictstat
10359 */
10360
10361 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10362
10363 #ifdef _POSIX
10364 size_t dictstat_nmemb = 0;
10365 #endif
10366
10367 #ifdef _WIN
10368 uint dictstat_nmemb = 0;
10369 #endif
10370
10371 char dictstat[256] = { 0 };
10372
10373 FILE *dictstat_fp = NULL;
10374
10375 if (keyspace == 0)
10376 {
10377 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10378
10379 dictstat_fp = fopen (dictstat, "rb");
10380
10381 if (dictstat_fp)
10382 {
10383 #ifdef _POSIX
10384 struct stat tmpstat;
10385
10386 fstat (fileno (dictstat_fp), &tmpstat);
10387 #endif
10388
10389 #ifdef _WIN
10390 struct stat64 tmpstat;
10391
10392 _fstat64 (fileno (dictstat_fp), &tmpstat);
10393 #endif
10394
10395 if (tmpstat.st_mtime < COMPTIME)
10396 {
10397 /* with v0.15 the format changed so we have to ensure user is using a good version
10398 since there is no version-header in the dictstat file */
10399
10400 fclose (dictstat_fp);
10401
10402 unlink (dictstat);
10403 }
10404 else
10405 {
10406 while (!feof (dictstat_fp))
10407 {
10408 dictstat_t d;
10409
10410 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10411
10412 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10413
10414 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10415 {
10416 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10417
10418 return -1;
10419 }
10420 }
10421
10422 fclose (dictstat_fp);
10423 }
10424 }
10425 }
10426
10427 /**
10428 * potfile
10429 */
10430
10431 char potfile[256] = { 0 };
10432
10433 if (potfile_path == NULL)
10434 {
10435 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10436 }
10437 else
10438 {
10439 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10440 }
10441
10442 data.pot_fp = NULL;
10443
10444 FILE *out_fp = NULL;
10445 FILE *pot_fp = NULL;
10446
10447 if (show == 1 || left == 1)
10448 {
10449 pot_fp = fopen (potfile, "rb");
10450
10451 if (pot_fp == NULL)
10452 {
10453 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10454
10455 return (-1);
10456 }
10457
10458 if (outfile != NULL)
10459 {
10460 if ((out_fp = fopen (outfile, "ab")) == NULL)
10461 {
10462 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10463
10464 fclose (pot_fp);
10465
10466 return (-1);
10467 }
10468 }
10469 else
10470 {
10471 out_fp = stdout;
10472 }
10473 }
10474 else
10475 {
10476 if (potfile_disable == 0)
10477 {
10478 pot_fp = fopen (potfile, "ab");
10479
10480 if (pot_fp == NULL)
10481 {
10482 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10483
10484 return (-1);
10485 }
10486
10487 data.pot_fp = pot_fp;
10488 }
10489 }
10490
10491 pot_t *pot = NULL;
10492
10493 uint pot_cnt = 0;
10494 uint pot_avail = 0;
10495
10496 if (show == 1 || left == 1)
10497 {
10498 SUPPRESS_OUTPUT = 1;
10499
10500 pot_avail = count_lines (pot_fp);
10501
10502 rewind (pot_fp);
10503
10504 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10505
10506 uint pot_hashes_avail = 0;
10507
10508 uint line_num = 0;
10509
10510 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10511
10512 while (!feof (pot_fp))
10513 {
10514 line_num++;
10515
10516 int line_len = fgetl (pot_fp, line_buf);
10517
10518 if (line_len == 0) continue;
10519
10520 char *plain_buf = line_buf + line_len;
10521
10522 pot_t *pot_ptr = &pot[pot_cnt];
10523
10524 hash_t *hashes_buf = &pot_ptr->hash;
10525
10526 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10527 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10528
10529 if (pot_cnt == pot_hashes_avail)
10530 {
10531 uint pos = 0;
10532
10533 for (pos = 0; pos < INCR_POT; pos++)
10534 {
10535 if ((pot_cnt + pos) >= pot_avail) break;
10536
10537 pot_t *tmp_pot = &pot[pot_cnt + pos];
10538
10539 hash_t *tmp_hash = &tmp_pot->hash;
10540
10541 tmp_hash->digest = mymalloc (dgst_size);
10542
10543 if (isSalted)
10544 {
10545 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10546 }
10547
10548 if (esalt_size)
10549 {
10550 tmp_hash->esalt = mymalloc (esalt_size);
10551 }
10552
10553 pot_hashes_avail++;
10554 }
10555 }
10556
10557 int plain_len = 0;
10558
10559 int parser_status;
10560
10561 int iter = MAX_CUT_TRIES;
10562
10563 do
10564 {
10565 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10566 {
10567 if (line_buf[i] == ':')
10568 {
10569 line_len--;
10570
10571 break;
10572 }
10573 }
10574
10575 if (data.hash_mode != 2500)
10576 {
10577 parser_status = parse_func (line_buf, line_len, hashes_buf);
10578 }
10579 else
10580 {
10581 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10582
10583 if (line_len > max_salt_size)
10584 {
10585 parser_status = PARSER_GLOBAL_LENGTH;
10586 }
10587 else
10588 {
10589 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10590
10591 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10592
10593 hashes_buf->salt->salt_len = line_len;
10594
10595 parser_status = PARSER_OK;
10596 }
10597 }
10598
10599 // if NOT parsed without error, we add the ":" to the plain
10600
10601 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10602 {
10603 plain_len++;
10604 plain_buf--;
10605 }
10606
10607 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10608
10609 if (parser_status < PARSER_GLOBAL_ZERO)
10610 {
10611 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10612
10613 continue;
10614 }
10615
10616 if (plain_len >= 255) continue;
10617
10618 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10619
10620 pot_ptr->plain_len = plain_len;
10621
10622 pot_cnt++;
10623 }
10624
10625 myfree (line_buf);
10626
10627 fclose (pot_fp);
10628
10629 SUPPRESS_OUTPUT = 0;
10630
10631 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10632 }
10633
10634 /**
10635 * word len
10636 */
10637
10638 uint pw_min = PW_MIN;
10639 uint pw_max = PW_MAX;
10640
10641 switch (hash_mode)
10642 {
10643 case 125: if (pw_max > 32) pw_max = 32;
10644 break;
10645 case 400: if (pw_max > 40) pw_max = 40;
10646 break;
10647 case 500: if (pw_max > 16) pw_max = 16;
10648 break;
10649 case 1500: if (pw_max > 8) pw_max = 8;
10650 break;
10651 case 1600: if (pw_max > 16) pw_max = 16;
10652 break;
10653 case 1800: if (pw_max > 16) pw_max = 16;
10654 break;
10655 case 2100: if (pw_max > 16) pw_max = 16;
10656 break;
10657 case 2500: if (pw_min < 8) pw_min = 8;
10658 break;
10659 case 3000: if (pw_max > 7) pw_max = 7;
10660 break;
10661 case 5200: if (pw_max > 24) pw_max = 24;
10662 break;
10663 case 5800: if (pw_max > 16) pw_max = 16;
10664 break;
10665 case 6300: if (pw_max > 16) pw_max = 16;
10666 break;
10667 case 7400: if (pw_max > 16) pw_max = 16;
10668 break;
10669 case 7900: if (pw_max > 48) pw_max = 48;
10670 break;
10671 case 8500: if (pw_max > 8) pw_max = 8;
10672 break;
10673 case 8600: if (pw_max > 16) pw_max = 16;
10674 break;
10675 case 9710: pw_min = 5;
10676 pw_max = 5;
10677 break;
10678 case 9810: pw_min = 5;
10679 pw_max = 5;
10680 break;
10681 case 10410: pw_min = 5;
10682 pw_max = 5;
10683 break;
10684 case 10300: if (pw_max < 3) pw_min = 3;
10685 if (pw_max > 40) pw_max = 40;
10686 break;
10687 case 10500: if (pw_max < 3) pw_min = 3;
10688 if (pw_max > 40) pw_max = 40;
10689 break;
10690 case 10700: if (pw_max > 16) pw_max = 16;
10691 break;
10692 case 11300: if (pw_max > 40) pw_max = 40;
10693 break;
10694 case 11600: if (pw_max > 32) pw_max = 32;
10695 break;
10696 case 12500: if (pw_max > 20) pw_max = 20;
10697 break;
10698 case 12800: if (pw_max > 24) pw_max = 24;
10699 break;
10700 }
10701
10702 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10703 {
10704 switch (attack_kern)
10705 {
10706 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10707 break;
10708 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10709 break;
10710 }
10711 }
10712
10713 /**
10714 * charsets : keep them together for more easy maintainnce
10715 */
10716
10717 cs_t mp_sys[6] = { { { 0 }, 0 } };
10718 cs_t mp_usr[4] = { { { 0 }, 0 } };
10719
10720 mp_setup_sys (mp_sys);
10721
10722 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10723 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10724 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10725 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10726
10727 /**
10728 * load hashes, part I: find input mode, count hashes
10729 */
10730
10731 uint hashlist_mode = 0;
10732 uint hashlist_format = HLFMT_HASHCAT;
10733
10734 uint hashes_avail = 0;
10735
10736 if (benchmark == 0)
10737 {
10738 struct stat f;
10739
10740 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10741
10742 if ((hash_mode == 2500) ||
10743 (hash_mode == 5200) ||
10744 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10745 (hash_mode == 9000))
10746 {
10747 hashlist_mode = HL_MODE_ARG;
10748
10749 char *hashfile = myargv[optind];
10750
10751 data.hashfile = hashfile;
10752
10753 logfile_top_var_string ("target", hashfile);
10754 }
10755
10756 if (hashlist_mode == HL_MODE_ARG)
10757 {
10758 if (hash_mode == 2500)
10759 {
10760 struct stat st;
10761
10762 if (stat (data.hashfile, &st) == -1)
10763 {
10764 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10765
10766 return (-1);
10767 }
10768
10769 hashes_avail = st.st_size / sizeof (hccap_t);
10770 }
10771 else
10772 {
10773 hashes_avail = 1;
10774 }
10775 }
10776 else if (hashlist_mode == HL_MODE_FILE)
10777 {
10778 char *hashfile = myargv[optind];
10779
10780 data.hashfile = hashfile;
10781
10782 logfile_top_var_string ("target", hashfile);
10783
10784 FILE *fp = NULL;
10785
10786 if ((fp = fopen (hashfile, "rb")) == NULL)
10787 {
10788 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10789
10790 return (-1);
10791 }
10792
10793 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10794
10795 hashes_avail = count_lines (fp);
10796
10797 rewind (fp);
10798
10799 if (hashes_avail == 0)
10800 {
10801 log_error ("ERROR: hashfile is empty or corrupt");
10802
10803 fclose (fp);
10804
10805 return (-1);
10806 }
10807
10808 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10809
10810 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10811 {
10812 log_error ("ERROR: remove not supported in native hashfile-format mode");
10813
10814 fclose (fp);
10815
10816 return (-1);
10817 }
10818
10819 fclose (fp);
10820 }
10821 }
10822 else
10823 {
10824 hashlist_mode = HL_MODE_ARG;
10825
10826 hashes_avail = 1;
10827 }
10828
10829 if (hash_mode == 3000) hashes_avail *= 2;
10830
10831 data.hashlist_mode = hashlist_mode;
10832 data.hashlist_format = hashlist_format;
10833
10834 logfile_top_uint (hashlist_mode);
10835 logfile_top_uint (hashlist_format);
10836
10837 /**
10838 * load hashes, part II: allocate required memory, set pointers
10839 */
10840
10841 hash_t *hashes_buf = NULL;
10842 void *digests_buf = NULL;
10843 salt_t *salts_buf = NULL;
10844 void *esalts_buf = NULL;
10845
10846 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10847
10848 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10849
10850 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10851 {
10852 u32 hash_pos;
10853
10854 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10855 {
10856 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10857
10858 hashes_buf[hash_pos].hash_info = hash_info;
10859
10860 if (username && (remove || show || left))
10861 {
10862 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10863 }
10864
10865 if (benchmark)
10866 {
10867 hash_info->orighash = (char *) mymalloc (256);
10868 }
10869 }
10870 }
10871
10872 if (isSalted)
10873 {
10874 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10875
10876 if (esalt_size)
10877 {
10878 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10879 }
10880 }
10881 else
10882 {
10883 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10884 }
10885
10886 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10887 {
10888 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10889
10890 if (isSalted)
10891 {
10892 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10893
10894 if (esalt_size)
10895 {
10896 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10897 }
10898 }
10899 else
10900 {
10901 hashes_buf[hash_pos].salt = &salts_buf[0];
10902 }
10903 }
10904
10905 /**
10906 * load hashes, part III: parse hashes or generate them if benchmark
10907 */
10908
10909 uint hashes_cnt = 0;
10910
10911 if (benchmark == 0)
10912 {
10913 if (keyspace == 1)
10914 {
10915 // useless to read hash file for keyspace, cheat a little bit w/ optind
10916 }
10917 else if (hashes_avail == 0)
10918 {
10919 }
10920 else if (hashlist_mode == HL_MODE_ARG)
10921 {
10922 char *input_buf = myargv[optind];
10923
10924 uint input_len = strlen (input_buf);
10925
10926 logfile_top_var_string ("target", input_buf);
10927
10928 char *hash_buf = NULL;
10929 int hash_len = 0;
10930
10931 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10932
10933 bool hash_fmt_error = 0;
10934
10935 if (hash_len < 1) hash_fmt_error = 1;
10936 if (hash_buf == NULL) hash_fmt_error = 1;
10937
10938 if (hash_fmt_error)
10939 {
10940 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
10941 }
10942 else
10943 {
10944 if (opts_type & OPTS_TYPE_HASH_COPY)
10945 {
10946 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10947
10948 hash_info_tmp->orighash = mystrdup (hash_buf);
10949 }
10950
10951 if (isSalted)
10952 {
10953 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10954 }
10955
10956 int parser_status = PARSER_OK;
10957
10958 if (hash_mode == 2500)
10959 {
10960 if (hash_len == 0)
10961 {
10962 log_error ("ERROR: hccap file not specified");
10963
10964 return (-1);
10965 }
10966
10967 hashlist_mode = HL_MODE_FILE;
10968
10969 data.hashlist_mode = hashlist_mode;
10970
10971 FILE *fp = fopen (hash_buf, "rb");
10972
10973 if (fp == NULL)
10974 {
10975 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10976
10977 return (-1);
10978 }
10979
10980 if (hashes_avail < 1)
10981 {
10982 log_error ("ERROR: hccap file is empty or corrupt");
10983
10984 fclose (fp);
10985
10986 return (-1);
10987 }
10988
10989 uint hccap_size = sizeof (hccap_t);
10990
10991 char *in = (char *) mymalloc (hccap_size);
10992
10993 while (!feof (fp))
10994 {
10995 int n = fread (in, hccap_size, 1, fp);
10996
10997 if (n != 1)
10998 {
10999 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11000
11001 break;
11002 }
11003
11004 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11005
11006 if (parser_status != PARSER_OK)
11007 {
11008 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11009
11010 continue;
11011 }
11012
11013 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11014
11015 if ((show == 1) || (left == 1))
11016 {
11017 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11018
11019 char *salt_ptr = (char *) tmp_salt->salt_buf;
11020
11021 int cur_pos = tmp_salt->salt_len;
11022 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11023
11024 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11025
11026 // do the appending task
11027
11028 snprintf (salt_ptr + cur_pos,
11029 rem_len,
11030 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11031 wpa->orig_mac1[0],
11032 wpa->orig_mac1[1],
11033 wpa->orig_mac1[2],
11034 wpa->orig_mac1[3],
11035 wpa->orig_mac1[4],
11036 wpa->orig_mac1[5],
11037 wpa->orig_mac2[0],
11038 wpa->orig_mac2[1],
11039 wpa->orig_mac2[2],
11040 wpa->orig_mac2[3],
11041 wpa->orig_mac2[4],
11042 wpa->orig_mac2[5]);
11043
11044 // memset () the remaining part of the salt
11045
11046 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11047 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11048
11049 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11050
11051 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11052 }
11053
11054 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);
11055 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);
11056
11057 hashes_cnt++;
11058 }
11059
11060 fclose (fp);
11061
11062 myfree (in);
11063 }
11064 else if (hash_mode == 3000)
11065 {
11066 if (hash_len == 32)
11067 {
11068 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11069
11070 hash_t *lm_hash_left = NULL;
11071
11072 if (parser_status == PARSER_OK)
11073 {
11074 lm_hash_left = &hashes_buf[hashes_cnt];
11075
11076 hashes_cnt++;
11077 }
11078 else
11079 {
11080 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11081 }
11082
11083 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11084
11085 hash_t *lm_hash_right = NULL;
11086
11087 if (parser_status == PARSER_OK)
11088 {
11089 lm_hash_right = &hashes_buf[hashes_cnt];
11090
11091 hashes_cnt++;
11092 }
11093 else
11094 {
11095 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11096 }
11097
11098 // show / left
11099
11100 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11101 {
11102 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);
11103 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);
11104 }
11105 }
11106 else
11107 {
11108 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11109
11110 if (parser_status == PARSER_OK)
11111 {
11112 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11113 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11114 }
11115
11116 if (parser_status == PARSER_OK)
11117 {
11118 hashes_cnt++;
11119 }
11120 else
11121 {
11122 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11123 }
11124 }
11125 }
11126 else
11127 {
11128 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11129
11130 if (parser_status == PARSER_OK)
11131 {
11132 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11133 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11134 }
11135
11136 if (parser_status == PARSER_OK)
11137 {
11138 hashes_cnt++;
11139 }
11140 else
11141 {
11142 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11143 }
11144 }
11145 }
11146 }
11147 else if (hashlist_mode == HL_MODE_FILE)
11148 {
11149 char *hashfile = data.hashfile;
11150
11151 FILE *fp;
11152
11153 if ((fp = fopen (hashfile, "rb")) == NULL)
11154 {
11155 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11156
11157 return (-1);
11158 }
11159
11160 uint line_num = 0;
11161
11162 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11163
11164 while (!feof (fp))
11165 {
11166 line_num++;
11167
11168 int line_len = fgetl (fp, line_buf);
11169
11170 if (line_len == 0) continue;
11171
11172 char *hash_buf = NULL;
11173 int hash_len = 0;
11174
11175 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11176
11177 bool hash_fmt_error = 0;
11178
11179 if (hash_len < 1) hash_fmt_error = 1;
11180 if (hash_buf == NULL) hash_fmt_error = 1;
11181
11182 if (hash_fmt_error)
11183 {
11184 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11185
11186 continue;
11187 }
11188
11189 if (username)
11190 {
11191 char *user_buf = NULL;
11192 int user_len = 0;
11193
11194 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11195
11196 if (remove || show)
11197 {
11198 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11199
11200 *user = (user_t *) mymalloc (sizeof (user_t));
11201
11202 user_t *user_ptr = *user;
11203
11204 if (user_buf != NULL)
11205 {
11206 user_ptr->user_name = mystrdup (user_buf);
11207 }
11208 else
11209 {
11210 user_ptr->user_name = mystrdup ("");
11211 }
11212
11213 user_ptr->user_len = user_len;
11214 }
11215 }
11216
11217 if (opts_type & OPTS_TYPE_HASH_COPY)
11218 {
11219 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11220
11221 hash_info_tmp->orighash = mystrdup (hash_buf);
11222 }
11223
11224 if (isSalted)
11225 {
11226 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11227 }
11228
11229 if (hash_mode == 3000)
11230 {
11231 if (hash_len == 32)
11232 {
11233 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11234
11235 if (parser_status < PARSER_GLOBAL_ZERO)
11236 {
11237 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11238
11239 continue;
11240 }
11241
11242 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11243
11244 hashes_cnt++;
11245
11246 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11247
11248 if (parser_status < PARSER_GLOBAL_ZERO)
11249 {
11250 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11251
11252 continue;
11253 }
11254
11255 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11256
11257 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);
11258
11259 hashes_cnt++;
11260
11261 // show / left
11262
11263 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);
11264 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);
11265 }
11266 else
11267 {
11268 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11269
11270 if (parser_status < PARSER_GLOBAL_ZERO)
11271 {
11272 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11273
11274 continue;
11275 }
11276
11277 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);
11278
11279 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11280 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11281
11282 hashes_cnt++;
11283 }
11284 }
11285 else
11286 {
11287 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11288
11289 if (parser_status < PARSER_GLOBAL_ZERO)
11290 {
11291 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11292
11293 continue;
11294 }
11295
11296 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);
11297
11298 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11299 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11300
11301 hashes_cnt++;
11302 }
11303 }
11304
11305 myfree (line_buf);
11306
11307 fclose (fp);
11308
11309 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11310
11311 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11312 }
11313 }
11314 else
11315 {
11316 if (isSalted)
11317 {
11318 hashes_buf[0].salt->salt_len = 8;
11319
11320 // special salt handling
11321
11322 switch (hash_mode)
11323 {
11324 case 1500: hashes_buf[0].salt->salt_len = 2;
11325 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11326 break;
11327 case 1731: hashes_buf[0].salt->salt_len = 4;
11328 break;
11329 case 2410: hashes_buf[0].salt->salt_len = 4;
11330 break;
11331 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11332 break;
11333 case 3100: hashes_buf[0].salt->salt_len = 1;
11334 break;
11335 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11336 break;
11337 case 5800: hashes_buf[0].salt->salt_len = 16;
11338 break;
11339 case 6800: hashes_buf[0].salt->salt_len = 32;
11340 break;
11341 case 8400: hashes_buf[0].salt->salt_len = 40;
11342 break;
11343 case 8800: hashes_buf[0].salt->salt_len = 16;
11344 break;
11345 case 8900: hashes_buf[0].salt->salt_len = 16;
11346 hashes_buf[0].salt->scrypt_N = 1024;
11347 hashes_buf[0].salt->scrypt_r = 1;
11348 hashes_buf[0].salt->scrypt_p = 1;
11349 break;
11350 case 9100: hashes_buf[0].salt->salt_len = 16;
11351 break;
11352 case 9300: hashes_buf[0].salt->salt_len = 14;
11353 hashes_buf[0].salt->scrypt_N = 16384;
11354 hashes_buf[0].salt->scrypt_r = 1;
11355 hashes_buf[0].salt->scrypt_p = 1;
11356 break;
11357 case 9400: hashes_buf[0].salt->salt_len = 16;
11358 break;
11359 case 9500: hashes_buf[0].salt->salt_len = 16;
11360 break;
11361 case 9600: hashes_buf[0].salt->salt_len = 16;
11362 break;
11363 case 9700: hashes_buf[0].salt->salt_len = 16;
11364 break;
11365 case 9710: hashes_buf[0].salt->salt_len = 16;
11366 break;
11367 case 9720: hashes_buf[0].salt->salt_len = 16;
11368 break;
11369 case 9800: hashes_buf[0].salt->salt_len = 16;
11370 break;
11371 case 9810: hashes_buf[0].salt->salt_len = 16;
11372 break;
11373 case 9820: hashes_buf[0].salt->salt_len = 16;
11374 break;
11375 case 10300: hashes_buf[0].salt->salt_len = 12;
11376 break;
11377 case 11500: hashes_buf[0].salt->salt_len = 4;
11378 break;
11379 case 11600: hashes_buf[0].salt->salt_len = 4;
11380 break;
11381 case 12400: hashes_buf[0].salt->salt_len = 4;
11382 break;
11383 case 12500: hashes_buf[0].salt->salt_len = 8;
11384 break;
11385 case 12600: hashes_buf[0].salt->salt_len = 64;
11386 break;
11387 }
11388
11389 // special esalt handling
11390
11391 switch (hash_mode)
11392 {
11393 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11394 break;
11395 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11396 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11397 break;
11398 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11399 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11400 break;
11401 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11402 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11403 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11404 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11405 break;
11406 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11407 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11408 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11409 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11410 break;
11411 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11412 break;
11413 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11414 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11415 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11416 break;
11417 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11418 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11419 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11420 break;
11421 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11422 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11423 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11424 break;
11425 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11426 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11427 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11428 break;
11429 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11430 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11431 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11432 break;
11433 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11434 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11435 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11436 break;
11437 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11438 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11439 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11440 break;
11441 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11442 break;
11443 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
11444 break;
11445 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
11446 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
11447 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
11448 break;
11449 }
11450 }
11451
11452 // set hashfile
11453
11454 switch (hash_mode)
11455 {
11456 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11457 break;
11458 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11459 break;
11460 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11461 break;
11462 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11463 break;
11464 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11465 break;
11466 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11467 break;
11468 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11469 break;
11470 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11471 break;
11472 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11473 break;
11474 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11475 break;
11476 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11477 break;
11478 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11479 break;
11480 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11481 break;
11482 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11483 break;
11484 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11485 break;
11486 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11487 break;
11488 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11489 break;
11490 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11491 break;
11492 }
11493
11494 // set default iterations
11495
11496 switch (hash_mode)
11497 {
11498 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11499 break;
11500 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11501 break;
11502 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11503 break;
11504 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11505 break;
11506 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11507 break;
11508 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11509 break;
11510 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11511 break;
11512 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11513 break;
11514 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11515 break;
11516 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11517 break;
11518 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11519 break;
11520 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11521 break;
11522 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11523 break;
11524 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11525 break;
11526 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11527 break;
11528 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11529 break;
11530 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11531 break;
11532 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11533 break;
11534 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11535 break;
11536 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11537 break;
11538 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11539 break;
11540 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11541 break;
11542 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11543 break;
11544 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11545 break;
11546 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11547 break;
11548 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11549 break;
11550 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11551 break;
11552 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11553 break;
11554 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11555 break;
11556 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11557 break;
11558 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11559 break;
11560 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11561 break;
11562 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11563 break;
11564 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11565 break;
11566 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11567 break;
11568 case 8900: hashes_buf[0].salt->salt_iter = 1;
11569 break;
11570 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11571 break;
11572 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11573 break;
11574 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11575 break;
11576 case 9300: hashes_buf[0].salt->salt_iter = 1;
11577 break;
11578 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11579 break;
11580 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11581 break;
11582 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11583 break;
11584 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11585 break;
11586 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11587 break;
11588 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11589 break;
11590 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11591 break;
11592 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11593 break;
11594 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11595 break;
11596 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11597 break;
11598 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11599 break;
11600 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11601 break;
11602 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11603 break;
11604 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11605 break;
11606 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11607 break;
11608 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11609 break;
11610 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11611 break;
11612 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11613 break;
11614 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11615 break;
11616 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11617 break;
11618 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11619 break;
11620 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
11621 break;
11622 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
11623 break;
11624 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
11625 break;
11626 }
11627
11628 hashes_cnt = 1;
11629 }
11630
11631 if (show == 1 || left == 1)
11632 {
11633 for (uint i = 0; i < pot_cnt; i++)
11634 {
11635 pot_t *pot_ptr = &pot[i];
11636
11637 hash_t *hashes_buf = &pot_ptr->hash;
11638
11639 local_free (hashes_buf->digest);
11640
11641 if (isSalted)
11642 {
11643 local_free (hashes_buf->salt);
11644 }
11645 }
11646
11647 local_free (pot);
11648
11649 if (data.quiet == 0) log_info_nn ("");
11650
11651 return (0);
11652 }
11653
11654 if (keyspace == 0)
11655 {
11656 if (hashes_cnt == 0)
11657 {
11658 log_error ("ERROR: No hashes loaded");
11659
11660 return (-1);
11661 }
11662 }
11663
11664 /**
11665 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11666 */
11667
11668 if (data.outfile != NULL)
11669 {
11670 if (data.hashfile != NULL)
11671 {
11672 #ifdef _POSIX
11673 struct stat tmpstat_outfile;
11674 struct stat tmpstat_hashfile;
11675 #endif
11676
11677 #ifdef _WIN
11678 struct stat64 tmpstat_outfile;
11679 struct stat64 tmpstat_hashfile;
11680 #endif
11681
11682 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11683
11684 if (tmp_outfile_fp)
11685 {
11686 #ifdef _POSIX
11687 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11688 #endif
11689
11690 #ifdef _WIN
11691 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11692 #endif
11693
11694 fclose (tmp_outfile_fp);
11695 }
11696
11697 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11698
11699 if (tmp_hashfile_fp)
11700 {
11701 #ifdef _POSIX
11702 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11703 #endif
11704
11705 #ifdef _WIN
11706 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11707 #endif
11708
11709 fclose (tmp_hashfile_fp);
11710 }
11711
11712 if (tmp_outfile_fp && tmp_outfile_fp)
11713 {
11714 tmpstat_outfile.st_mode = 0;
11715 tmpstat_outfile.st_nlink = 0;
11716 tmpstat_outfile.st_uid = 0;
11717 tmpstat_outfile.st_gid = 0;
11718 tmpstat_outfile.st_rdev = 0;
11719 tmpstat_outfile.st_atime = 0;
11720
11721 tmpstat_hashfile.st_mode = 0;
11722 tmpstat_hashfile.st_nlink = 0;
11723 tmpstat_hashfile.st_uid = 0;
11724 tmpstat_hashfile.st_gid = 0;
11725 tmpstat_hashfile.st_rdev = 0;
11726 tmpstat_hashfile.st_atime = 0;
11727
11728 #ifdef _POSIX
11729 tmpstat_outfile.st_blksize = 0;
11730 tmpstat_outfile.st_blocks = 0;
11731
11732 tmpstat_hashfile.st_blksize = 0;
11733 tmpstat_hashfile.st_blocks = 0;
11734 #endif
11735
11736 #ifdef _POSIX
11737 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11738 {
11739 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11740
11741 return (-1);
11742 }
11743 #endif
11744
11745 #ifdef _WIN
11746 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11747 {
11748 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11749
11750 return (-1);
11751 }
11752 #endif
11753 }
11754 }
11755 }
11756
11757 /**
11758 * Remove duplicates
11759 */
11760
11761 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11762
11763 if (isSalted)
11764 {
11765 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11766 }
11767 else
11768 {
11769 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11770 }
11771
11772 uint hashes_cnt_orig = hashes_cnt;
11773
11774 hashes_cnt = 1;
11775
11776 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11777 {
11778 if (isSalted)
11779 {
11780 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11781 {
11782 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11783 }
11784 }
11785 else
11786 {
11787 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11788 }
11789
11790 if (hashes_pos > hashes_cnt)
11791 {
11792 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11793 }
11794
11795 hashes_cnt++;
11796 }
11797
11798 /**
11799 * Potfile removes
11800 */
11801
11802 uint potfile_remove_cracks = 0;
11803
11804 if (potfile_disable == 0)
11805 {
11806 hash_t hash_buf;
11807
11808 hash_buf.digest = mymalloc (dgst_size);
11809 hash_buf.salt = NULL;
11810 hash_buf.esalt = NULL;
11811 hash_buf.hash_info = NULL;
11812 hash_buf.cracked = 0;
11813
11814 if (isSalted)
11815 {
11816 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11817 }
11818
11819 if (esalt_size)
11820 {
11821 hash_buf.esalt = mymalloc (esalt_size);
11822 }
11823
11824 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11825
11826 // no solution for these special hash types (for instane because they use hashfile in output etc)
11827 if ((hash_mode != 5200) &&
11828 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11829 (hash_mode != 9000))
11830 {
11831 FILE *fp = fopen (potfile, "rb");
11832
11833 if (fp != NULL)
11834 {
11835 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11836
11837 // to be safe work with a copy (because of line_len loop, i etc)
11838 // moved up here because it's easier to handle continue case
11839 // it's just 64kb
11840
11841 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
11842
11843 while (!feof (fp))
11844 {
11845 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
11846
11847 if (ptr == NULL) break;
11848
11849 int line_len = strlen (line_buf);
11850
11851 if (line_len == 0) continue;
11852
11853 int iter = MAX_CUT_TRIES;
11854
11855 for (int i = line_len - 1; i && iter; i--, line_len--)
11856 {
11857 if (line_buf[i] != ':') continue;
11858
11859 if (isSalted)
11860 {
11861 memset (hash_buf.salt, 0, sizeof (salt_t));
11862 }
11863
11864 hash_t *found = NULL;
11865
11866 if (hash_mode == 6800)
11867 {
11868 if (i < 64) // 64 = 16 * uint in salt_buf[]
11869 {
11870 // manipulate salt_buf
11871 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11872
11873 hash_buf.salt->salt_len = i;
11874
11875 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11876 }
11877 }
11878 else if (hash_mode == 2500)
11879 {
11880 if (i < 64) // 64 = 16 * uint in salt_buf[]
11881 {
11882 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11883 // manipulate salt_buf
11884
11885 memcpy (line_buf_cpy, line_buf, i);
11886
11887 char *mac2_pos = strrchr (line_buf_cpy, ':');
11888
11889 if (mac2_pos == NULL) continue;
11890
11891 mac2_pos[0] = 0;
11892 mac2_pos++;
11893
11894 if (strlen (mac2_pos) != 12) continue;
11895
11896 char *mac1_pos = strrchr (line_buf_cpy, ':');
11897
11898 if (mac1_pos == NULL) continue;
11899
11900 mac1_pos[0] = 0;
11901 mac1_pos++;
11902
11903 if (strlen (mac1_pos) != 12) continue;
11904
11905 uint essid_length = mac1_pos - line_buf_cpy - 1;
11906
11907 // here we need the ESSID
11908 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11909
11910 hash_buf.salt->salt_len = essid_length;
11911
11912 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11913
11914 if (found)
11915 {
11916 wpa_t *wpa = (wpa_t *) found->esalt;
11917
11918 // compare hex string(s) vs binary MAC address(es)
11919
11920 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11921 {
11922 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11923 {
11924 found = NULL;
11925
11926 break;
11927 }
11928 }
11929
11930 // early skip ;)
11931 if (!found) continue;
11932
11933 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11934 {
11935 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11936 {
11937 found = NULL;
11938
11939 break;
11940 }
11941 }
11942 }
11943 }
11944 }
11945 else
11946 {
11947 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11948
11949 if (parser_status == PARSER_OK)
11950 {
11951 if (isSalted)
11952 {
11953 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11954 }
11955 else
11956 {
11957 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11958 }
11959 }
11960 }
11961
11962 if (found == NULL) continue;
11963
11964 if (!found->cracked) potfile_remove_cracks++;
11965
11966 found->cracked = 1;
11967
11968 if (found) break;
11969
11970 iter--;
11971 }
11972 }
11973
11974 myfree (line_buf_cpy);
11975
11976 myfree (line_buf);
11977
11978 fclose (fp);
11979 }
11980 }
11981
11982 if (esalt_size)
11983 {
11984 local_free (hash_buf.esalt);
11985 }
11986
11987 if (isSalted)
11988 {
11989 local_free (hash_buf.salt);
11990 }
11991
11992 local_free (hash_buf.digest);
11993 }
11994
11995 /**
11996 * Now generate all the buffers required for later
11997 */
11998
11999 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12000
12001 salt_t *salts_buf_new = NULL;
12002 void *esalts_buf_new = NULL;
12003
12004 if (isSalted)
12005 {
12006 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12007
12008 if (esalt_size)
12009 {
12010 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12011 }
12012 }
12013 else
12014 {
12015 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12016 }
12017
12018 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12019
12020 uint digests_cnt = hashes_cnt;
12021 uint digests_done = 0;
12022
12023 size_t size_digests = digests_cnt * dgst_size;
12024 size_t size_shown = digests_cnt * sizeof (uint);
12025
12026 uint *digests_shown = (uint *) mymalloc (size_shown);
12027 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12028
12029 uint salts_cnt = 0;
12030 uint salts_done = 0;
12031
12032 hashinfo_t **hash_info = NULL;
12033
12034 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12035 {
12036 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12037
12038 if (username && (remove || show))
12039 {
12040 uint user_pos;
12041
12042 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12043 {
12044 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12045
12046 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12047 }
12048 }
12049 }
12050
12051 uint *salts_shown = (uint *) mymalloc (size_shown);
12052
12053 salt_t *salt_buf;
12054
12055 {
12056 // copied from inner loop
12057
12058 salt_buf = &salts_buf_new[salts_cnt];
12059
12060 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12061
12062 if (esalt_size)
12063 {
12064 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12065 }
12066
12067 salt_buf->digests_cnt = 0;
12068 salt_buf->digests_done = 0;
12069 salt_buf->digests_offset = 0;
12070
12071 salts_cnt++;
12072 }
12073
12074 if (hashes_buf[0].cracked == 1)
12075 {
12076 digests_shown[0] = 1;
12077
12078 digests_done++;
12079
12080 salt_buf->digests_done++;
12081 }
12082
12083 salt_buf->digests_cnt++;
12084
12085 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12086
12087 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12088 {
12089 hash_info[0] = hashes_buf[0].hash_info;
12090 }
12091
12092 // copy from inner loop
12093
12094 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12095 {
12096 if (isSalted)
12097 {
12098 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12099 {
12100 salt_buf = &salts_buf_new[salts_cnt];
12101
12102 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12103
12104 if (esalt_size)
12105 {
12106 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12107 }
12108
12109 salt_buf->digests_cnt = 0;
12110 salt_buf->digests_done = 0;
12111 salt_buf->digests_offset = hashes_pos;
12112
12113 salts_cnt++;
12114 }
12115 }
12116
12117 if (hashes_buf[hashes_pos].cracked == 1)
12118 {
12119 digests_shown[hashes_pos] = 1;
12120
12121 digests_done++;
12122
12123 salt_buf->digests_done++;
12124 }
12125
12126 salt_buf->digests_cnt++;
12127
12128 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12129
12130 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12131 {
12132 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12133 }
12134 }
12135
12136 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12137 {
12138 salt_t *salt_buf = &salts_buf_new[salt_pos];
12139
12140 if (salt_buf->digests_done == salt_buf->digests_cnt)
12141 {
12142 salts_shown[salt_pos] = 1;
12143
12144 salts_done++;
12145 }
12146
12147 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12148 }
12149
12150 local_free (digests_buf);
12151 local_free (salts_buf);
12152 local_free (esalts_buf);
12153
12154 digests_buf = digests_buf_new;
12155 salts_buf = salts_buf_new;
12156 esalts_buf = esalts_buf_new;
12157
12158 local_free (hashes_buf);
12159
12160 /**
12161 * special modification not set from parser
12162 */
12163
12164 switch (hash_mode)
12165 {
12166 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12167 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12168 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12169 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12170 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12171 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12172 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12173 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12174 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12175 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12176 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12177 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12178 }
12179
12180 if (truecrypt_keyfiles)
12181 {
12182 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12183
12184 char *keyfiles = strdup (truecrypt_keyfiles);
12185
12186 char *keyfile = strtok (keyfiles, ",");
12187
12188 do
12189 {
12190 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12191
12192 } while ((keyfile = strtok (NULL, ",")) != NULL);
12193
12194 free (keyfiles);
12195 }
12196
12197 data.digests_cnt = digests_cnt;
12198 data.digests_done = digests_done;
12199 data.digests_buf = digests_buf;
12200 data.digests_shown = digests_shown;
12201 data.digests_shown_tmp = digests_shown_tmp;
12202
12203 data.salts_cnt = salts_cnt;
12204 data.salts_done = salts_done;
12205 data.salts_buf = salts_buf;
12206 data.salts_shown = salts_shown;
12207
12208 data.esalts_buf = esalts_buf;
12209 data.hash_info = hash_info;
12210
12211 /**
12212 * Automatic Optimizers
12213 */
12214
12215 if (salts_cnt == 1)
12216 opti_type |= OPTI_TYPE_SINGLE_SALT;
12217
12218 if (digests_cnt == 1)
12219 opti_type |= OPTI_TYPE_SINGLE_HASH;
12220
12221 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12222 opti_type |= OPTI_TYPE_NOT_ITERATED;
12223
12224 if (attack_mode == ATTACK_MODE_BF)
12225 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12226
12227 data.opti_type = opti_type;
12228
12229 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12230 {
12231 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12232 {
12233 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12234 {
12235 if (opts_type & OPTS_TYPE_ST_ADD80)
12236 {
12237 opts_type &= ~OPTS_TYPE_ST_ADD80;
12238 opts_type |= OPTS_TYPE_PT_ADD80;
12239 }
12240
12241 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12242 {
12243 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12244 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12245 }
12246
12247 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12248 {
12249 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12250 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12251 }
12252 }
12253 }
12254 }
12255
12256 /**
12257 * Some algorithm, like descrypt, can benefit from JIT compilation
12258 */
12259
12260 int force_jit_compilation = -1;
12261
12262 if (hash_mode == 8900)
12263 {
12264 force_jit_compilation = 8900;
12265 }
12266 else if (hash_mode == 9300)
12267 {
12268 force_jit_compilation = 8900;
12269 }
12270 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12271 {
12272 force_jit_compilation = 1500;
12273 }
12274
12275 /**
12276 * generate bitmap tables
12277 */
12278
12279 const uint bitmap_shift1 = 5;
12280 const uint bitmap_shift2 = 13;
12281
12282 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12283
12284 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12285 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12286 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12287 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12288 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12289 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12290 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12291 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12292
12293 uint bitmap_bits;
12294 uint bitmap_nums;
12295 uint bitmap_mask;
12296 uint bitmap_size;
12297
12298 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12299 {
12300 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12301
12302 bitmap_nums = 1 << bitmap_bits;
12303
12304 bitmap_mask = bitmap_nums - 1;
12305
12306 bitmap_size = bitmap_nums * sizeof (uint);
12307
12308 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12309
12310 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;
12311 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;
12312
12313 break;
12314 }
12315
12316 bitmap_nums = 1 << bitmap_bits;
12317
12318 bitmap_mask = bitmap_nums - 1;
12319
12320 bitmap_size = bitmap_nums * sizeof (uint);
12321
12322 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);
12323 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);
12324
12325 /**
12326 * prepare quick rule
12327 */
12328
12329 data.rule_buf_l = rule_buf_l;
12330 data.rule_buf_r = rule_buf_r;
12331
12332 int rule_len_l = (int) strlen (rule_buf_l);
12333 int rule_len_r = (int) strlen (rule_buf_r);
12334
12335 data.rule_len_l = rule_len_l;
12336 data.rule_len_r = rule_len_r;
12337
12338 /**
12339 * load rules
12340 */
12341
12342 uint *all_kernel_rules_cnt = NULL;
12343
12344 kernel_rule_t **all_kernel_rules_buf = NULL;
12345
12346 if (rp_files_cnt)
12347 {
12348 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12349
12350 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12351 }
12352
12353 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12354
12355 int rule_len = 0;
12356
12357 for (uint i = 0; i < rp_files_cnt; i++)
12358 {
12359 uint kernel_rules_avail = 0;
12360
12361 uint kernel_rules_cnt = 0;
12362
12363 kernel_rule_t *kernel_rules_buf = NULL;
12364
12365 char *rp_file = rp_files[i];
12366
12367 char in[BLOCK_SIZE] = { 0 };
12368 char out[BLOCK_SIZE] = { 0 };
12369
12370 FILE *fp = NULL;
12371
12372 uint rule_line = 0;
12373
12374 if ((fp = fopen (rp_file, "rb")) == NULL)
12375 {
12376 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12377
12378 return (-1);
12379 }
12380
12381 while (!feof (fp))
12382 {
12383 memset (rule_buf, 0, HCBUFSIZ);
12384
12385 rule_len = fgetl (fp, rule_buf);
12386
12387 rule_line++;
12388
12389 if (rule_len == 0) continue;
12390
12391 if (rule_buf[0] == '#') continue;
12392
12393 if (kernel_rules_avail == kernel_rules_cnt)
12394 {
12395 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12396
12397 kernel_rules_avail += INCR_RULES;
12398 }
12399
12400 memset (in, 0, BLOCK_SIZE);
12401 memset (out, 0, BLOCK_SIZE);
12402
12403 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12404
12405 if (result == -1)
12406 {
12407 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12408
12409 continue;
12410 }
12411
12412 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12413 {
12414 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12415
12416 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12417
12418 continue;
12419 }
12420
12421 /* its so slow
12422 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12423 {
12424 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12425
12426 continue;
12427 }
12428 */
12429
12430 kernel_rules_cnt++;
12431 }
12432
12433 fclose (fp);
12434
12435 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12436
12437 all_kernel_rules_buf[i] = kernel_rules_buf;
12438 }
12439
12440 /**
12441 * merge rules or automatic rule generator
12442 */
12443
12444 uint kernel_rules_cnt = 0;
12445
12446 kernel_rule_t *kernel_rules_buf = NULL;
12447
12448 if (attack_mode == ATTACK_MODE_STRAIGHT)
12449 {
12450 if (rp_files_cnt)
12451 {
12452 kernel_rules_cnt = 1;
12453
12454 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12455
12456 repeats[0] = kernel_rules_cnt;
12457
12458 for (uint i = 0; i < rp_files_cnt; i++)
12459 {
12460 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12461
12462 repeats[i + 1] = kernel_rules_cnt;
12463 }
12464
12465 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12466
12467 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12468
12469 for (uint i = 0; i < kernel_rules_cnt; i++)
12470 {
12471 uint out_pos = 0;
12472
12473 kernel_rule_t *out = &kernel_rules_buf[i];
12474
12475 for (uint j = 0; j < rp_files_cnt; j++)
12476 {
12477 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12478 uint in_pos;
12479
12480 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12481
12482 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12483 {
12484 if (out_pos == RULES_MAX - 1)
12485 {
12486 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12487
12488 break;
12489 }
12490
12491 out->cmds[out_pos] = in->cmds[in_pos];
12492 }
12493 }
12494 }
12495
12496 local_free (repeats);
12497 }
12498 else if (rp_gen)
12499 {
12500 uint kernel_rules_avail = 0;
12501
12502 while (kernel_rules_cnt < rp_gen)
12503 {
12504 if (kernel_rules_avail == kernel_rules_cnt)
12505 {
12506 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12507
12508 kernel_rules_avail += INCR_RULES;
12509 }
12510
12511 memset (rule_buf, 0, HCBUFSIZ);
12512
12513 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12514
12515 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12516
12517 kernel_rules_cnt++;
12518 }
12519 }
12520 }
12521
12522 myfree (rule_buf);
12523
12524 /**
12525 * generate NOP rules
12526 */
12527
12528 if (kernel_rules_cnt == 0)
12529 {
12530 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12531
12532 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12533
12534 kernel_rules_cnt++;
12535 }
12536
12537 data.kernel_rules_cnt = kernel_rules_cnt;
12538 data.kernel_rules_buf = kernel_rules_buf;
12539
12540 /**
12541 * OpenCL platforms: detect
12542 */
12543
12544 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12545 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12546
12547 cl_uint platforms_cnt = 0;
12548 cl_uint platform_devices_cnt = 0;
12549
12550 if (keyspace == 0)
12551 {
12552 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12553
12554 if (platforms_cnt == 0)
12555 {
12556 log_info ("");
12557 log_info ("ATTENTION! No OpenCL compatible platform found");
12558 log_info ("");
12559 log_info ("You're probably missing the OpenCL runtime installation");
12560 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
12561 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
12562 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
12563 log_info ("");
12564
12565 return (-1);
12566 }
12567
12568 if (opencl_platforms_filter != (uint) -1)
12569 {
12570 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
12571
12572 if (opencl_platforms_filter > platform_cnt_mask)
12573 {
12574 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
12575
12576 return (-1);
12577 }
12578 }
12579 }
12580
12581 /**
12582 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12583 */
12584
12585 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12586 {
12587 cl_platform_id platform = platforms[platform_id];
12588
12589 char platform_vendor[INFOSZ] = { 0 };
12590
12591 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12592
12593 #ifdef HAVE_HWMON
12594 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12595 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12596 {
12597 // make sure that we do not directly control the fan for NVidia
12598
12599 gpu_temp_retain = 0;
12600
12601 data.gpu_temp_retain = gpu_temp_retain;
12602 }
12603 #endif // HAVE_NVML || HAVE_NVAPI
12604 #endif
12605 }
12606
12607 /**
12608 * OpenCL device types:
12609 * 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.
12610 * In such a case, automatically enable CPU device type support, since it's disabled by default.
12611 */
12612
12613 if (opencl_device_types == NULL)
12614 {
12615 cl_device_type device_types_all = 0;
12616
12617 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12618 {
12619 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12620
12621 cl_platform_id platform = platforms[platform_id];
12622
12623 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12624
12625 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12626 {
12627 cl_device_id device = platform_devices[platform_devices_id];
12628
12629 cl_device_type device_type;
12630
12631 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12632
12633 device_types_all |= device_type;
12634 }
12635 }
12636
12637 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
12638 {
12639 device_types_filter |= CL_DEVICE_TYPE_CPU;
12640 }
12641 }
12642
12643 /**
12644 * OpenCL devices: simply push all devices from all platforms into the same device array
12645 */
12646
12647 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12648
12649 data.devices_param = devices_param;
12650
12651 uint devices_cnt = 0;
12652
12653 uint devices_active = 0;
12654
12655 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12656 {
12657 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12658
12659 cl_platform_id platform = platforms[platform_id];
12660
12661 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12662
12663 char platform_vendor[INFOSZ] = { 0 };
12664
12665 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12666
12667 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
12668 // this causes trouble with vendor id based macros
12669 // we'll assign generic to those without special optimization available
12670
12671 cl_uint vendor_id = 0;
12672
12673 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
12674 {
12675 vendor_id = VENDOR_ID_AMD;
12676 }
12677 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
12678 {
12679 vendor_id = VENDOR_ID_APPLE;
12680 }
12681 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
12682 {
12683 vendor_id = VENDOR_ID_INTEL_BEIGNET;
12684 }
12685 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
12686 {
12687 vendor_id = VENDOR_ID_INTEL_SDK;
12688 }
12689 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
12690 {
12691 vendor_id = VENDOR_ID_MESA;
12692 }
12693 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12694 {
12695 vendor_id = VENDOR_ID_NV;
12696 }
12697 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
12698 {
12699 vendor_id = VENDOR_ID_POCL;
12700 }
12701 else
12702 {
12703 vendor_id = VENDOR_ID_GENERIC;
12704 }
12705
12706 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12707 {
12708 size_t param_value_size = 0;
12709
12710 const uint device_id = devices_cnt;
12711
12712 hc_device_param_t *device_param = &data.devices_param[device_id];
12713
12714 device_param->vendor_id = vendor_id;
12715
12716 device_param->device = platform_devices[platform_devices_id];
12717
12718 device_param->device_id = device_id;
12719
12720 device_param->platform_devices_id = platform_devices_id;
12721
12722 // device_type
12723
12724 cl_device_type device_type;
12725
12726 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12727
12728 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12729
12730 device_param->device_type = device_type;
12731
12732 // device_name
12733
12734 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12735
12736 char *device_name = (char *) mymalloc (param_value_size);
12737
12738 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12739
12740 device_param->device_name = device_name;
12741
12742 // tuning db
12743
12744 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12745
12746 // device_version
12747
12748 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12749
12750 char *device_version = (char *) mymalloc (param_value_size);
12751
12752 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12753
12754 device_param->device_version = device_version;
12755
12756 // device_opencl_version
12757
12758 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12759
12760 char *device_opencl_version = (char *) mymalloc (param_value_size);
12761
12762 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12763
12764 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12765
12766 myfree (device_opencl_version);
12767
12768 // vector_width
12769
12770 cl_uint vector_width;
12771
12772 if (opencl_vector_width_chgd == 0)
12773 {
12774 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12775 {
12776 if (opti_type & OPTI_TYPE_USES_BITS_64)
12777 {
12778 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12779 }
12780 else
12781 {
12782 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12783 }
12784 }
12785 else
12786 {
12787 vector_width = (cl_uint) tuningdb_entry->vector_width;
12788 }
12789 }
12790 else
12791 {
12792 vector_width = opencl_vector_width;
12793 }
12794
12795 if (vector_width > 16) vector_width = 16;
12796
12797 device_param->vector_width = vector_width;
12798
12799 // max_compute_units
12800
12801 cl_uint device_processors;
12802
12803 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12804
12805 device_param->device_processors = device_processors;
12806
12807 // device_maxmem_alloc
12808 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
12809
12810 cl_ulong device_maxmem_alloc;
12811
12812 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12813
12814 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
12815
12816 // device_global_mem
12817
12818 cl_ulong device_global_mem;
12819
12820 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12821
12822 device_param->device_global_mem = device_global_mem;
12823
12824 // max_work_group_size
12825
12826 size_t device_maxworkgroup_size;
12827
12828 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
12829
12830 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
12831
12832 // max_clock_frequency
12833
12834 cl_uint device_maxclock_frequency;
12835
12836 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12837
12838 device_param->device_maxclock_frequency = device_maxclock_frequency;
12839
12840 // device_endian_little
12841
12842 cl_bool device_endian_little;
12843
12844 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
12845
12846 if (device_endian_little == CL_FALSE)
12847 {
12848 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
12849
12850 device_param->skipped = 1;
12851 }
12852
12853 // device_available
12854
12855 cl_bool device_available;
12856
12857 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
12858
12859 if (device_available == CL_FALSE)
12860 {
12861 log_info ("Device #%u: WARNING: device not available", device_id + 1);
12862
12863 device_param->skipped = 1;
12864 }
12865
12866 // device_compiler_available
12867
12868 cl_bool device_compiler_available;
12869
12870 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
12871
12872 if (device_compiler_available == CL_FALSE)
12873 {
12874 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
12875
12876 device_param->skipped = 1;
12877 }
12878
12879 // device_execution_capabilities
12880
12881 cl_device_exec_capabilities device_execution_capabilities;
12882
12883 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
12884
12885 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
12886 {
12887 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
12888
12889 device_param->skipped = 1;
12890 }
12891
12892 // device_extensions
12893
12894 size_t device_extensions_size;
12895
12896 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
12897
12898 char *device_extensions = mymalloc (device_extensions_size + 1);
12899
12900 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
12901
12902 if (strstr (device_extensions, "base_atomics") == 0)
12903 {
12904 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
12905
12906 device_param->skipped = 1;
12907 }
12908
12909 if (strstr (device_extensions, "byte_addressable_store") == 0)
12910 {
12911 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
12912
12913 device_param->skipped = 1;
12914 }
12915
12916 myfree (device_extensions);
12917
12918 // device_local_mem_size
12919
12920 cl_ulong device_local_mem_size;
12921
12922 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
12923
12924 if (device_local_mem_size < 32768)
12925 {
12926 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
12927
12928 device_param->skipped = 1;
12929 }
12930
12931
12932 // skipped
12933
12934 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
12935 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
12936
12937 // driver_version
12938
12939 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12940
12941 char *driver_version = (char *) mymalloc (param_value_size);
12942
12943 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12944
12945 device_param->driver_version = driver_version;
12946
12947 // device_name_chksum
12948
12949 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12950
12951 #if __x86_64__
12952 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);
12953 #else
12954 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);
12955 #endif
12956
12957 uint device_name_digest[4] = { 0 };
12958
12959 md5_64 ((uint *) device_name_chksum, device_name_digest);
12960
12961 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12962
12963 device_param->device_name_chksum = device_name_chksum;
12964
12965 // device_processor_cores
12966
12967 if (device_type & CL_DEVICE_TYPE_CPU)
12968 {
12969 cl_uint device_processor_cores = 1;
12970
12971 device_param->device_processor_cores = device_processor_cores;
12972 }
12973
12974 if (device_type & CL_DEVICE_TYPE_GPU)
12975 {
12976 if (vendor_id == VENDOR_ID_AMD)
12977 {
12978 cl_uint device_processor_cores = 0;
12979
12980 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12981
12982 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12983
12984 device_param->device_processor_cores = device_processor_cores;
12985 }
12986 else if (vendor_id == VENDOR_ID_NV)
12987 {
12988 cl_uint kernel_exec_timeout = 0;
12989
12990 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12991
12992 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12993
12994 device_param->kernel_exec_timeout = kernel_exec_timeout;
12995
12996 cl_uint device_processor_cores = 0;
12997
12998 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12999
13000 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13001
13002 device_param->device_processor_cores = device_processor_cores;
13003
13004 cl_uint sm_minor = 0;
13005 cl_uint sm_major = 0;
13006
13007 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13008 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13009
13010 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13011 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13012
13013 device_param->sm_minor = sm_minor;
13014 device_param->sm_major = sm_major;
13015 }
13016 else
13017 {
13018 cl_uint device_processor_cores = 1;
13019
13020 device_param->device_processor_cores = device_processor_cores;
13021 }
13022 }
13023
13024 // display results
13025
13026 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13027 {
13028 if (device_param->skipped == 0)
13029 {
13030 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
13031 device_id + 1,
13032 device_name,
13033 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13034 (unsigned int) (device_global_mem / 1024 / 1024),
13035 (unsigned int) (device_maxclock_frequency),
13036 (unsigned int) device_processors);
13037 }
13038 else
13039 {
13040 log_info ("Device #%u: %s, skipped",
13041 device_id + 1,
13042 device_name);
13043 }
13044 }
13045
13046 // common driver check
13047
13048 if (device_param->skipped == 0)
13049 {
13050 if (device_type & CL_DEVICE_TYPE_GPU)
13051 {
13052 if (vendor_id == VENDOR_ID_AMD)
13053 {
13054 int catalyst_check = (force == 1) ? 0 : 1;
13055
13056 int catalyst_warn = 0;
13057
13058 int catalyst_broken = 0;
13059
13060 if (catalyst_check == 1)
13061 {
13062 catalyst_warn = 1;
13063
13064 // v14.9 and higher
13065 if (atoi (device_param->driver_version) >= 1573)
13066 {
13067 catalyst_warn = 0;
13068 }
13069
13070 catalyst_check = 0;
13071 }
13072
13073 if (catalyst_broken == 1)
13074 {
13075 log_info ("");
13076 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13077 log_info ("It will pass over cracked hashes and does not report them as cracked");
13078 log_info ("You are STRONGLY encouraged not to use it");
13079 log_info ("You can use --force to override this but do not post error reports if you do so");
13080 log_info ("");
13081
13082 return (-1);
13083 }
13084
13085 if (catalyst_warn == 1)
13086 {
13087 log_info ("");
13088 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13089 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13090 log_info ("See hashcat's homepage for official supported catalyst drivers");
13091 #ifdef _WIN
13092 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13093 #endif
13094 log_info ("You can use --force to override this but do not post error reports if you do so");
13095 log_info ("");
13096
13097 return (-1);
13098 }
13099 }
13100 else if (vendor_id == VENDOR_ID_NV)
13101 {
13102 if (device_param->kernel_exec_timeout != 0)
13103 {
13104 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);
13105 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13106 }
13107 }
13108 }
13109
13110 if (device_type & CL_DEVICE_TYPE_CPU)
13111 {
13112 if (vendor_id == VENDOR_ID_AMD)
13113 {
13114 if (force == 0)
13115 {
13116 log_info ("");
13117 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13118 log_info ("You are STRONGLY encouraged not to use it");
13119 log_info ("You can use --force to override this but do not post error reports if you do so");
13120 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13121 log_info ("");
13122
13123 return (-1);
13124 }
13125 }
13126 }
13127
13128 /**
13129 * kernel accel and loops tuning db adjustment
13130 */
13131
13132 device_param->kernel_accel_min = 1;
13133 device_param->kernel_accel_max = 1024;
13134
13135 device_param->kernel_loops_min = 1;
13136 device_param->kernel_loops_max = 1024;
13137
13138 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13139
13140 if (tuningdb_entry)
13141 {
13142 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13143 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13144
13145 if (_kernel_accel)
13146 {
13147 device_param->kernel_accel_min = _kernel_accel;
13148 device_param->kernel_accel_max = _kernel_accel;
13149 }
13150
13151 if (_kernel_loops)
13152 {
13153 if (workload_profile == 1)
13154 {
13155 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13156 }
13157 else if (workload_profile == 2)
13158 {
13159 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13160 }
13161
13162 device_param->kernel_loops_min = _kernel_loops;
13163 device_param->kernel_loops_max = _kernel_loops;
13164 }
13165 }
13166
13167 // commandline parameters overwrite tuningdb entries
13168
13169 if (kernel_accel)
13170 {
13171 device_param->kernel_accel_min = kernel_accel;
13172 device_param->kernel_accel_max = kernel_accel;
13173 }
13174
13175 if (kernel_loops)
13176 {
13177 device_param->kernel_loops_min = kernel_loops;
13178 device_param->kernel_loops_max = kernel_loops;
13179 }
13180
13181 /**
13182 * activate device
13183 */
13184
13185 devices_active++;
13186 }
13187
13188 // next please
13189
13190 devices_cnt++;
13191 }
13192 }
13193
13194 if (keyspace == 0 && devices_active == 0)
13195 {
13196 log_error ("ERROR: No devices found/left");
13197
13198 return (-1);
13199 }
13200
13201 // 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)
13202
13203 if (devices_filter != (uint) -1)
13204 {
13205 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13206
13207 if (devices_filter > devices_cnt_mask)
13208 {
13209 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13210
13211 return (-1);
13212 }
13213 }
13214
13215 data.devices_cnt = devices_cnt;
13216
13217 data.devices_active = devices_active;
13218
13219 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13220 {
13221 log_info ("");
13222 }
13223
13224 /**
13225 * HM devices: init
13226 */
13227
13228 #ifdef HAVE_HWMON
13229 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13230 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13231 #endif
13232
13233 #ifdef HAVE_ADL
13234 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13235 #endif
13236
13237 if (gpu_temp_disable == 0)
13238 {
13239 #if defined(WIN) && defined(HAVE_NVAPI)
13240 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13241
13242 if (nvapi_init (nvapi) == 0)
13243 data.hm_nv = nvapi;
13244
13245 if (data.hm_nv)
13246 {
13247 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13248 {
13249 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13250
13251 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13252
13253 int tmp_out = 0;
13254
13255 for (int i = 0; i < tmp_in; i++)
13256 {
13257 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13258 }
13259
13260 for (int i = 0; i < tmp_out; i++)
13261 {
13262 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13263
13264 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13265
13266 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;
13267 }
13268 }
13269 }
13270 #endif // WIN && HAVE_NVAPI
13271
13272 #if defined(LINUX) && defined(HAVE_NVML)
13273 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13274
13275 if (nvml_init (nvml) == 0)
13276 data.hm_nv = nvml;
13277
13278 if (data.hm_nv)
13279 {
13280 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13281 {
13282 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13283
13284 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13285
13286 int tmp_out = 0;
13287
13288 for (int i = 0; i < tmp_in; i++)
13289 {
13290 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13291 }
13292
13293 for (int i = 0; i < tmp_out; i++)
13294 {
13295 unsigned int speed;
13296
13297 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;
13298 }
13299 }
13300 }
13301 #endif // LINUX && HAVE_NVML
13302
13303 data.hm_amd = NULL;
13304
13305 #ifdef HAVE_ADL
13306 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13307
13308 if (adl_init (adl) == 0)
13309 data.hm_amd = adl;
13310
13311 if (data.hm_amd)
13312 {
13313 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13314 {
13315 // total number of adapters
13316
13317 int hm_adapters_num;
13318
13319 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13320
13321 // adapter info
13322
13323 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13324
13325 if (lpAdapterInfo == NULL) return (-1);
13326
13327 // get a list (of ids of) valid/usable adapters
13328
13329 int num_adl_adapters = 0;
13330
13331 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13332
13333 if (num_adl_adapters > 0)
13334 {
13335 hc_thread_mutex_lock (mux_adl);
13336
13337 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13338
13339 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13340
13341 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13342 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13343
13344 hc_thread_mutex_unlock (mux_adl);
13345 }
13346
13347 myfree (valid_adl_device_list);
13348 myfree (lpAdapterInfo);
13349 }
13350 }
13351 #endif // HAVE_ADL
13352
13353 if (data.hm_amd == NULL && data.hm_nv == NULL)
13354 {
13355 gpu_temp_disable = 1;
13356 }
13357 }
13358
13359 /**
13360 * OpenCL devices: allocate buffer for device specific information
13361 */
13362
13363 #ifdef HAVE_HWMON
13364 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13365
13366 #ifdef HAVE_ADL
13367 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13368
13369 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13370 #endif // ADL
13371 #endif
13372
13373 /**
13374 * enable custom signal handler(s)
13375 */
13376
13377 if (benchmark == 0)
13378 {
13379 hc_signal (sigHandler_default);
13380 }
13381 else
13382 {
13383 hc_signal (sigHandler_benchmark);
13384 }
13385
13386 /**
13387 * User-defined GPU temp handling
13388 */
13389
13390 #ifdef HAVE_HWMON
13391 if (gpu_temp_disable == 1)
13392 {
13393 gpu_temp_abort = 0;
13394 gpu_temp_retain = 0;
13395 }
13396
13397 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13398 {
13399 if (gpu_temp_abort < gpu_temp_retain)
13400 {
13401 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13402
13403 return (-1);
13404 }
13405 }
13406
13407 data.gpu_temp_disable = gpu_temp_disable;
13408 data.gpu_temp_abort = gpu_temp_abort;
13409 data.gpu_temp_retain = gpu_temp_retain;
13410 #endif
13411
13412 /**
13413 * inform the user
13414 */
13415
13416 if (data.quiet == 0)
13417 {
13418 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13419
13420 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);
13421
13422 if (attack_mode == ATTACK_MODE_STRAIGHT)
13423 {
13424 log_info ("Rules: %u", kernel_rules_cnt);
13425 }
13426
13427 if (opti_type)
13428 {
13429 log_info ("Applicable Optimizers:");
13430
13431 for (uint i = 0; i < 32; i++)
13432 {
13433 const uint opti_bit = 1u << i;
13434
13435 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13436 }
13437 }
13438
13439 /**
13440 * Watchdog and Temperature balance
13441 */
13442
13443 #ifdef HAVE_HWMON
13444 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13445 {
13446 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13447 }
13448
13449 if (gpu_temp_abort == 0)
13450 {
13451 log_info ("Watchdog: Temperature abort trigger disabled");
13452 }
13453 else
13454 {
13455 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13456 }
13457
13458 if (gpu_temp_retain == 0)
13459 {
13460 log_info ("Watchdog: Temperature retain trigger disabled");
13461 }
13462 else
13463 {
13464 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13465 }
13466
13467 if (data.quiet == 0) log_info ("");
13468 #endif
13469 }
13470
13471 /**
13472 * HM devices: copy
13473 */
13474
13475 if (gpu_temp_disable == 0)
13476 {
13477 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13478 {
13479 hc_device_param_t *device_param = &data.devices_param[device_id];
13480
13481 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13482
13483 if (device_param->skipped) continue;
13484
13485 const uint platform_devices_id = device_param->platform_devices_id;
13486
13487 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13488 if (device_param->vendor_id == VENDOR_ID_NV)
13489 {
13490 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13491 }
13492 #endif
13493
13494 #ifdef HAVE_ADL
13495 if (device_param->vendor_id == VENDOR_ID_AMD)
13496 {
13497 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13498 }
13499 #endif
13500 }
13501 }
13502
13503 /*
13504 * Temporary fix:
13505 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13506 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13507 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13508 * Driver / ADL bug?
13509 */
13510
13511 #ifdef HAVE_ADL
13512 if (powertune_enable == 1)
13513 {
13514 hc_thread_mutex_lock (mux_adl);
13515
13516 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13517 {
13518 hc_device_param_t *device_param = &data.devices_param[device_id];
13519
13520 if (device_param->skipped) continue;
13521
13522 if (data.hm_device[device_id].od_version == 6)
13523 {
13524 // set powertune value only
13525
13526 int powertune_supported = 0;
13527
13528 int ADL_rc = 0;
13529
13530 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13531 {
13532 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13533
13534 return (-1);
13535 }
13536
13537 if (powertune_supported != 0)
13538 {
13539 // powertune set
13540 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13541
13542 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13543 {
13544 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13545
13546 return (-1);
13547 }
13548
13549 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13550 {
13551 log_error ("ERROR: Failed to set new ADL PowerControl values");
13552
13553 return (-1);
13554 }
13555 }
13556 }
13557 }
13558
13559 hc_thread_mutex_unlock (mux_adl);
13560 }
13561 #endif // HAVE_ADK
13562 #endif // HAVE_HWMON
13563
13564 #ifdef DEBUG
13565 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13566 #endif
13567
13568 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
13569
13570 uint kernel_power_all = 0;
13571
13572 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13573 {
13574 /**
13575 * host buffer
13576 */
13577
13578 hc_device_param_t *device_param = &data.devices_param[device_id];
13579
13580 if (device_param->skipped) continue;
13581
13582 /**
13583 * device properties
13584 */
13585
13586 const char *device_name_chksum = device_param->device_name_chksum;
13587 const u32 device_processors = device_param->device_processors;
13588 const u32 device_processor_cores = device_param->device_processor_cores;
13589
13590 /**
13591 * create context for each device
13592 */
13593
13594 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13595
13596 /**
13597 * create command-queue
13598 */
13599
13600 // not supported with NV
13601 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13602
13603 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13604
13605 /**
13606 * kernel threads: some algorithms need a fixed kernel-threads count
13607 * because of shared memory usage or bitslice
13608 * there needs to be some upper limit, otherwise there's too much overhead
13609 */
13610
13611 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
13612
13613 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
13614 {
13615 kernel_threads = KERNEL_THREADS_MAX_CPU;
13616 }
13617
13618 if (hash_mode == 1500) kernel_threads = 64; // DES
13619 if (hash_mode == 3000) kernel_threads = 64; // DES
13620 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
13621 if (hash_mode == 7500) kernel_threads = 64; // RC4
13622 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
13623 if (hash_mode == 9700) kernel_threads = 64; // RC4
13624 if (hash_mode == 9710) kernel_threads = 64; // RC4
13625 if (hash_mode == 9800) kernel_threads = 64; // RC4
13626 if (hash_mode == 9810) kernel_threads = 64; // RC4
13627 if (hash_mode == 10400) kernel_threads = 64; // RC4
13628 if (hash_mode == 10410) kernel_threads = 64; // RC4
13629 if (hash_mode == 10500) kernel_threads = 64; // RC4
13630 if (hash_mode == 13100) kernel_threads = 64; // RC4
13631
13632 /**
13633 * create input buffers on device : calculate size of fixed memory buffers
13634 */
13635
13636 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
13637 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13638
13639 device_param->size_root_css = size_root_css;
13640 device_param->size_markov_css = size_markov_css;
13641
13642 size_t size_results = kernel_threads * sizeof (uint);
13643
13644 device_param->size_results = size_results;
13645
13646 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13647 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13648
13649 size_t size_plains = digests_cnt * sizeof (plain_t);
13650 size_t size_salts = salts_cnt * sizeof (salt_t);
13651 size_t size_esalts = salts_cnt * esalt_size;
13652
13653 device_param->size_plains = size_plains;
13654 device_param->size_digests = size_digests;
13655 device_param->size_shown = size_shown;
13656 device_param->size_salts = size_salts;
13657
13658 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
13659 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
13660 size_t size_tm = 32 * sizeof (bs_word_t);
13661
13662 // scryptV stuff
13663
13664 size_t size_scryptV = 1;
13665
13666 if ((hash_mode == 8900) || (hash_mode == 9300))
13667 {
13668 uint tmto_start = 0;
13669 uint tmto_stop = 10;
13670
13671 if (scrypt_tmto)
13672 {
13673 tmto_start = scrypt_tmto;
13674 }
13675 else
13676 {
13677 // in case the user did not specify the tmto manually
13678 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13679 // but set the lower end only in case the user has a device with too less memory
13680
13681 if (hash_mode == 8900)
13682 {
13683 if (device_param->vendor_id == VENDOR_ID_AMD)
13684 {
13685 tmto_start = 1;
13686 }
13687 else if (device_param->vendor_id == VENDOR_ID_NV)
13688 {
13689 tmto_start = 2;
13690 }
13691 }
13692 else if (hash_mode == 9300)
13693 {
13694 if (device_param->vendor_id == VENDOR_ID_AMD)
13695 {
13696 tmto_start = 2;
13697 }
13698 else if (device_param->vendor_id == VENDOR_ID_NV)
13699 {
13700 tmto_start = 2;
13701 }
13702 }
13703 }
13704
13705 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13706 {
13707 // TODO: in theory the following calculation needs to be done per salt, not global
13708 // we assume all hashes have the same scrypt settings
13709
13710 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13711
13712 size_scryptV /= 1 << tmto;
13713
13714 size_scryptV *= device_processors * device_processor_cores;
13715
13716 if (size_scryptV > device_param->device_maxmem_alloc)
13717 {
13718 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13719
13720 continue;
13721 }
13722
13723 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13724 {
13725 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13726 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
13727 }
13728
13729 break;
13730 }
13731
13732 if (data.salts_buf[0].scrypt_phy == 0)
13733 {
13734 log_error ("ERROR: can't allocate enough device memory");
13735
13736 return -1;
13737 }
13738
13739 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13740 }
13741
13742 /**
13743 * some algorithms need a fixed kernel-loops count
13744 */
13745
13746 if (hash_mode == 1500)
13747 {
13748 const u32 kernel_loops_fixed = 1024;
13749
13750 device_param->kernel_loops_min = kernel_loops_fixed;
13751 device_param->kernel_loops_max = kernel_loops_fixed;
13752 }
13753
13754 if (hash_mode == 3000)
13755 {
13756 const u32 kernel_loops_fixed = 1024;
13757
13758 device_param->kernel_loops_min = kernel_loops_fixed;
13759 device_param->kernel_loops_max = kernel_loops_fixed;
13760 }
13761
13762 if (hash_mode == 8900)
13763 {
13764 const u32 kernel_loops_fixed = 1;
13765
13766 device_param->kernel_loops_min = kernel_loops_fixed;
13767 device_param->kernel_loops_max = kernel_loops_fixed;
13768 }
13769
13770 if (hash_mode == 9300)
13771 {
13772 const u32 kernel_loops_fixed = 1;
13773
13774 device_param->kernel_loops_min = kernel_loops_fixed;
13775 device_param->kernel_loops_max = kernel_loops_fixed;
13776 }
13777
13778 if (hash_mode == 12500)
13779 {
13780 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13781
13782 device_param->kernel_loops_min = kernel_loops_fixed;
13783 device_param->kernel_loops_max = kernel_loops_fixed;
13784 }
13785
13786 /**
13787 * some algorithms have a maximum kernel-loops count
13788 */
13789
13790 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13791 {
13792 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13793 {
13794 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13795 }
13796 }
13797
13798 /**
13799 * some algorithms need a special kernel-accel
13800 */
13801
13802 if (hash_mode == 8900)
13803 {
13804 device_param->kernel_accel_min = 1;
13805 device_param->kernel_accel_max = 64;
13806 }
13807
13808 if (hash_mode == 9300)
13809 {
13810 device_param->kernel_accel_min = 1;
13811 device_param->kernel_accel_max = 64;
13812 }
13813
13814 u32 kernel_accel_min = device_param->kernel_accel_min;
13815 u32 kernel_accel_max = device_param->kernel_accel_max;
13816
13817 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13818
13819 size_t size_pws = 4;
13820 size_t size_tmps = 4;
13821 size_t size_hooks = 4;
13822
13823 while (kernel_accel_max >= kernel_accel_min)
13824 {
13825 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13826
13827 // size_pws
13828
13829 size_pws = kernel_power_max * sizeof (pw_t);
13830
13831 // size_tmps
13832
13833 switch (hash_mode)
13834 {
13835 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13836 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13837 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13838 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13839 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13840 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13841 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13842 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13843 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13844 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13845 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13846 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13847 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13848 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13849 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13850 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13851 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13852 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13853 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13854 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13855 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13856 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13857 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13858 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13859 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13860 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13861 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13862 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13863 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13864 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13865 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13866 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13867 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13868 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13869 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13870 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13871 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13872 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13873 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13874 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13875 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13876 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13877 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13878 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13879 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13880 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13881 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13882 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13883 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13884 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13885 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13886 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13887 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13888 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13889 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13890 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13891 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13892 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13893 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13894 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13895 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13896 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
13897 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
13898 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13899 };
13900
13901 // size_hooks
13902
13903 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13904 {
13905 // none yet
13906 }
13907
13908 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13909 // if not, decrease amplifier and try again
13910
13911 int skip = 0;
13912
13913 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13914 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13915 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13916
13917 if (( bitmap_size
13918 + bitmap_size
13919 + bitmap_size
13920 + bitmap_size
13921 + bitmap_size
13922 + bitmap_size
13923 + bitmap_size
13924 + bitmap_size
13925 + size_bfs
13926 + size_combs
13927 + size_digests
13928 + size_esalts
13929 + size_hooks
13930 + size_markov_css
13931 + size_plains
13932 + size_pws
13933 + size_pws // not a bug
13934 + size_results
13935 + size_root_css
13936 + size_rules
13937 + size_rules_c
13938 + size_salts
13939 + size_scryptV
13940 + size_shown
13941 + size_tm
13942 + size_tmps) > device_param->device_global_mem) skip = 1;
13943
13944 if (skip == 1)
13945 {
13946 kernel_accel_max--;
13947
13948 continue;
13949 }
13950
13951 break;
13952 }
13953
13954 /*
13955 if (kernel_accel_max == 0)
13956 {
13957 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13958
13959 return -1;
13960 }
13961 */
13962
13963 device_param->kernel_accel_min = kernel_accel_min;
13964 device_param->kernel_accel_max = kernel_accel_max;
13965
13966 /*
13967 if (kernel_accel_max < kernel_accel)
13968 {
13969 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13970
13971 device_param->kernel_accel = kernel_accel_max;
13972 }
13973 */
13974
13975 device_param->size_bfs = size_bfs;
13976 device_param->size_combs = size_combs;
13977 device_param->size_rules = size_rules;
13978 device_param->size_rules_c = size_rules_c;
13979 device_param->size_pws = size_pws;
13980 device_param->size_tmps = size_tmps;
13981 device_param->size_hooks = size_hooks;
13982
13983 // do not confuse kernel_accel_max with kernel_accel here
13984
13985 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13986
13987 device_param->kernel_threads = kernel_threads;
13988 device_param->kernel_power_user = kernel_power;
13989
13990 kernel_power_all += kernel_power;
13991
13992 /**
13993 * default building options
13994 */
13995
13996 char build_opts[1024] = { 0 };
13997
13998 // we don't have sm_* on vendors not NV but it doesn't matter
13999
14000 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);
14001
14002 if (device_param->vendor_id == VENDOR_ID_INTEL_SDK)
14003 {
14004 // we do vectorizing much better than the auto-vectorizer
14005
14006 char build_opts_new[1024] = { 0 };
14007
14008 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14009
14010 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14011 }
14012
14013 #ifdef DEBUG
14014 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14015 #endif
14016
14017 /**
14018 * main kernel
14019 */
14020
14021 {
14022 /**
14023 * kernel source filename
14024 */
14025
14026 char source_file[256] = { 0 };
14027
14028 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14029
14030 struct stat sst;
14031
14032 if (stat (source_file, &sst) == -1)
14033 {
14034 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14035
14036 return -1;
14037 }
14038
14039 /**
14040 * kernel cached filename
14041 */
14042
14043 char cached_file[256] = { 0 };
14044
14045 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14046
14047 int cached = 1;
14048
14049 struct stat cst;
14050
14051 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14052 {
14053 cached = 0;
14054 }
14055
14056 /**
14057 * kernel compile or load
14058 */
14059
14060 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14061
14062 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14063
14064 if (force_jit_compilation == -1)
14065 {
14066 if (cached == 0)
14067 {
14068 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14069
14070 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14071
14072 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14073
14074 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14075
14076 #ifdef DEBUG
14077 size_t build_log_size = 0;
14078
14079 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14080
14081 if (build_log_size > 1)
14082 {
14083 char *build_log = (char *) malloc (build_log_size + 1);
14084
14085 memset (build_log, 0, build_log_size + 1);
14086
14087 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14088
14089 puts (build_log);
14090
14091 free (build_log);
14092 }
14093 #endif
14094
14095 if (rc != 0)
14096 {
14097 device_param->skipped = true;
14098
14099 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14100
14101 continue;
14102 }
14103
14104 size_t binary_size;
14105
14106 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14107
14108 u8 *binary = (u8 *) mymalloc (binary_size);
14109
14110 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14111
14112 writeProgramBin (cached_file, binary, binary_size);
14113
14114 local_free (binary);
14115 }
14116 else
14117 {
14118 #ifdef DEBUG
14119 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14120 #endif
14121
14122 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14123
14124 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14125
14126 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14127 }
14128 }
14129 else
14130 {
14131 #ifdef DEBUG
14132 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14133 #endif
14134
14135 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14136
14137 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14138
14139 char build_opts_update[1024] = { 0 };
14140
14141 if (force_jit_compilation == 1500)
14142 {
14143 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14144 }
14145 else if (force_jit_compilation == 8900)
14146 {
14147 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);
14148 }
14149 else
14150 {
14151 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14152 }
14153
14154 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14155
14156 #ifdef DEBUG
14157 size_t build_log_size = 0;
14158
14159 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14160
14161 if (build_log_size > 1)
14162 {
14163 char *build_log = (char *) malloc (build_log_size + 1);
14164
14165 memset (build_log, 0, build_log_size + 1);
14166
14167 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14168
14169 puts (build_log);
14170
14171 free (build_log);
14172 }
14173 #endif
14174
14175 if (rc != 0)
14176 {
14177 device_param->skipped = true;
14178
14179 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14180 }
14181 }
14182
14183 local_free (kernel_lengths);
14184 local_free (kernel_sources[0]);
14185 local_free (kernel_sources);
14186 }
14187
14188 /**
14189 * word generator kernel
14190 */
14191
14192 if (attack_mode != ATTACK_MODE_STRAIGHT)
14193 {
14194 /**
14195 * kernel mp source filename
14196 */
14197
14198 char source_file[256] = { 0 };
14199
14200 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14201
14202 struct stat sst;
14203
14204 if (stat (source_file, &sst) == -1)
14205 {
14206 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14207
14208 return -1;
14209 }
14210
14211 /**
14212 * kernel mp cached filename
14213 */
14214
14215 char cached_file[256] = { 0 };
14216
14217 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14218
14219 int cached = 1;
14220
14221 struct stat cst;
14222
14223 if (stat (cached_file, &cst) == -1)
14224 {
14225 cached = 0;
14226 }
14227
14228 /**
14229 * kernel compile or load
14230 */
14231
14232 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14233
14234 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14235
14236 if (cached == 0)
14237 {
14238 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14239 if (quiet == 0) log_info ("");
14240
14241 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14242
14243 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14244
14245 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14246
14247 if (rc != 0)
14248 {
14249 device_param->skipped = true;
14250
14251 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14252
14253 continue;
14254 }
14255
14256 size_t binary_size;
14257
14258 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14259
14260 u8 *binary = (u8 *) mymalloc (binary_size);
14261
14262 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14263
14264 writeProgramBin (cached_file, binary, binary_size);
14265
14266 local_free (binary);
14267 }
14268 else
14269 {
14270 #ifdef DEBUG
14271 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14272 #endif
14273
14274 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14275
14276 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14277
14278 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14279 }
14280
14281 local_free (kernel_lengths);
14282 local_free (kernel_sources[0]);
14283 local_free (kernel_sources);
14284 }
14285
14286 /**
14287 * amplifier kernel
14288 */
14289
14290 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14291 {
14292
14293 }
14294 else
14295 {
14296 /**
14297 * kernel amp source filename
14298 */
14299
14300 char source_file[256] = { 0 };
14301
14302 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14303
14304 struct stat sst;
14305
14306 if (stat (source_file, &sst) == -1)
14307 {
14308 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14309
14310 return -1;
14311 }
14312
14313 /**
14314 * kernel amp cached filename
14315 */
14316
14317 char cached_file[256] = { 0 };
14318
14319 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14320
14321 int cached = 1;
14322
14323 struct stat cst;
14324
14325 if (stat (cached_file, &cst) == -1)
14326 {
14327 cached = 0;
14328 }
14329
14330 /**
14331 * kernel compile or load
14332 */
14333
14334 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14335
14336 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14337
14338 if (cached == 0)
14339 {
14340 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14341 if (quiet == 0) log_info ("");
14342
14343 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14344
14345 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14346
14347 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14348
14349 if (rc != 0)
14350 {
14351 device_param->skipped = true;
14352
14353 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14354
14355 continue;
14356 }
14357
14358 size_t binary_size;
14359
14360 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14361
14362 u8 *binary = (u8 *) mymalloc (binary_size);
14363
14364 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14365
14366 writeProgramBin (cached_file, binary, binary_size);
14367
14368 local_free (binary);
14369 }
14370 else
14371 {
14372 #ifdef DEBUG
14373 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14374 #endif
14375
14376 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14377
14378 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14379
14380 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14381 }
14382
14383 local_free (kernel_lengths);
14384 local_free (kernel_sources[0]);
14385 local_free (kernel_sources);
14386 }
14387
14388 // some algorithm collide too fast, make that impossible
14389
14390 if (benchmark == 1)
14391 {
14392 ((uint *) digests_buf)[0] = -1;
14393 ((uint *) digests_buf)[1] = -1;
14394 ((uint *) digests_buf)[2] = -1;
14395 ((uint *) digests_buf)[3] = -1;
14396 }
14397
14398 /**
14399 * global buffers
14400 */
14401
14402 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14403 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14404 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14405 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14406 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14407 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14408 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14409 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14410 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14411 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14412 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14413 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14414 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14415 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14416 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14417 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14418 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14419 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14420
14421 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);
14422 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);
14423 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);
14424 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);
14425 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);
14426 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);
14427 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);
14428 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);
14429 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14430 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14431 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14432
14433 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14434 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14435 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14436 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14437 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14438 run_kernel_bzero (device_param, device_param->d_result, size_results);
14439
14440 /**
14441 * special buffers
14442 */
14443
14444 if (attack_kern == ATTACK_KERN_STRAIGHT)
14445 {
14446 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14447 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14448
14449 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14450
14451 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14452 }
14453 else if (attack_kern == ATTACK_KERN_COMBI)
14454 {
14455 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14456 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14457 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14458 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14459
14460 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14461 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14462 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14463 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14464 }
14465 else if (attack_kern == ATTACK_KERN_BF)
14466 {
14467 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14468 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14469 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14470 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14471 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14472
14473 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14474 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14475 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14476 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14477 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14478 }
14479
14480 if (size_esalts)
14481 {
14482 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14483
14484 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14485 }
14486
14487 /**
14488 * main host data
14489 */
14490
14491 uint *result = (uint *) mymalloc (size_results);
14492
14493 device_param->result = result;
14494
14495 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14496
14497 device_param->pws_buf = pws_buf;
14498
14499 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14500
14501 device_param->combs_buf = combs_buf;
14502
14503 void *hooks_buf = mymalloc (size_hooks);
14504
14505 device_param->hooks_buf = hooks_buf;
14506
14507 /**
14508 * kernel args
14509 */
14510
14511 device_param->kernel_params_buf32[21] = bitmap_mask;
14512 device_param->kernel_params_buf32[22] = bitmap_shift1;
14513 device_param->kernel_params_buf32[23] = bitmap_shift2;
14514 device_param->kernel_params_buf32[24] = 0; // salt_pos
14515 device_param->kernel_params_buf32[25] = 0; // loop_pos
14516 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14517 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14518 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14519 device_param->kernel_params_buf32[29] = 0; // digests_offset
14520 device_param->kernel_params_buf32[30] = 0; // combs_mode
14521 device_param->kernel_params_buf32[31] = 0; // gid_max
14522
14523 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14524 ? &device_param->d_pws_buf
14525 : &device_param->d_pws_amp_buf;
14526 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14527 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14528 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14529 device_param->kernel_params[ 4] = &device_param->d_tmps;
14530 device_param->kernel_params[ 5] = &device_param->d_hooks;
14531 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14532 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14533 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14534 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14535 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14536 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14537 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14538 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14539 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14540 device_param->kernel_params[15] = &device_param->d_digests_buf;
14541 device_param->kernel_params[16] = &device_param->d_digests_shown;
14542 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14543 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14544 device_param->kernel_params[19] = &device_param->d_result;
14545 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14546 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14547 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14548 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14549 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14550 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14551 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14552 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14553 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14554 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14555 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14556 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14557
14558 device_param->kernel_params_mp_buf64[3] = 0;
14559 device_param->kernel_params_mp_buf32[4] = 0;
14560 device_param->kernel_params_mp_buf32[5] = 0;
14561 device_param->kernel_params_mp_buf32[6] = 0;
14562 device_param->kernel_params_mp_buf32[7] = 0;
14563 device_param->kernel_params_mp_buf32[8] = 0;
14564
14565 device_param->kernel_params_mp[0] = NULL;
14566 device_param->kernel_params_mp[1] = NULL;
14567 device_param->kernel_params_mp[2] = NULL;
14568 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14569 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14570 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14571 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14572 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14573 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14574
14575 device_param->kernel_params_mp_l_buf64[3] = 0;
14576 device_param->kernel_params_mp_l_buf32[4] = 0;
14577 device_param->kernel_params_mp_l_buf32[5] = 0;
14578 device_param->kernel_params_mp_l_buf32[6] = 0;
14579 device_param->kernel_params_mp_l_buf32[7] = 0;
14580 device_param->kernel_params_mp_l_buf32[8] = 0;
14581 device_param->kernel_params_mp_l_buf32[9] = 0;
14582
14583 device_param->kernel_params_mp_l[0] = NULL;
14584 device_param->kernel_params_mp_l[1] = NULL;
14585 device_param->kernel_params_mp_l[2] = NULL;
14586 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14587 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14588 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14589 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14590 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14591 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14592 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14593
14594 device_param->kernel_params_mp_r_buf64[3] = 0;
14595 device_param->kernel_params_mp_r_buf32[4] = 0;
14596 device_param->kernel_params_mp_r_buf32[5] = 0;
14597 device_param->kernel_params_mp_r_buf32[6] = 0;
14598 device_param->kernel_params_mp_r_buf32[7] = 0;
14599 device_param->kernel_params_mp_r_buf32[8] = 0;
14600
14601 device_param->kernel_params_mp_r[0] = NULL;
14602 device_param->kernel_params_mp_r[1] = NULL;
14603 device_param->kernel_params_mp_r[2] = NULL;
14604 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14605 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14606 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14607 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14608 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14609 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14610
14611 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14612 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14613
14614 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14615 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14616 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14617 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14618 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14619 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14620 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14621
14622 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14623 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14624
14625 /**
14626 * kernel name
14627 */
14628
14629 size_t kernel_wgs_tmp;
14630
14631 char kernel_name[64] = { 0 };
14632
14633 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14634 {
14635 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14636 {
14637 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14638
14639 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14640
14641 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14642
14643 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14644
14645 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14646
14647 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14648 }
14649 else
14650 {
14651 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14652
14653 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14654
14655 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14656
14657 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14658
14659 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14660
14661 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14662 }
14663
14664 if (data.attack_mode == ATTACK_MODE_BF)
14665 {
14666 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14667 {
14668 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14669
14670 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14671
14672 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);
14673 }
14674 }
14675 }
14676 else
14677 {
14678 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14679
14680 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14681
14682 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14683
14684 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14685
14686 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14687
14688 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14689
14690 if (opts_type & OPTS_TYPE_HOOK12)
14691 {
14692 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14693
14694 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14695
14696 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);
14697 }
14698
14699 if (opts_type & OPTS_TYPE_HOOK23)
14700 {
14701 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14702
14703 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14704
14705 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);
14706 }
14707 }
14708
14709 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);
14710 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);
14711 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);
14712
14713 for (uint i = 0; i <= 20; i++)
14714 {
14715 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14716 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14717 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14718
14719 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14720 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14721 }
14722
14723 for (uint i = 21; i <= 31; i++)
14724 {
14725 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14726 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14727 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14728
14729 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14730 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14731 }
14732
14733 if (attack_mode == ATTACK_MODE_BF)
14734 {
14735 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14736 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14737
14738 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);
14739 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);
14740
14741 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14742 {
14743 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14744 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14745 }
14746 }
14747 else if (attack_mode == ATTACK_MODE_HYBRID1)
14748 {
14749 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14750
14751 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);
14752 }
14753 else if (attack_mode == ATTACK_MODE_HYBRID2)
14754 {
14755 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14756
14757 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);
14758 }
14759
14760 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14761 {
14762 // nothing to do
14763 }
14764 else
14765 {
14766 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14767
14768 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);
14769 }
14770
14771 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14772 {
14773 // nothing to do
14774 }
14775 else
14776 {
14777 for (uint i = 0; i < 5; i++)
14778 {
14779 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14780 }
14781
14782 for (uint i = 5; i < 7; i++)
14783 {
14784 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14785 }
14786 }
14787
14788 // maybe this has been updated by clGetKernelWorkGroupInfo()
14789 // value can only be decreased, so we don't need to reallocate buffers
14790
14791 device_param->kernel_threads = kernel_threads;
14792
14793 /**
14794 * Store initial fanspeed if gpu_temp_retain is enabled
14795 */
14796
14797 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14798 int gpu_temp_retain_set = 0;
14799
14800 if (gpu_temp_disable == 0)
14801 {
14802 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14803 {
14804 hc_thread_mutex_lock (mux_adl);
14805
14806 if (data.hm_device[device_id].fan_supported == 1)
14807 {
14808 if (gpu_temp_retain_chgd == 0)
14809 {
14810 uint cur_temp = 0;
14811 uint default_temp = 0;
14812
14813 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);
14814
14815 if (ADL_rc == ADL_OK)
14816 {
14817 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14818
14819 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14820
14821 // special case with multi gpu setups: always use minimum retain
14822
14823 if (gpu_temp_retain_set == 0)
14824 {
14825 gpu_temp_retain = gpu_temp_retain_target;
14826 gpu_temp_retain_set = 1;
14827 }
14828 else
14829 {
14830 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14831 }
14832
14833 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14834 }
14835 }
14836
14837 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14838
14839 temp_retain_fanspeed_value[device_id] = fan_speed;
14840
14841 if (fan_speed == -1)
14842 {
14843 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14844
14845 temp_retain_fanspeed_value[device_id] = 0;
14846 }
14847 }
14848
14849 hc_thread_mutex_unlock (mux_adl);
14850 }
14851 }
14852
14853 /**
14854 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14855 */
14856
14857 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14858 {
14859 hc_thread_mutex_lock (mux_adl);
14860
14861 if (data.hm_device[device_id].od_version == 6)
14862 {
14863 int ADL_rc;
14864
14865 // check powertune capabilities first, if not available then skip device
14866
14867 int powertune_supported = 0;
14868
14869 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14870 {
14871 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14872
14873 return (-1);
14874 }
14875
14876 if (powertune_supported != 0)
14877 {
14878 // powercontrol settings
14879
14880 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14881
14882 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14883 {
14884 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14885 }
14886
14887 if (ADL_rc != ADL_OK)
14888 {
14889 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14890
14891 return (-1);
14892 }
14893
14894 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14895 {
14896 log_error ("ERROR: Failed to set new ADL PowerControl values");
14897
14898 return (-1);
14899 }
14900
14901 // clocks
14902
14903 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14904
14905 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14906
14907 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)
14908 {
14909 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14910
14911 return (-1);
14912 }
14913
14914 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14915
14916 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14917
14918 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14919 {
14920 log_error ("ERROR: Failed to get ADL device capabilities");
14921
14922 return (-1);
14923 }
14924
14925 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14926 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14927
14928 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14929 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14930
14931 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14932 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14933
14934 // warning if profile has too low max values
14935
14936 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14937 {
14938 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14939 }
14940
14941 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14942 {
14943 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14944 }
14945
14946 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14947
14948 performance_state->iNumberOfPerformanceLevels = 2;
14949
14950 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14951 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14952 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14953 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14954
14955 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)
14956 {
14957 log_info ("ERROR: Failed to set ADL performance state");
14958
14959 return (-1);
14960 }
14961
14962 local_free (performance_state);
14963 }
14964 }
14965
14966 hc_thread_mutex_unlock (mux_adl);
14967 }
14968 #endif // HAVE_HWMON && HAVE_ADL
14969 }
14970
14971 data.kernel_power_all = kernel_power_all;
14972
14973 if (data.quiet == 0) log_info_nn ("");
14974
14975 /**
14976 * In benchmark-mode, inform user which algorithm is checked
14977 */
14978
14979 if (benchmark == 1)
14980 {
14981 quiet = 0;
14982
14983 data.quiet = quiet;
14984
14985 char *hash_type = strhashtype (data.hash_mode); // not a bug
14986
14987 log_info ("Hashtype: %s", hash_type);
14988 log_info ("");
14989 }
14990
14991 /**
14992 * keep track of the progress
14993 */
14994
14995 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14996 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14997 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14998
14999 /**
15000 * open filehandles
15001 */
15002
15003 #if _WIN
15004 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15005 {
15006 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15007
15008 return (-1);
15009 }
15010
15011 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15012 {
15013 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15014
15015 return (-1);
15016 }
15017
15018 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15019 {
15020 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15021
15022 return (-1);
15023 }
15024 #endif
15025
15026 /**
15027 * dictionary pad
15028 */
15029
15030 segment_size *= (1024 * 1024);
15031
15032 data.segment_size = segment_size;
15033
15034 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15035
15036 wl_data->buf = (char *) mymalloc (segment_size);
15037 wl_data->avail = segment_size;
15038 wl_data->incr = segment_size;
15039 wl_data->cnt = 0;
15040 wl_data->pos = 0;
15041
15042 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15043
15044 data.wordlist_mode = wordlist_mode;
15045
15046 cs_t *css_buf = NULL;
15047 uint css_cnt = 0;
15048 uint dictcnt = 0;
15049 uint maskcnt = 1;
15050 char **masks = NULL;
15051 char **dictfiles = NULL;
15052
15053 uint mask_from_file = 0;
15054
15055 if (attack_mode == ATTACK_MODE_STRAIGHT)
15056 {
15057 if (wordlist_mode == WL_MODE_FILE)
15058 {
15059 int wls_left = myargc - (optind + 1);
15060
15061 for (int i = 0; i < wls_left; i++)
15062 {
15063 char *l0_filename = myargv[optind + 1 + i];
15064
15065 struct stat l0_stat;
15066
15067 if (stat (l0_filename, &l0_stat) == -1)
15068 {
15069 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15070
15071 return (-1);
15072 }
15073
15074 uint is_dir = S_ISDIR (l0_stat.st_mode);
15075
15076 if (is_dir == 0)
15077 {
15078 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15079
15080 dictcnt++;
15081
15082 dictfiles[dictcnt - 1] = l0_filename;
15083 }
15084 else
15085 {
15086 // do not allow --keyspace w/ a directory
15087
15088 if (keyspace == 1)
15089 {
15090 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15091
15092 return (-1);
15093 }
15094
15095 char **dictionary_files = NULL;
15096
15097 dictionary_files = scan_directory (l0_filename);
15098
15099 if (dictionary_files != NULL)
15100 {
15101 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15102
15103 for (int d = 0; dictionary_files[d] != NULL; d++)
15104 {
15105 char *l1_filename = dictionary_files[d];
15106
15107 struct stat l1_stat;
15108
15109 if (stat (l1_filename, &l1_stat) == -1)
15110 {
15111 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15112
15113 return (-1);
15114 }
15115
15116 if (S_ISREG (l1_stat.st_mode))
15117 {
15118 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15119
15120 dictcnt++;
15121
15122 dictfiles[dictcnt - 1] = strdup (l1_filename);
15123 }
15124 }
15125 }
15126
15127 local_free (dictionary_files);
15128 }
15129 }
15130
15131 if (dictcnt < 1)
15132 {
15133 log_error ("ERROR: No usable dictionary file found.");
15134
15135 return (-1);
15136 }
15137 }
15138 else if (wordlist_mode == WL_MODE_STDIN)
15139 {
15140 dictcnt = 1;
15141 }
15142 }
15143 else if (attack_mode == ATTACK_MODE_COMBI)
15144 {
15145 // display
15146
15147 char *dictfile1 = myargv[optind + 1 + 0];
15148 char *dictfile2 = myargv[optind + 1 + 1];
15149
15150 // find the bigger dictionary and use as base
15151
15152 FILE *fp1 = NULL;
15153 FILE *fp2 = NULL;
15154
15155 struct stat tmp_stat;
15156
15157 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15158 {
15159 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15160
15161 return (-1);
15162 }
15163
15164 if (stat (dictfile1, &tmp_stat) == -1)
15165 {
15166 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15167
15168 fclose (fp1);
15169
15170 return (-1);
15171 }
15172
15173 if (S_ISDIR (tmp_stat.st_mode))
15174 {
15175 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15176
15177 fclose (fp1);
15178
15179 return (-1);
15180 }
15181
15182 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15183 {
15184 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15185
15186 fclose (fp1);
15187
15188 return (-1);
15189 }
15190
15191 if (stat (dictfile2, &tmp_stat) == -1)
15192 {
15193 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15194
15195 fclose (fp1);
15196 fclose (fp2);
15197
15198 return (-1);
15199 }
15200
15201 if (S_ISDIR (tmp_stat.st_mode))
15202 {
15203 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15204
15205 fclose (fp1);
15206 fclose (fp2);
15207
15208 return (-1);
15209 }
15210
15211 data.combs_cnt = 1;
15212
15213 data.quiet = 1;
15214
15215 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15216
15217 data.quiet = quiet;
15218
15219 if (words1_cnt == 0)
15220 {
15221 log_error ("ERROR: %s: empty file", dictfile1);
15222
15223 fclose (fp1);
15224 fclose (fp2);
15225
15226 return (-1);
15227 }
15228
15229 data.combs_cnt = 1;
15230
15231 data.quiet = 1;
15232
15233 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15234
15235 data.quiet = quiet;
15236
15237 if (words2_cnt == 0)
15238 {
15239 log_error ("ERROR: %s: empty file", dictfile2);
15240
15241 fclose (fp1);
15242 fclose (fp2);
15243
15244 return (-1);
15245 }
15246
15247 fclose (fp1);
15248 fclose (fp2);
15249
15250 data.dictfile = dictfile1;
15251 data.dictfile2 = dictfile2;
15252
15253 if (words1_cnt >= words2_cnt)
15254 {
15255 data.combs_cnt = words2_cnt;
15256 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15257
15258 dictfiles = &data.dictfile;
15259
15260 dictcnt = 1;
15261 }
15262 else
15263 {
15264 data.combs_cnt = words1_cnt;
15265 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15266
15267 dictfiles = &data.dictfile2;
15268
15269 dictcnt = 1;
15270
15271 // we also have to switch wordlist related rules!
15272
15273 char *tmpc = data.rule_buf_l;
15274
15275 data.rule_buf_l = data.rule_buf_r;
15276 data.rule_buf_r = tmpc;
15277
15278 int tmpi = data.rule_len_l;
15279
15280 data.rule_len_l = data.rule_len_r;
15281 data.rule_len_r = tmpi;
15282 }
15283 }
15284 else if (attack_mode == ATTACK_MODE_BF)
15285 {
15286 char *mask = NULL;
15287
15288 maskcnt = 0;
15289
15290 if (benchmark == 0)
15291 {
15292 mask = myargv[optind + 1];
15293
15294 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15295
15296 if ((optind + 2) <= myargc)
15297 {
15298 struct stat file_stat;
15299
15300 if (stat (mask, &file_stat) == -1)
15301 {
15302 maskcnt = 1;
15303
15304 masks[maskcnt - 1] = mystrdup (mask);
15305 }
15306 else
15307 {
15308 int wls_left = myargc - (optind + 1);
15309
15310 uint masks_avail = INCR_MASKS;
15311
15312 for (int i = 0; i < wls_left; i++)
15313 {
15314 if (i != 0)
15315 {
15316 mask = myargv[optind + 1 + i];
15317
15318 if (stat (mask, &file_stat) == -1)
15319 {
15320 log_error ("ERROR: %s: %s", mask, strerror (errno));
15321
15322 return (-1);
15323 }
15324 }
15325
15326 uint is_file = S_ISREG (file_stat.st_mode);
15327
15328 if (is_file == 1)
15329 {
15330 FILE *mask_fp;
15331
15332 if ((mask_fp = fopen (mask, "r")) == NULL)
15333 {
15334 log_error ("ERROR: %s: %s", mask, strerror (errno));
15335
15336 return (-1);
15337 }
15338
15339 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15340
15341 while (!feof (mask_fp))
15342 {
15343 memset (line_buf, 0, HCBUFSIZ);
15344
15345 int line_len = fgetl (mask_fp, line_buf);
15346
15347 if (line_len == 0) continue;
15348
15349 if (line_buf[0] == '#') continue;
15350
15351 if (masks_avail == maskcnt)
15352 {
15353 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15354
15355 masks_avail += INCR_MASKS;
15356 }
15357
15358 masks[maskcnt] = mystrdup (line_buf);
15359
15360 maskcnt++;
15361 }
15362
15363 myfree (line_buf);
15364
15365 fclose (mask_fp);
15366 }
15367 else
15368 {
15369 log_error ("ERROR: %s: unsupported file-type", mask);
15370
15371 return (-1);
15372 }
15373 }
15374
15375 mask_from_file = 1;
15376 }
15377 }
15378 else
15379 {
15380 custom_charset_1 = (char *) "?l?d?u";
15381 custom_charset_2 = (char *) "?l?d";
15382 custom_charset_3 = (char *) "?l?d*!$@_";
15383
15384 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15385 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15386 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15387
15388 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15389
15390 wordlist_mode = WL_MODE_MASK;
15391
15392 data.wordlist_mode = wordlist_mode;
15393
15394 increment = 1;
15395
15396 maskcnt = 1;
15397 }
15398 }
15399 else
15400 {
15401 /**
15402 * generate full masks and charsets
15403 */
15404
15405 masks = (char **) mymalloc (sizeof (char *));
15406
15407 switch (hash_mode)
15408 {
15409 case 1731: pw_min = 5;
15410 pw_max = 5;
15411 mask = mystrdup ("?b?b?b?b?b");
15412 break;
15413 case 12500: pw_min = 5;
15414 pw_max = 5;
15415 mask = mystrdup ("?b?b?b?b?b");
15416 break;
15417 default: pw_min = 7;
15418 pw_max = 7;
15419 mask = mystrdup ("?b?b?b?b?b?b?b");
15420 break;
15421 }
15422
15423 maskcnt = 1;
15424
15425 masks[maskcnt - 1] = mystrdup (mask);
15426
15427 wordlist_mode = WL_MODE_MASK;
15428
15429 data.wordlist_mode = wordlist_mode;
15430
15431 increment = 1;
15432 }
15433
15434 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15435
15436 if (increment)
15437 {
15438 if (increment_min > pw_min) pw_min = increment_min;
15439
15440 if (increment_max < pw_max) pw_max = increment_max;
15441 }
15442 }
15443 else if (attack_mode == ATTACK_MODE_HYBRID1)
15444 {
15445 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15446
15447 // display
15448
15449 char *mask = myargv[myargc - 1];
15450
15451 maskcnt = 0;
15452
15453 masks = (char **) mymalloc (1 * sizeof (char *));
15454
15455 // mod
15456
15457 struct stat file_stat;
15458
15459 if (stat (mask, &file_stat) == -1)
15460 {
15461 maskcnt = 1;
15462
15463 masks[maskcnt - 1] = mystrdup (mask);
15464 }
15465 else
15466 {
15467 uint is_file = S_ISREG (file_stat.st_mode);
15468
15469 if (is_file == 1)
15470 {
15471 FILE *mask_fp;
15472
15473 if ((mask_fp = fopen (mask, "r")) == NULL)
15474 {
15475 log_error ("ERROR: %s: %s", mask, strerror (errno));
15476
15477 return (-1);
15478 }
15479
15480 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15481
15482 uint masks_avail = 1;
15483
15484 while (!feof (mask_fp))
15485 {
15486 memset (line_buf, 0, HCBUFSIZ);
15487
15488 int line_len = fgetl (mask_fp, line_buf);
15489
15490 if (line_len == 0) continue;
15491
15492 if (line_buf[0] == '#') continue;
15493
15494 if (masks_avail == maskcnt)
15495 {
15496 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15497
15498 masks_avail += INCR_MASKS;
15499 }
15500
15501 masks[maskcnt] = mystrdup (line_buf);
15502
15503 maskcnt++;
15504 }
15505
15506 myfree (line_buf);
15507
15508 fclose (mask_fp);
15509
15510 mask_from_file = 1;
15511 }
15512 else
15513 {
15514 maskcnt = 1;
15515
15516 masks[maskcnt - 1] = mystrdup (mask);
15517 }
15518 }
15519
15520 // base
15521
15522 int wls_left = myargc - (optind + 2);
15523
15524 for (int i = 0; i < wls_left; i++)
15525 {
15526 char *filename = myargv[optind + 1 + i];
15527
15528 struct stat file_stat;
15529
15530 if (stat (filename, &file_stat) == -1)
15531 {
15532 log_error ("ERROR: %s: %s", filename, strerror (errno));
15533
15534 return (-1);
15535 }
15536
15537 uint is_dir = S_ISDIR (file_stat.st_mode);
15538
15539 if (is_dir == 0)
15540 {
15541 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15542
15543 dictcnt++;
15544
15545 dictfiles[dictcnt - 1] = filename;
15546 }
15547 else
15548 {
15549 // do not allow --keyspace w/ a directory
15550
15551 if (keyspace == 1)
15552 {
15553 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15554
15555 return (-1);
15556 }
15557
15558 char **dictionary_files = NULL;
15559
15560 dictionary_files = scan_directory (filename);
15561
15562 if (dictionary_files != NULL)
15563 {
15564 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15565
15566 for (int d = 0; dictionary_files[d] != NULL; d++)
15567 {
15568 char *l1_filename = dictionary_files[d];
15569
15570 struct stat l1_stat;
15571
15572 if (stat (l1_filename, &l1_stat) == -1)
15573 {
15574 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15575
15576 return (-1);
15577 }
15578
15579 if (S_ISREG (l1_stat.st_mode))
15580 {
15581 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15582
15583 dictcnt++;
15584
15585 dictfiles[dictcnt - 1] = strdup (l1_filename);
15586 }
15587 }
15588 }
15589
15590 local_free (dictionary_files);
15591 }
15592 }
15593
15594 if (dictcnt < 1)
15595 {
15596 log_error ("ERROR: No usable dictionary file found.");
15597
15598 return (-1);
15599 }
15600
15601 if (increment)
15602 {
15603 maskcnt = 0;
15604
15605 uint mask_min = increment_min; // we can't reject smaller masks here
15606 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15607
15608 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15609 {
15610 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15611
15612 if (cur_mask == NULL) break;
15613
15614 masks[maskcnt] = cur_mask;
15615
15616 maskcnt++;
15617
15618 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15619 }
15620 }
15621 }
15622 else if (attack_mode == ATTACK_MODE_HYBRID2)
15623 {
15624 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15625
15626 // display
15627
15628 char *mask = myargv[optind + 1 + 0];
15629
15630 maskcnt = 0;
15631
15632 masks = (char **) mymalloc (1 * sizeof (char *));
15633
15634 // mod
15635
15636 struct stat file_stat;
15637
15638 if (stat (mask, &file_stat) == -1)
15639 {
15640 maskcnt = 1;
15641
15642 masks[maskcnt - 1] = mystrdup (mask);
15643 }
15644 else
15645 {
15646 uint is_file = S_ISREG (file_stat.st_mode);
15647
15648 if (is_file == 1)
15649 {
15650 FILE *mask_fp;
15651
15652 if ((mask_fp = fopen (mask, "r")) == NULL)
15653 {
15654 log_error ("ERROR: %s: %s", mask, strerror (errno));
15655
15656 return (-1);
15657 }
15658
15659 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15660
15661 uint masks_avail = 1;
15662
15663 while (!feof (mask_fp))
15664 {
15665 memset (line_buf, 0, HCBUFSIZ);
15666
15667 int line_len = fgetl (mask_fp, line_buf);
15668
15669 if (line_len == 0) continue;
15670
15671 if (line_buf[0] == '#') continue;
15672
15673 if (masks_avail == maskcnt)
15674 {
15675 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15676
15677 masks_avail += INCR_MASKS;
15678 }
15679
15680 masks[maskcnt] = mystrdup (line_buf);
15681
15682 maskcnt++;
15683 }
15684
15685 myfree (line_buf);
15686
15687 fclose (mask_fp);
15688
15689 mask_from_file = 1;
15690 }
15691 else
15692 {
15693 maskcnt = 1;
15694
15695 masks[maskcnt - 1] = mystrdup (mask);
15696 }
15697 }
15698
15699 // base
15700
15701 int wls_left = myargc - (optind + 2);
15702
15703 for (int i = 0; i < wls_left; i++)
15704 {
15705 char *filename = myargv[optind + 2 + i];
15706
15707 struct stat file_stat;
15708
15709 if (stat (filename, &file_stat) == -1)
15710 {
15711 log_error ("ERROR: %s: %s", filename, strerror (errno));
15712
15713 return (-1);
15714 }
15715
15716 uint is_dir = S_ISDIR (file_stat.st_mode);
15717
15718 if (is_dir == 0)
15719 {
15720 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15721
15722 dictcnt++;
15723
15724 dictfiles[dictcnt - 1] = filename;
15725 }
15726 else
15727 {
15728 // do not allow --keyspace w/ a directory
15729
15730 if (keyspace == 1)
15731 {
15732 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15733
15734 return (-1);
15735 }
15736
15737 char **dictionary_files = NULL;
15738
15739 dictionary_files = scan_directory (filename);
15740
15741 if (dictionary_files != NULL)
15742 {
15743 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15744
15745 for (int d = 0; dictionary_files[d] != NULL; d++)
15746 {
15747 char *l1_filename = dictionary_files[d];
15748
15749 struct stat l1_stat;
15750
15751 if (stat (l1_filename, &l1_stat) == -1)
15752 {
15753 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15754
15755 return (-1);
15756 }
15757
15758 if (S_ISREG (l1_stat.st_mode))
15759 {
15760 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15761
15762 dictcnt++;
15763
15764 dictfiles[dictcnt - 1] = strdup (l1_filename);
15765 }
15766 }
15767 }
15768
15769 local_free (dictionary_files);
15770 }
15771 }
15772
15773 if (dictcnt < 1)
15774 {
15775 log_error ("ERROR: No usable dictionary file found.");
15776
15777 return (-1);
15778 }
15779
15780 if (increment)
15781 {
15782 maskcnt = 0;
15783
15784 uint mask_min = increment_min; // we can't reject smaller masks here
15785 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15786
15787 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15788 {
15789 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15790
15791 if (cur_mask == NULL) break;
15792
15793 masks[maskcnt] = cur_mask;
15794
15795 maskcnt++;
15796
15797 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15798 }
15799 }
15800 }
15801
15802 data.pw_min = pw_min;
15803 data.pw_max = pw_max;
15804
15805 /**
15806 * weak hash check
15807 */
15808
15809 if (weak_hash_threshold >= salts_cnt)
15810 {
15811 hc_device_param_t *device_param = NULL;
15812
15813 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15814 {
15815 device_param = &data.devices_param[device_id];
15816
15817 if (device_param->skipped) continue;
15818
15819 break;
15820 }
15821
15822 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15823
15824 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15825 {
15826 weak_hash_check (device_param, salt_pos);
15827 }
15828
15829 // Display hack, guarantee that there is at least one \r before real start
15830
15831 //if (data.quiet == 0) log_info ("");
15832 }
15833
15834 /**
15835 * status and monitor threads
15836 */
15837
15838 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15839
15840 hc_thread_t i_thread = 0;
15841
15842 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15843 {
15844 hc_thread_create (i_thread, thread_keypress, &benchmark);
15845 }
15846
15847 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15848
15849 uint ni_threads_cnt = 0;
15850
15851 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15852
15853 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15854
15855 ni_threads_cnt++;
15856
15857 /**
15858 * Outfile remove
15859 */
15860
15861 if (keyspace == 0)
15862 {
15863 if (outfile_check_timer != 0)
15864 {
15865 if (data.outfile_check_directory != NULL)
15866 {
15867 if ((hash_mode != 5200) &&
15868 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15869 (hash_mode != 9000))
15870 {
15871 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15872
15873 ni_threads_cnt++;
15874 }
15875 else
15876 {
15877 outfile_check_timer = 0;
15878 }
15879 }
15880 else
15881 {
15882 outfile_check_timer = 0;
15883 }
15884 }
15885 }
15886
15887 /**
15888 * Inform the user if we got some hashes remove because of the pot file remove feature
15889 */
15890
15891 if (data.quiet == 0)
15892 {
15893 if (potfile_remove_cracks > 0)
15894 {
15895 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15896 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15897 }
15898 }
15899
15900 data.outfile_check_timer = outfile_check_timer;
15901
15902 /**
15903 * main loop
15904 */
15905
15906 char **induction_dictionaries = NULL;
15907
15908 int induction_dictionaries_cnt = 0;
15909
15910 hcstat_table_t *root_table_buf = NULL;
15911 hcstat_table_t *markov_table_buf = NULL;
15912
15913 uint initial_restore_done = 0;
15914
15915 data.maskcnt = maskcnt;
15916
15917 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15918 {
15919 if (data.devices_status == STATUS_CRACKED) break;
15920
15921 data.devices_status = STATUS_INIT;
15922
15923 if (maskpos > rd->maskpos)
15924 {
15925 rd->dictpos = 0;
15926 }
15927
15928 rd->maskpos = maskpos;
15929 data.maskpos = maskpos;
15930
15931 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15932 {
15933 char *mask = masks[maskpos];
15934
15935 if (mask_from_file == 1)
15936 {
15937 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15938
15939 char *str_ptr;
15940 uint str_pos;
15941
15942 uint mask_offset = 0;
15943
15944 uint separator_cnt;
15945
15946 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15947 {
15948 str_ptr = strstr (mask + mask_offset, ",");
15949
15950 if (str_ptr == NULL) break;
15951
15952 str_pos = str_ptr - mask;
15953
15954 // escaped separator, i.e. "\,"
15955
15956 if (str_pos > 0)
15957 {
15958 if (mask[str_pos - 1] == '\\')
15959 {
15960 separator_cnt --;
15961
15962 mask_offset = str_pos + 1;
15963
15964 continue;
15965 }
15966 }
15967
15968 // reset the offset
15969
15970 mask_offset = 0;
15971
15972 mask[str_pos] = '\0';
15973
15974 switch (separator_cnt)
15975 {
15976 case 0:
15977 mp_reset_usr (mp_usr, 0);
15978
15979 custom_charset_1 = mask;
15980 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15981 break;
15982
15983 case 1:
15984 mp_reset_usr (mp_usr, 1);
15985
15986 custom_charset_2 = mask;
15987 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15988 break;
15989
15990 case 2:
15991 mp_reset_usr (mp_usr, 2);
15992
15993 custom_charset_3 = mask;
15994 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15995 break;
15996
15997 case 3:
15998 mp_reset_usr (mp_usr, 3);
15999
16000 custom_charset_4 = mask;
16001 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16002 break;
16003 }
16004
16005 mask = mask + str_pos + 1;
16006 }
16007 }
16008
16009 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16010 {
16011 if (maskpos > 0)
16012 {
16013 local_free (css_buf);
16014 local_free (data.root_css_buf);
16015 local_free (data.markov_css_buf);
16016
16017 local_free (masks[maskpos - 1]);
16018 }
16019
16020 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16021
16022 data.mask = mask;
16023 data.css_cnt = css_cnt;
16024 data.css_buf = css_buf;
16025
16026 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16027
16028 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16029
16030 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16031 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16032
16033 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16034
16035 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16036
16037 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16038 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16039
16040 data.root_css_buf = root_css_buf;
16041 data.markov_css_buf = markov_css_buf;
16042
16043 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16044
16045 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16046
16047 local_free (root_table_buf);
16048 local_free (markov_table_buf);
16049
16050 // args
16051
16052 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16053 {
16054 hc_device_param_t *device_param = &data.devices_param[device_id];
16055
16056 if (device_param->skipped) continue;
16057
16058 device_param->kernel_params_mp[0] = &device_param->d_combs;
16059 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16060 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16061
16062 device_param->kernel_params_mp_buf64[3] = 0;
16063 device_param->kernel_params_mp_buf32[4] = css_cnt;
16064 device_param->kernel_params_mp_buf32[5] = 0;
16065 device_param->kernel_params_mp_buf32[6] = 0;
16066 device_param->kernel_params_mp_buf32[7] = 0;
16067
16068 if (attack_mode == ATTACK_MODE_HYBRID1)
16069 {
16070 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16071 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16072 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16073 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16074 }
16075 else if (attack_mode == ATTACK_MODE_HYBRID2)
16076 {
16077 device_param->kernel_params_mp_buf32[5] = 0;
16078 device_param->kernel_params_mp_buf32[6] = 0;
16079 device_param->kernel_params_mp_buf32[7] = 0;
16080 }
16081
16082 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]);
16083 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]);
16084 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]);
16085
16086 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);
16087 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);
16088 }
16089 }
16090 else if (attack_mode == ATTACK_MODE_BF)
16091 {
16092 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16093
16094 if (increment)
16095 {
16096 for (uint i = 0; i < dictcnt; i++)
16097 {
16098 local_free (dictfiles[i]);
16099 }
16100
16101 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16102 {
16103 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16104
16105 if (l1_filename == NULL) break;
16106
16107 dictcnt++;
16108
16109 dictfiles[dictcnt - 1] = l1_filename;
16110 }
16111 }
16112 else
16113 {
16114 dictcnt++;
16115
16116 dictfiles[dictcnt - 1] = mask;
16117 }
16118
16119 if (dictcnt == 0)
16120 {
16121 log_error ("ERROR: Mask is too small");
16122
16123 return (-1);
16124 }
16125 }
16126 }
16127
16128 free (induction_dictionaries);
16129
16130 // induction_dictionaries_cnt = 0; // implied
16131
16132 if (attack_mode != ATTACK_MODE_BF)
16133 {
16134 if (keyspace == 0)
16135 {
16136 induction_dictionaries = scan_directory (induction_directory);
16137
16138 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16139 }
16140 }
16141
16142 if (induction_dictionaries_cnt)
16143 {
16144 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16145 }
16146
16147 /**
16148 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16149 */
16150 if (keyspace == 1)
16151 {
16152 if ((maskcnt > 1) || (dictcnt > 1))
16153 {
16154 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16155
16156 return (-1);
16157 }
16158 }
16159
16160 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16161 {
16162 char *subid = logfile_generate_subid ();
16163
16164 data.subid = subid;
16165
16166 logfile_sub_msg ("START");
16167
16168 data.devices_status = STATUS_INIT;
16169
16170 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16171 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16172 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16173
16174 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16175
16176 data.cpt_pos = 0;
16177
16178 data.cpt_start = time (NULL);
16179
16180 data.cpt_total = 0;
16181
16182 if (data.restore == 0)
16183 {
16184 rd->words_cur = skip;
16185
16186 skip = 0;
16187
16188 data.skip = 0;
16189 }
16190
16191 data.ms_paused = 0;
16192
16193 data.words_cur = rd->words_cur;
16194
16195 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16196 {
16197 hc_device_param_t *device_param = &data.devices_param[device_id];
16198
16199 if (device_param->skipped) continue;
16200
16201 device_param->speed_pos = 0;
16202
16203 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16204 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16205
16206 device_param->exec_pos = 0;
16207
16208 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16209
16210 device_param->kernel_power = device_param->kernel_power_user;
16211
16212 device_param->outerloop_pos = 0;
16213 device_param->outerloop_left = 0;
16214 device_param->innerloop_pos = 0;
16215 device_param->innerloop_left = 0;
16216
16217 // some more resets:
16218
16219 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16220
16221 device_param->pws_cnt = 0;
16222
16223 device_param->words_off = 0;
16224 device_param->words_done = 0;
16225 }
16226
16227 data.kernel_power_div = 0;
16228
16229 // figure out some workload
16230
16231 if (attack_mode == ATTACK_MODE_STRAIGHT)
16232 {
16233 if (data.wordlist_mode == WL_MODE_FILE)
16234 {
16235 char *dictfile = NULL;
16236
16237 if (induction_dictionaries_cnt)
16238 {
16239 dictfile = induction_dictionaries[0];
16240 }
16241 else
16242 {
16243 dictfile = dictfiles[dictpos];
16244 }
16245
16246 data.dictfile = dictfile;
16247
16248 logfile_sub_string (dictfile);
16249
16250 for (uint i = 0; i < rp_files_cnt; i++)
16251 {
16252 logfile_sub_var_string ("rulefile", rp_files[i]);
16253 }
16254
16255 FILE *fd2 = fopen (dictfile, "rb");
16256
16257 if (fd2 == NULL)
16258 {
16259 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16260
16261 return (-1);
16262 }
16263
16264 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16265
16266 fclose (fd2);
16267
16268 if (data.words_cnt == 0)
16269 {
16270 if (data.devices_status == STATUS_CRACKED) break;
16271 if (data.devices_status == STATUS_ABORTED) break;
16272
16273 dictpos++;
16274
16275 continue;
16276 }
16277 }
16278 }
16279 else if (attack_mode == ATTACK_MODE_COMBI)
16280 {
16281 char *dictfile = data.dictfile;
16282 char *dictfile2 = data.dictfile2;
16283
16284 logfile_sub_string (dictfile);
16285 logfile_sub_string (dictfile2);
16286
16287 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16288 {
16289 FILE *fd2 = fopen (dictfile, "rb");
16290
16291 if (fd2 == NULL)
16292 {
16293 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16294
16295 return (-1);
16296 }
16297
16298 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16299
16300 fclose (fd2);
16301 }
16302 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16303 {
16304 FILE *fd2 = fopen (dictfile2, "rb");
16305
16306 if (fd2 == NULL)
16307 {
16308 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16309
16310 return (-1);
16311 }
16312
16313 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16314
16315 fclose (fd2);
16316 }
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 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16329 {
16330 char *dictfile = NULL;
16331
16332 if (induction_dictionaries_cnt)
16333 {
16334 dictfile = induction_dictionaries[0];
16335 }
16336 else
16337 {
16338 dictfile = dictfiles[dictpos];
16339 }
16340
16341 data.dictfile = dictfile;
16342
16343 char *mask = data.mask;
16344
16345 logfile_sub_string (dictfile);
16346 logfile_sub_string (mask);
16347
16348 FILE *fd2 = fopen (dictfile, "rb");
16349
16350 if (fd2 == NULL)
16351 {
16352 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16353
16354 return (-1);
16355 }
16356
16357 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16358
16359 fclose (fd2);
16360
16361 if (data.words_cnt == 0)
16362 {
16363 if (data.devices_status == STATUS_CRACKED) break;
16364 if (data.devices_status == STATUS_ABORTED) break;
16365
16366 dictpos++;
16367
16368 continue;
16369 }
16370 }
16371 else if (attack_mode == ATTACK_MODE_BF)
16372 {
16373 local_free (css_buf);
16374 local_free (data.root_css_buf);
16375 local_free (data.markov_css_buf);
16376
16377 char *mask = dictfiles[dictpos];
16378
16379 logfile_sub_string (mask);
16380
16381 // base
16382
16383 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16384
16385 if (opts_type & OPTS_TYPE_PT_UNICODE)
16386 {
16387 uint css_cnt_unicode = css_cnt * 2;
16388
16389 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16390
16391 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16392 {
16393 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16394
16395 css_buf_unicode[j + 1].cs_buf[0] = 0;
16396 css_buf_unicode[j + 1].cs_len = 1;
16397 }
16398
16399 free (css_buf);
16400
16401 css_buf = css_buf_unicode;
16402 css_cnt = css_cnt_unicode;
16403 }
16404
16405 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16406
16407 uint mask_min = pw_min;
16408 uint mask_max = pw_max;
16409
16410 if (opts_type & OPTS_TYPE_PT_UNICODE)
16411 {
16412 mask_min *= 2;
16413 mask_max *= 2;
16414 }
16415
16416 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16417 {
16418 if (css_cnt < mask_min)
16419 {
16420 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16421 }
16422
16423 if (css_cnt > mask_max)
16424 {
16425 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16426 }
16427
16428 // skip to next mask
16429
16430 dictpos++;
16431
16432 rd->dictpos = dictpos;
16433
16434 logfile_sub_msg ("STOP");
16435
16436 continue;
16437 }
16438
16439 uint save_css_cnt = css_cnt;
16440
16441 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16442 {
16443 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16444 {
16445 uint salt_len = (uint) data.salts_buf[0].salt_len;
16446 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16447
16448 uint css_cnt_salt = css_cnt + salt_len;
16449
16450 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16451
16452 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16453
16454 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16455 {
16456 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16457 css_buf_salt[j].cs_len = 1;
16458 }
16459
16460 free (css_buf);
16461
16462 css_buf = css_buf_salt;
16463 css_cnt = css_cnt_salt;
16464 }
16465 }
16466
16467 data.mask = mask;
16468 data.css_cnt = css_cnt;
16469 data.css_buf = css_buf;
16470
16471 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16472
16473 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16474
16475 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16476
16477 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16478 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16479
16480 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16481
16482 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16483
16484 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16485 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16486
16487 data.root_css_buf = root_css_buf;
16488 data.markov_css_buf = markov_css_buf;
16489
16490 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16491
16492 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16493
16494 local_free (root_table_buf);
16495 local_free (markov_table_buf);
16496
16497 // copy + args
16498
16499 uint css_cnt_l = css_cnt;
16500 uint css_cnt_r;
16501
16502 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16503 {
16504 if (save_css_cnt < 6)
16505 {
16506 css_cnt_r = 1;
16507 }
16508 else if (save_css_cnt == 6)
16509 {
16510 css_cnt_r = 2;
16511 }
16512 else
16513 {
16514 if (opts_type & OPTS_TYPE_PT_UNICODE)
16515 {
16516 if (save_css_cnt == 8 || save_css_cnt == 10)
16517 {
16518 css_cnt_r = 2;
16519 }
16520 else
16521 {
16522 css_cnt_r = 4;
16523 }
16524 }
16525 else
16526 {
16527 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16528 {
16529 css_cnt_r = 3;
16530 }
16531 else
16532 {
16533 css_cnt_r = 4;
16534 }
16535 }
16536 }
16537 }
16538 else
16539 {
16540 css_cnt_r = 1;
16541
16542 /* unfinished code?
16543 int sum = css_buf[css_cnt_r - 1].cs_len;
16544
16545 for (uint i = 1; i < 4 && i < css_cnt; i++)
16546 {
16547 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16548
16549 css_cnt_r++;
16550
16551 sum *= css_buf[css_cnt_r - 1].cs_len;
16552 }
16553 */
16554 }
16555
16556 css_cnt_l -= css_cnt_r;
16557
16558 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16559
16560 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16561 {
16562 hc_device_param_t *device_param = &data.devices_param[device_id];
16563
16564 if (device_param->skipped) continue;
16565
16566 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16567 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16568 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16569
16570 device_param->kernel_params_mp_l_buf64[3] = 0;
16571 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16572 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16573 device_param->kernel_params_mp_l_buf32[6] = 0;
16574 device_param->kernel_params_mp_l_buf32[7] = 0;
16575 device_param->kernel_params_mp_l_buf32[8] = 0;
16576
16577 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16578 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16579 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16580 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16581
16582 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16583 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16584 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16585
16586 device_param->kernel_params_mp_r_buf64[3] = 0;
16587 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16588 device_param->kernel_params_mp_r_buf32[5] = 0;
16589 device_param->kernel_params_mp_r_buf32[6] = 0;
16590 device_param->kernel_params_mp_r_buf32[7] = 0;
16591
16592 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]);
16593 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]);
16594 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]);
16595
16596 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]);
16597 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]);
16598 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]);
16599
16600 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);
16601 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);
16602 }
16603 }
16604
16605 u64 words_base = data.words_cnt;
16606
16607 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16608 {
16609 if (data.kernel_rules_cnt)
16610 {
16611 words_base /= data.kernel_rules_cnt;
16612 }
16613 }
16614 else if (data.attack_kern == ATTACK_KERN_COMBI)
16615 {
16616 if (data.combs_cnt)
16617 {
16618 words_base /= data.combs_cnt;
16619 }
16620 }
16621 else if (data.attack_kern == ATTACK_KERN_BF)
16622 {
16623 if (data.bfs_cnt)
16624 {
16625 words_base /= data.bfs_cnt;
16626 }
16627 }
16628
16629 data.words_base = words_base;
16630
16631 if (keyspace == 1)
16632 {
16633 log_info ("%llu", (unsigned long long int) words_base);
16634
16635 return (0);
16636 }
16637
16638 if (data.words_cur > data.words_base)
16639 {
16640 log_error ("ERROR: restore value greater keyspace");
16641
16642 return (-1);
16643 }
16644
16645 if (data.words_cur)
16646 {
16647 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16648 {
16649 for (uint i = 0; i < data.salts_cnt; i++)
16650 {
16651 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16652 }
16653 }
16654 else if (data.attack_kern == ATTACK_KERN_COMBI)
16655 {
16656 for (uint i = 0; i < data.salts_cnt; i++)
16657 {
16658 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16659 }
16660 }
16661 else if (data.attack_kern == ATTACK_KERN_BF)
16662 {
16663 for (uint i = 0; i < data.salts_cnt; i++)
16664 {
16665 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16666 }
16667 }
16668 }
16669
16670 /*
16671 * Inform user about possible slow speeds
16672 */
16673
16674 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16675 {
16676 if (data.words_base < kernel_power_all)
16677 {
16678 if (quiet == 0)
16679 {
16680 log_info ("ATTENTION!");
16681 log_info (" The wordlist or mask you are using is too small.");
16682 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
16683 log_info (" The cracking speed will drop.");
16684 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16685 log_info ("");
16686 }
16687 }
16688 }
16689
16690 /*
16691 * Update loopback file
16692 */
16693
16694 if (loopback == 1)
16695 {
16696 time_t now;
16697
16698 time (&now);
16699
16700 uint random_num = get_random_num (0, 9999);
16701
16702 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16703
16704 data.loopback_file = loopback_file;
16705 }
16706
16707 /*
16708 * Update dictionary statistic
16709 */
16710
16711 if (keyspace == 0)
16712 {
16713 dictstat_fp = fopen (dictstat, "wb");
16714
16715 if (dictstat_fp)
16716 {
16717 lock_file (dictstat_fp);
16718
16719 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16720
16721 fclose (dictstat_fp);
16722 }
16723 }
16724
16725 data.devices_status = STATUS_RUNNING;
16726
16727 if (initial_restore_done == 0)
16728 {
16729 if (data.restore_disable == 0) cycle_restore ();
16730
16731 initial_restore_done = 1;
16732 }
16733
16734 hc_timer_set (&data.timer_running);
16735
16736 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16737 {
16738 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16739 {
16740 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16741 if (quiet == 0) fflush (stdout);
16742 }
16743 }
16744 else if (wordlist_mode == WL_MODE_STDIN)
16745 {
16746 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16747 if (data.quiet == 0) log_info ("");
16748 }
16749
16750 time_t runtime_start;
16751
16752 time (&runtime_start);
16753
16754 data.runtime_start = runtime_start;
16755
16756 /**
16757 * create cracker threads
16758 */
16759
16760 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16761
16762 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16763 {
16764 hc_device_param_t *device_param = &devices_param[device_id];
16765
16766 if (wordlist_mode == WL_MODE_STDIN)
16767 {
16768 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16769 }
16770 else
16771 {
16772 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16773 }
16774 }
16775
16776 // wait for crack threads to exit
16777
16778 hc_thread_wait (data.devices_cnt, c_threads);
16779
16780 local_free (c_threads);
16781
16782 data.restore = 0;
16783
16784 // finalize task
16785
16786 logfile_sub_var_uint ("status-after-work", data.devices_status);
16787
16788 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16789
16790 if (data.devices_status == STATUS_CRACKED) break;
16791 if (data.devices_status == STATUS_ABORTED) break;
16792
16793 if (data.devices_status == STATUS_BYPASS)
16794 {
16795 data.devices_status = STATUS_RUNNING;
16796 }
16797
16798 if (induction_dictionaries_cnt)
16799 {
16800 unlink (induction_dictionaries[0]);
16801 }
16802
16803 free (induction_dictionaries);
16804
16805 if (attack_mode != ATTACK_MODE_BF)
16806 {
16807 induction_dictionaries = scan_directory (induction_directory);
16808
16809 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16810 }
16811
16812 if (benchmark == 0)
16813 {
16814 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16815 {
16816 if (quiet == 0) clear_prompt ();
16817
16818 if (quiet == 0) log_info ("");
16819
16820 if (status == 1)
16821 {
16822 status_display ();
16823 }
16824 else
16825 {
16826 if (quiet == 0) status_display ();
16827 }
16828
16829 if (quiet == 0) log_info ("");
16830 }
16831 }
16832
16833 if (attack_mode == ATTACK_MODE_BF)
16834 {
16835 dictpos++;
16836
16837 rd->dictpos = dictpos;
16838 }
16839 else
16840 {
16841 if (induction_dictionaries_cnt)
16842 {
16843 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16844 }
16845 else
16846 {
16847 dictpos++;
16848
16849 rd->dictpos = dictpos;
16850 }
16851 }
16852
16853 time_t runtime_stop;
16854
16855 time (&runtime_stop);
16856
16857 data.runtime_stop = runtime_stop;
16858
16859 logfile_sub_uint (runtime_start);
16860 logfile_sub_uint (runtime_stop);
16861
16862 logfile_sub_msg ("STOP");
16863
16864 global_free (subid);
16865 }
16866
16867 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16868
16869 if (data.devices_status == STATUS_CRACKED) break;
16870 if (data.devices_status == STATUS_ABORTED) break;
16871 if (data.devices_status == STATUS_QUIT) break;
16872
16873 if (data.devices_status == STATUS_BYPASS)
16874 {
16875 data.devices_status = STATUS_RUNNING;
16876 }
16877 }
16878
16879 // 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
16880
16881 if (attack_mode == ATTACK_MODE_STRAIGHT)
16882 {
16883 if (data.wordlist_mode == WL_MODE_FILE)
16884 {
16885 if (data.dictfile == NULL)
16886 {
16887 if (dictfiles != NULL)
16888 {
16889 data.dictfile = dictfiles[0];
16890
16891 hc_timer_set (&data.timer_running);
16892 }
16893 }
16894 }
16895 }
16896 // NOTE: combi is okay because it is already set beforehand
16897 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16898 {
16899 if (data.dictfile == NULL)
16900 {
16901 if (dictfiles != NULL)
16902 {
16903 hc_timer_set (&data.timer_running);
16904
16905 data.dictfile = dictfiles[0];
16906 }
16907 }
16908 }
16909 else if (attack_mode == ATTACK_MODE_BF)
16910 {
16911 if (data.mask == NULL)
16912 {
16913 hc_timer_set (&data.timer_running);
16914
16915 data.mask = masks[0];
16916 }
16917 }
16918
16919 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16920 {
16921 data.devices_status = STATUS_EXHAUSTED;
16922 }
16923
16924 // if cracked / aborted remove last induction dictionary
16925
16926 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16927 {
16928 struct stat induct_stat;
16929
16930 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16931 {
16932 unlink (induction_dictionaries[file_pos]);
16933 }
16934 }
16935
16936 // wait for non-interactive threads
16937
16938 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16939 {
16940 hc_thread_wait (1, &ni_threads[thread_idx]);
16941 }
16942
16943 local_free (ni_threads);
16944
16945 // wait for interactive threads
16946
16947 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16948 {
16949 hc_thread_wait (1, &i_thread);
16950 }
16951
16952 // we dont need restore file anymore
16953 if (data.restore_disable == 0)
16954 {
16955 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16956 {
16957 unlink (eff_restore_file);
16958 unlink (new_restore_file);
16959 }
16960 else
16961 {
16962 cycle_restore ();
16963 }
16964 }
16965
16966 // finally save left hashes
16967
16968 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16969 {
16970 save_hash ();
16971 }
16972
16973 /**
16974 * Clean up
16975 */
16976
16977 if (benchmark == 1)
16978 {
16979 status_benchmark ();
16980
16981 log_info ("");
16982 }
16983 else
16984 {
16985 if (quiet == 0) clear_prompt ();
16986
16987 if (quiet == 0) log_info ("");
16988
16989 if (status == 1)
16990 {
16991 status_display ();
16992 }
16993 else
16994 {
16995 if (quiet == 0) status_display ();
16996 }
16997
16998 if (quiet == 0) log_info ("");
16999 }
17000
17001 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17002 {
17003 hc_device_param_t *device_param = &data.devices_param[device_id];
17004
17005 if (device_param->skipped) continue;
17006
17007 local_free (device_param->result);
17008
17009 local_free (device_param->combs_buf);
17010
17011 local_free (device_param->hooks_buf);
17012
17013 local_free (device_param->device_name);
17014
17015 local_free (device_param->device_name_chksum);
17016
17017 local_free (device_param->device_version);
17018
17019 local_free (device_param->driver_version);
17020
17021 if (device_param->pws_buf) myfree (device_param->pws_buf);
17022 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17023 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17024 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17025 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17026 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17027 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17028 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17029 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17030 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17031 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17032 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17033 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17034 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17035 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17036 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17037 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17038 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17039 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17040 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17041 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17042 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17043 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17044 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17045 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17046 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17047 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17048 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17049 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17050
17051 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17052 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17053 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17054 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17055 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17056 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17057 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17058 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17059 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17060 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17061
17062 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17063 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17064 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17065
17066 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17067 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17068 }
17069
17070 // reset default fan speed
17071
17072 #ifdef HAVE_HWMON
17073 if (gpu_temp_disable == 0)
17074 {
17075 #ifdef HAVE_ADL
17076 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17077 {
17078 hc_thread_mutex_lock (mux_adl);
17079
17080 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17081 {
17082 hc_device_param_t *device_param = &data.devices_param[device_id];
17083
17084 if (device_param->skipped) continue;
17085
17086 if (data.hm_device[device_id].fan_supported == 1)
17087 {
17088 int fanspeed = temp_retain_fanspeed_value[device_id];
17089
17090 if (fanspeed == -1) continue;
17091
17092 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
17093
17094 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
17095 }
17096 }
17097
17098 hc_thread_mutex_unlock (mux_adl);
17099 }
17100 #endif // HAVE_ADL
17101 }
17102
17103 #ifdef HAVE_ADL
17104 // reset power tuning
17105
17106 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17107 {
17108 hc_thread_mutex_lock (mux_adl);
17109
17110 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17111 {
17112 hc_device_param_t *device_param = &data.devices_param[device_id];
17113
17114 if (device_param->skipped) continue;
17115
17116 if (data.hm_device[device_id].od_version == 6)
17117 {
17118 // check powertune capabilities first, if not available then skip device
17119
17120 int powertune_supported = 0;
17121
17122 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17123 {
17124 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17125
17126 return (-1);
17127 }
17128
17129 if (powertune_supported != 0)
17130 {
17131 // powercontrol settings
17132
17133 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)
17134 {
17135 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17136
17137 return (-1);
17138 }
17139
17140 // clocks
17141
17142 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17143
17144 performance_state->iNumberOfPerformanceLevels = 2;
17145
17146 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17147 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17148 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17149 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17150
17151 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)
17152 {
17153 log_info ("ERROR: Failed to restore ADL performance state");
17154
17155 return (-1);
17156 }
17157
17158 local_free (performance_state);
17159 }
17160 }
17161 }
17162
17163 hc_thread_mutex_unlock (mux_adl);
17164 }
17165 #endif // HAVE_ADL
17166
17167 if (gpu_temp_disable == 0)
17168 {
17169 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17170 if (data.hm_nv)
17171 {
17172 #if defined(LINUX) && defined(HAVE_NVML)
17173
17174 hm_NVML_nvmlShutdown (data.hm_nv);
17175
17176 nvml_close (data.hm_nv);
17177
17178 #elif defined(WIN) && (HAVE_NVAPI)
17179
17180 hm_NvAPI_Unload (data.hm_nv);
17181
17182 nvapi_close (data.hm_nv);
17183
17184 #endif
17185
17186 data.hm_nv = NULL;
17187 }
17188 #endif
17189
17190 #ifdef HAVE_ADL
17191 if (data.hm_amd)
17192 {
17193 hm_ADL_Main_Control_Destroy (data.hm_amd);
17194
17195 adl_close (data.hm_amd);
17196 data.hm_amd = NULL;
17197 }
17198 #endif
17199 }
17200 #endif // HAVE_HWMON
17201
17202 // free memory
17203
17204 local_free (masks);
17205
17206 local_free (dictstat_base);
17207
17208 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17209 {
17210 pot_t *pot_ptr = &pot[pot_pos];
17211
17212 hash_t *hash = &pot_ptr->hash;
17213
17214 local_free (hash->digest);
17215
17216 if (isSalted)
17217 {
17218 local_free (hash->salt);
17219 }
17220 }
17221
17222 local_free (pot);
17223
17224 local_free (all_kernel_rules_cnt);
17225 local_free (all_kernel_rules_buf);
17226
17227 local_free (wl_data->buf);
17228 local_free (wl_data);
17229
17230 local_free (bitmap_s1_a);
17231 local_free (bitmap_s1_b);
17232 local_free (bitmap_s1_c);
17233 local_free (bitmap_s1_d);
17234 local_free (bitmap_s2_a);
17235 local_free (bitmap_s2_b);
17236 local_free (bitmap_s2_c);
17237 local_free (bitmap_s2_d);
17238
17239 #ifdef HAVE_HWMON
17240 local_free (temp_retain_fanspeed_value);
17241 #ifdef HAVE_ADL
17242 local_free (od_clock_mem_status);
17243 local_free (od_power_control_status);
17244 #endif // ADL
17245 #endif
17246
17247 global_free (devices_param);
17248
17249 global_free (kernel_rules_buf);
17250
17251 global_free (root_css_buf);
17252 global_free (markov_css_buf);
17253
17254 global_free (digests_buf);
17255 global_free (digests_shown);
17256 global_free (digests_shown_tmp);
17257
17258 global_free (salts_buf);
17259 global_free (salts_shown);
17260
17261 global_free (esalts_buf);
17262
17263 global_free (words_progress_done);
17264 global_free (words_progress_rejected);
17265 global_free (words_progress_restored);
17266
17267 if (pot_fp) fclose (pot_fp);
17268
17269 if (data.devices_status == STATUS_QUIT) break;
17270 }
17271
17272 // destroy others mutex
17273
17274 hc_thread_mutex_delete (mux_dispatcher);
17275 hc_thread_mutex_delete (mux_counter);
17276 hc_thread_mutex_delete (mux_display);
17277 hc_thread_mutex_delete (mux_adl);
17278
17279 // free memory
17280
17281 local_free (eff_restore_file);
17282 local_free (new_restore_file);
17283
17284 local_free (rd);
17285
17286 // tuning db
17287
17288 tuning_db_destroy (tuning_db);
17289
17290 // loopback
17291
17292 local_free (loopback_file);
17293
17294 if (loopback == 1) unlink (loopback_file);
17295
17296 // induction directory
17297
17298 if (induction_dir == NULL)
17299 {
17300 if (attack_mode != ATTACK_MODE_BF)
17301 {
17302 if (rmdir (induction_directory) == -1)
17303 {
17304 if (errno == ENOENT)
17305 {
17306 // good, we can ignore
17307 }
17308 else if (errno == ENOTEMPTY)
17309 {
17310 // good, we can ignore
17311 }
17312 else
17313 {
17314 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17315
17316 return (-1);
17317 }
17318 }
17319
17320 local_free (induction_directory);
17321 }
17322 }
17323
17324 // outfile-check directory
17325
17326 if (outfile_check_dir == NULL)
17327 {
17328 if (rmdir (outfile_check_directory) == -1)
17329 {
17330 if (errno == ENOENT)
17331 {
17332 // good, we can ignore
17333 }
17334 else if (errno == ENOTEMPTY)
17335 {
17336 // good, we can ignore
17337 }
17338 else
17339 {
17340 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17341
17342 return (-1);
17343 }
17344 }
17345
17346 local_free (outfile_check_directory);
17347 }
17348
17349 time_t proc_stop;
17350
17351 time (&proc_stop);
17352
17353 logfile_top_uint (proc_start);
17354 logfile_top_uint (proc_stop);
17355
17356 logfile_top_msg ("STOP");
17357
17358 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17359 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17360
17361 if (data.ocl) ocl_close (data.ocl);
17362
17363 if (data.devices_status == STATUS_ABORTED) return 2;
17364 if (data.devices_status == STATUS_QUIT) return 2;
17365 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17366 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17367 if (data.devices_status == STATUS_CRACKED) return 0;
17368
17369 return -1;
17370 }
Hashcat additions to support pwdhash