projects / hashcat.git / blob
? search:


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