projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Added SIMD code for DCC2
[hashcat.git] / src / hashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "hashcat";
19 const uint VERSION_BIN = 300;
20 const uint RESTORE_MIN = 300;
21
22 double TARGET_MS_PROFILE[3] = { 8, 16, 96 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define RESTORE 0
37 #define RESTORE_TIMER 60
38 #define RESTORE_DISABLE 0
39 #define STATUS 0
40 #define STATUS_TIMER 10
41 #define STATUS_AUTOMAT 0
42 #define LOOPBACK 0
43 #define WEAK_HASH_THRESHOLD 100
44 #define SHOW 0
45 #define LEFT 0
46 #define USERNAME 0
47 #define REMOVE 0
48 #define REMOVE_TIMER 60
49 #define SKIP 0
50 #define LIMIT 0
51 #define KEYSPACE 0
52 #define POTFILE_DISABLE 0
53 #define DEBUG_MODE 0
54 #define RP_GEN 0
55 #define RP_GEN_FUNC_MIN 1
56 #define RP_GEN_FUNC_MAX 4
57 #define RP_GEN_SEED 0
58 #define RULE_BUF_L ":"
59 #define RULE_BUF_R ":"
60 #define FORCE 0
61 #define RUNTIME 0
62 #define HEX_CHARSET 0
63 #define HEX_SALT 0
64 #define HEX_WORDLIST 0
65 #define OUTFILE_FORMAT 3
66 #define OUTFILE_AUTOHEX 1
67 #define OUTFILE_CHECK_TIMER 5
68 #define ATTACK_MODE 0
69 #define HASH_MODE 0
70 #define SEGMENT_SIZE 32
71 #define INCREMENT 0
72 #define INCREMENT_MIN 1
73 #define INCREMENT_MAX PW_MAX
74 #define SEPARATOR ':'
75 #define BITMAP_MIN 16
76 #define BITMAP_MAX 24
77 #define GPU_TEMP_DISABLE 0
78 #define GPU_TEMP_ABORT 90
79 #define GPU_TEMP_RETAIN 80
80 #define WORKLOAD_PROFILE 2
81 #define KERNEL_ACCEL 0
82 #define KERNEL_LOOPS 0
83 #define KERNEL_RULES 1024
84 #define KERNEL_COMBS 1024
85 #define KERNEL_BFS 1024
86 #define KERNEL_THREADS_MAX 256
87 #define KERNEL_THREADS_MAX_CPU 16
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 137
152
153 #define global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
168 {
169 900,
170 0,
171 5100,
172 100,
173 1400,
174 10800,
175 1700,
176 5000,
177 10100,
178 6000,
179 6100,
180 6900,
181 11700,
182 11800,
183 400,
184 8900,
185 11900,
186 12000,
187 10900,
188 12100,
189 23,
190 2500,
191 5300,
192 5400,
193 5500,
194 5600,
195 7300,
196 7500,
197 13100,
198 8300,
199 11100,
200 11200,
201 11400,
202 121,
203 2611,
204 2711,
205 2811,
206 8400,
207 11,
208 2612,
209 7900,
210 21,
211 11000,
212 124,
213 10000,
214 3711,
215 7600,
216 12,
217 131,
218 132,
219 1731,
220 200,
221 300,
222 3100,
223 112,
224 12300,
225 8000,
226 141,
227 1441,
228 1600,
229 12600,
230 1421,
231 101,
232 111,
233 1711,
234 3000,
235 1000,
236 1100,
237 2100,
238 12800,
239 1500,
240 12400,
241 500,
242 3200,
243 7400,
244 1800,
245 122,
246 1722,
247 7100,
248 6300,
249 6700,
250 6400,
251 6500,
252 2400,
253 2410,
254 5700,
255 9200,
256 9300,
257 22,
258 501,
259 5800,
260 8100,
261 8500,
262 7200,
263 9900,
264 7700,
265 7800,
266 10300,
267 8600,
268 8700,
269 9100,
270 133,
271 13500,
272 11600,
273 13600,
274 12500,
275 13000,
276 13200,
277 13300,
278 6211,
279 6221,
280 6231,
281 6241,
282 8800,
283 12900,
284 12200,
285 9700,
286 9710,
287 9800,
288 9810,
289 9400,
290 9500,
291 9600,
292 10400,
293 10410,
294 10500,
295 10600,
296 10700,
297 9000,
298 5200,
299 6800,
300 6600,
301 8200,
302 11300,
303 12700,
304 13400,
305 125
306 };
307
308 /**
309 * types
310 */
311
312 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
313
314 /**
315 * globals
316 */
317
318 static unsigned int full01 = 0x01010101;
319 static unsigned int full80 = 0x80808080;
320
321 int SUPPRESS_OUTPUT = 0;
322
323 hc_thread_mutex_t mux_adl;
324 hc_thread_mutex_t mux_counter;
325 hc_thread_mutex_t mux_dispatcher;
326 hc_thread_mutex_t mux_display;
327
328 hc_global_data_t data;
329
330 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
331
332 const char *USAGE_MINI[] =
333 {
334 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
335 "",
336 "Try --help for more help.",
337 NULL
338 };
339
340 const char *USAGE_BIG[] =
341 {
342 "%s, advanced password recovery",
343 "",
344 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
345 "",
346 "=======",
347 "Options",
348 "=======",
349 "",
350 "* General:",
351 "",
352 " -m, --hash-type=NUM Hash-type, see references below",
353 " -a, --attack-mode=NUM Attack-mode, see references below",
354 " -V, --version Print version",
355 " -h, --help Print help",
356 " --quiet Suppress output",
357 "",
358 "* Misc:",
359 "",
360 " --hex-charset Assume charset is given in hex",
361 " --hex-salt Assume salt is given in hex",
362 " --hex-wordlist Assume words in wordlist is given in hex",
363 " --force Ignore warnings",
364 " --status Enable automatic update of the status-screen",
365 " --status-timer=NUM Seconds between status-screen update",
366 " --status-automat Display the status view in a machine readable format",
367 " --loopback Add new plains to induct directory",
368 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
369 "",
370 "* Markov:",
371 "",
372 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
373 " --markov-disable Disables markov-chains, emulates classic brute-force",
374 " --markov-classic Enables classic markov-chains, no per-position enhancement",
375 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
376 "",
377 "* Session:",
378 "",
379 " --runtime=NUM Abort session after NUM seconds of runtime",
380 " --session=STR Define specific session name",
381 " --restore Restore session from --session",
382 " --restore-disable Do not write restore file",
383 "",
384 "* Files:",
385 "",
386 " -o, --outfile=FILE Define outfile for recovered hash",
387 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
388 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
389 " --outfile-check-timer=NUM Seconds between outfile checks",
390 " -p, --separator=CHAR Separator char for hashlists and outfile",
391 " --show Show cracked passwords only",
392 " --left Show un-cracked passwords only",
393 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
394 " --remove Enable remove of hash once it is cracked",
395 " --remove-timer=NUM Update input hash file each NUM seconds",
396 " --potfile-disable Do not write potfile",
397 " --potfile-path Specific path to potfile",
398 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
399 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
400 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
401 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
402 " --logfile-disable Disable the logfile",
403 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
404 "",
405 "* Resources:",
406 "",
407 " -b, --benchmark Run benchmark",
408 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
409 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
410 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
411 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
412 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
413 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
414 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
415 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
416 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
417 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
418 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
419 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
420 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
421 #ifdef HAVE_HWMON
422 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
423 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
424 #ifdef HAVE_ADL
425 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
426 #endif
427 #endif
428 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
429 "",
430 "* Distributed:",
431 "",
432 " -s, --skip=NUM Skip number of words",
433 " -l, --limit=NUM Limit number of words",
434 " --keyspace Show keyspace base:mod values and quit",
435 "",
436 "* Rules:",
437 "",
438 " -j, --rule-left=RULE Single rule applied to each word from left dict",
439 " -k, --rule-right=RULE Single rule applied to each word from right dict",
440 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
441 " -g, --generate-rules=NUM Generate NUM random rules",
442 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
443 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
444 " --generate-rules-seed=NUM Force RNG seed to NUM",
445 "",
446 "* Custom charsets:",
447 "",
448 " -1, --custom-charset1=CS User-defined charsets",
449 " -2, --custom-charset2=CS Example:",
450 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
451 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
452 "",
453 "* Increment:",
454 "",
455 " -i, --increment Enable increment mode",
456 " --increment-min=NUM Start incrementing at NUM",
457 " --increment-max=NUM Stop incrementing at NUM",
458 "",
459 "==========",
460 "References",
461 "==========",
462 "",
463 "* Workload Profile:",
464 "",
465 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
466 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
467 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
468 "",
469 "* OpenCL device-types:",
470 "",
471 " 1 = CPU devices",
472 " 2 = GPU devices",
473 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
474 "",
475 "* Outfile Formats:",
476 "",
477 " 1 = hash[:salt]",
478 " 2 = plain",
479 " 3 = hash[:salt]:plain",
480 " 4 = hex_plain",
481 " 5 = hash[:salt]:hex_plain",
482 " 6 = plain:hex_plain",
483 " 7 = hash[:salt]:plain:hex_plain",
484 " 8 = crackpos",
485 " 9 = hash[:salt]:crackpos",
486 " 10 = plain:crackpos",
487 " 11 = hash[:salt]:plain:crackpos",
488 " 12 = hex_plain:crackpos",
489 " 13 = hash[:salt]:hex_plain:crackpos",
490 " 14 = plain:hex_plain:crackpos",
491 " 15 = hash[:salt]:plain:hex_plain:crackpos",
492 "",
493 "* Debug mode output formats (for hybrid mode only, by using rules):",
494 "",
495 " 1 = save finding rule",
496 " 2 = save original word",
497 " 3 = save original word and finding rule",
498 " 4 = save original word, finding rule and modified plain",
499 "",
500 "* Built-in charsets:",
501 "",
502 " ?l = abcdefghijklmnopqrstuvwxyz",
503 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
504 " ?d = 0123456789",
505 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
506 " ?a = ?l?u?d?s",
507 " ?b = 0x00 - 0xff",
508 "",
509 "* Attack modes:",
510 "",
511 " 0 = Straight",
512 " 1 = Combination",
513 " 3 = Brute-force",
514 " 6 = Hybrid dict + mask",
515 " 7 = Hybrid mask + dict",
516 "",
517 "* Hash types:",
518 "",
519 "[[ Roll-your-own: Raw Hashes ]]",
520 "",
521 " 900 = MD4",
522 " 0 = MD5",
523 " 5100 = Half MD5",
524 " 100 = SHA1",
525 " 10800 = SHA-384",
526 " 1400 = SHA-256",
527 " 1700 = SHA-512",
528 " 5000 = SHA-3(Keccak)",
529 " 10100 = SipHash",
530 " 6000 = RipeMD160",
531 " 6100 = Whirlpool",
532 " 6900 = GOST R 34.11-94",
533 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
534 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
535 "",
536 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
537 "",
538 " 10 = md5($pass.$salt)",
539 " 20 = md5($salt.$pass)",
540 " 30 = md5(unicode($pass).$salt)",
541 " 40 = md5($salt.unicode($pass))",
542 " 3800 = md5($salt.$pass.$salt)",
543 " 3710 = md5($salt.md5($pass))",
544 " 2600 = md5(md5($pass)",
545 " 4300 = md5(strtoupper(md5($pass)))",
546 " 4400 = md5(sha1($pass))",
547 " 110 = sha1($pass.$salt)",
548 " 120 = sha1($salt.$pass)",
549 " 130 = sha1(unicode($pass).$salt)",
550 " 140 = sha1($salt.unicode($pass))",
551 " 4500 = sha1(sha1($pass)",
552 " 4700 = sha1(md5($pass))",
553 " 4900 = sha1($salt.$pass.$salt)",
554 " 1410 = sha256($pass.$salt)",
555 " 1420 = sha256($salt.$pass)",
556 " 1430 = sha256(unicode($pass).$salt)",
557 " 1440 = sha256($salt.unicode($pass))",
558 " 1710 = sha512($pass.$salt)",
559 " 1720 = sha512($salt.$pass)",
560 " 1730 = sha512(unicode($pass).$salt)",
561 " 1740 = sha512($salt.unicode($pass))",
562 "",
563 "[[ Roll-your-own: Authenticated Hashes ]]",
564 "",
565 " 50 = HMAC-MD5 (key = $pass)",
566 " 60 = HMAC-MD5 (key = $salt)",
567 " 150 = HMAC-SHA1 (key = $pass)",
568 " 160 = HMAC-SHA1 (key = $salt)",
569 " 1450 = HMAC-SHA256 (key = $pass)",
570 " 1460 = HMAC-SHA256 (key = $salt)",
571 " 1750 = HMAC-SHA512 (key = $pass)",
572 " 1760 = HMAC-SHA512 (key = $salt)",
573 "",
574 "[[ Generic KDF ]]",
575 "",
576 " 400 = phpass",
577 " 8900 = scrypt",
578 " 11900 = PBKDF2-HMAC-MD5",
579 " 12000 = PBKDF2-HMAC-SHA1",
580 " 10900 = PBKDF2-HMAC-SHA256",
581 " 12100 = PBKDF2-HMAC-SHA512",
582 "",
583 "[[ Network protocols, Challenge-Response ]]",
584 "",
585 " 23 = Skype",
586 " 2500 = WPA/WPA2",
587 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
588 " 5300 = IKE-PSK MD5",
589 " 5400 = IKE-PSK SHA1",
590 " 5500 = NetNTLMv1",
591 " 5500 = NetNTLMv1 + ESS",
592 " 5600 = NetNTLMv2",
593 " 7300 = IPMI2 RAKP HMAC-SHA1",
594 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
595 " 8300 = DNSSEC (NSEC3)",
596 " 10200 = Cram MD5",
597 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
598 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
599 " 11400 = SIP digest authentication (MD5)",
600 " 13100 = Kerberos 5 TGS-REP etype 23",
601 "",
602 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
603 "",
604 " 121 = SMF (Simple Machines Forum)",
605 " 400 = phpBB3",
606 " 2611 = vBulletin < v3.8.5",
607 " 2711 = vBulletin > v3.8.5",
608 " 2811 = MyBB",
609 " 2811 = IPB (Invison Power Board)",
610 " 8400 = WBB3 (Woltlab Burning Board)",
611 " 11 = Joomla < 2.5.18",
612 " 400 = Joomla > 2.5.18",
613 " 400 = Wordpress",
614 " 2612 = PHPS",
615 " 7900 = Drupal7",
616 " 21 = osCommerce",
617 " 21 = xt:Commerce",
618 " 11000 = PrestaShop",
619 " 124 = Django (SHA-1)",
620 " 10000 = Django (PBKDF2-SHA256)",
621 " 3711 = Mediawiki B type",
622 " 7600 = Redmine",
623 "",
624 "[[ Database Server ]]",
625 "",
626 " 12 = PostgreSQL",
627 " 131 = MSSQL(2000)",
628 " 132 = MSSQL(2005)",
629 " 1731 = MSSQL(2012)",
630 " 1731 = MSSQL(2014)",
631 " 200 = MySQL323",
632 " 300 = MySQL4.1/MySQL5",
633 " 3100 = Oracle H: Type (Oracle 7+)",
634 " 112 = Oracle S: Type (Oracle 11+)",
635 " 12300 = Oracle T: Type (Oracle 12+)",
636 " 8000 = Sybase ASE",
637 "",
638 "[[ HTTP, SMTP, LDAP Server ]]",
639 "",
640 " 141 = EPiServer 6.x < v4",
641 " 1441 = EPiServer 6.x > v4",
642 " 1600 = Apache $apr1$",
643 " 12600 = ColdFusion 10+",
644 " 1421 = hMailServer",
645 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
646 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
647 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
648 "",
649 "[[ Checksums ]]",
650 "",
651 " 11500 = CRC32",
652 "",
653 "[[ Operating-Systems ]]",
654 "",
655 " 3000 = LM",
656 " 1000 = NTLM",
657 " 1100 = Domain Cached Credentials (DCC), MS Cache",
658 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
659 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
660 " 1500 = descrypt, DES(Unix), Traditional DES",
661 " 12400 = BSDiCrypt, Extended DES",
662 " 500 = md5crypt $1$, MD5(Unix)",
663 " 3200 = bcrypt $2*$, Blowfish(Unix)",
664 " 7400 = sha256crypt $5$, SHA256(Unix)",
665 " 1800 = sha512crypt $6$, SHA512(Unix)",
666 " 122 = OSX v10.4",
667 " 122 = OSX v10.5",
668 " 122 = OSX v10.6",
669 " 1722 = OSX v10.7",
670 " 7100 = OSX v10.8",
671 " 7100 = OSX v10.9",
672 " 7100 = OSX v10.10",
673 " 6300 = AIX {smd5}",
674 " 6700 = AIX {ssha1}",
675 " 6400 = AIX {ssha256}",
676 " 6500 = AIX {ssha512}",
677 " 2400 = Cisco-PIX",
678 " 2410 = Cisco-ASA",
679 " 500 = Cisco-IOS $1$",
680 " 5700 = Cisco-IOS $4$",
681 " 9200 = Cisco-IOS $8$",
682 " 9300 = Cisco-IOS $9$",
683 " 22 = Juniper Netscreen/SSG (ScreenOS)",
684 " 501 = Juniper IVE",
685 " 5800 = Android PIN",
686 " 8100 = Citrix Netscaler",
687 " 8500 = RACF",
688 " 7200 = GRUB 2",
689 " 9900 = Radmin2",
690 " 125 = ArubaOS",
691 "",
692 "[[ Enterprise Application Software (EAS) ]]",
693 "",
694 " 7700 = SAP CODVN B (BCODE)",
695 " 7800 = SAP CODVN F/G (PASSCODE)",
696 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
697 " 8600 = Lotus Notes/Domino 5",
698 " 8700 = Lotus Notes/Domino 6",
699 " 9100 = Lotus Notes/Domino 8",
700 " 133 = PeopleSoft",
701 " 13500 = PeopleSoft Token",
702 "",
703 "[[ Archives ]]",
704 "",
705 " 11600 = 7-Zip",
706 " 12500 = RAR3-hp",
707 " 13000 = RAR5",
708 " 13200 = AxCrypt",
709 " 13300 = AxCrypt in memory SHA1",
710 " 13600 = WinZip",
711 "",
712 "[[ Full-Disk encryptions (FDE) ]]",
713 "",
714 " 62XY = TrueCrypt 5.0+",
715 " X = 1 = PBKDF2-HMAC-RipeMD160",
716 " X = 2 = PBKDF2-HMAC-SHA512",
717 " X = 3 = PBKDF2-HMAC-Whirlpool",
718 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
719 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
720 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
721 " Y = 3 = XTS 1536 bit (Ciphers: All)",
722 " 8800 = Android FDE < v4.3",
723 " 12900 = Android FDE (Samsung DEK)",
724 " 12200 = eCryptfs",
725 "",
726 "[[ Documents ]]",
727 "",
728 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
729 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
730 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
731 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
732 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
733 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
734 " 9400 = MS Office 2007",
735 " 9500 = MS Office 2010",
736 " 9600 = MS Office 2013",
737 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
738 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
739 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
740 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
741 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
742 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
743 "",
744 "[[ Password Managers ]]",
745 "",
746 " 9000 = Password Safe v2",
747 " 5200 = Password Safe v3",
748 " 6800 = Lastpass",
749 " 6600 = 1Password, agilekeychain",
750 " 8200 = 1Password, cloudkeychain",
751 " 11300 = Bitcoin/Litecoin wallet.dat",
752 " 12700 = Blockchain, My Wallet",
753 " 13400 = Keepass 1 (AES/Twofish) and Keepass 2 (AES)",
754 "",
755 NULL
756 };
757
758 /**
759 * hashcat specific functions
760 */
761
762 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
763 {
764 int exec_pos = (int) device_param->exec_pos - last_num_entries;
765
766 if (exec_pos < 0) exec_pos += EXEC_CACHE;
767
768 double exec_ms_sum = 0;
769
770 int exec_ms_cnt = 0;
771
772 for (int i = 0; i < last_num_entries; i++)
773 {
774 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
775
776 if (exec_ms)
777 {
778 exec_ms_sum += exec_ms;
779
780 exec_ms_cnt++;
781 }
782 }
783
784 if (exec_ms_cnt == 0) return 0;
785
786 return exec_ms_sum / exec_ms_cnt;
787 }
788
789 void status_display_automat ()
790 {
791 FILE *out = stdout;
792
793 fprintf (out, "STATUS\t%u\t", data.devices_status);
794
795 /**
796 * speed new
797 */
798
799 fprintf (out, "SPEED\t");
800
801 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
802 {
803 hc_device_param_t *device_param = &data.devices_param[device_id];
804
805 if (device_param->skipped) continue;
806
807 u64 speed_cnt = 0;
808 double speed_ms = 0;
809
810 for (int i = 0; i < SPEED_CACHE; i++)
811 {
812 speed_cnt += device_param->speed_cnt[i];
813 speed_ms += device_param->speed_ms[i];
814 }
815
816 speed_cnt /= SPEED_CACHE;
817 speed_ms /= SPEED_CACHE;
818
819 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
820 }
821
822 /**
823 * exec time
824 */
825
826 fprintf (out, "EXEC_RUNTIME\t");
827
828 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
829 {
830 hc_device_param_t *device_param = &data.devices_param[device_id];
831
832 if (device_param->skipped) continue;
833
834 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
835
836 fprintf (out, "%f\t", exec_ms_avg);
837 }
838
839 /**
840 * words_cur
841 */
842
843 u64 words_cur = get_lowest_words_done ();
844
845 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
846
847 /**
848 * counter
849 */
850
851 u64 progress_total = data.words_cnt * data.salts_cnt;
852
853 u64 all_done = 0;
854 u64 all_rejected = 0;
855 u64 all_restored = 0;
856
857 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
858 {
859 all_done += data.words_progress_done[salt_pos];
860 all_rejected += data.words_progress_rejected[salt_pos];
861 all_restored += data.words_progress_restored[salt_pos];
862 }
863
864 u64 progress_cur = all_restored + all_done + all_rejected;
865 u64 progress_end = progress_total;
866
867 u64 progress_skip = 0;
868
869 if (data.skip)
870 {
871 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
872
873 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
874 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
875 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
876 }
877
878 if (data.limit)
879 {
880 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
881
882 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
883 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
884 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
885 }
886
887 u64 progress_cur_relative_skip = progress_cur - progress_skip;
888 u64 progress_end_relative_skip = progress_end - progress_skip;
889
890 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
891
892 /**
893 * cracks
894 */
895
896 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
897 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
898
899 /**
900 * temperature
901 */
902
903 #ifdef HAVE_HWMON
904 if (data.gpu_temp_disable == 0)
905 {
906 fprintf (out, "TEMP\t");
907
908 hc_thread_mutex_lock (mux_adl);
909
910 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
911 {
912 hc_device_param_t *device_param = &data.devices_param[device_id];
913
914 if (device_param->skipped) continue;
915
916 int temp = hm_get_temperature_with_device_id (device_id);
917
918 fprintf (out, "%d\t", temp);
919 }
920
921 hc_thread_mutex_unlock (mux_adl);
922 }
923 #endif // HAVE_HWMON
924
925 /**
926 * flush
927 */
928
929 #ifdef _WIN
930 fputc ('\r', out);
931 fputc ('\n', out);
932 #endif
933
934 #ifdef _POSIX
935 fputc ('\n', out);
936 #endif
937
938 fflush (out);
939 }
940
941 void status_display ()
942 {
943 if (data.devices_status == STATUS_INIT) return;
944 if (data.devices_status == STATUS_STARTING) return;
945 if (data.devices_status == STATUS_BYPASS) return;
946
947 if (data.status_automat == 1)
948 {
949 status_display_automat ();
950
951 return;
952 }
953
954 char tmp_buf[1000] = { 0 };
955
956 uint tmp_len = 0;
957
958 log_info ("Session.Name...: %s", data.session);
959
960 char *status_type = strstatus (data.devices_status);
961
962 uint hash_mode = data.hash_mode;
963
964 char *hash_type = strhashtype (hash_mode); // not a bug
965
966 log_info ("Status.........: %s", status_type);
967
968 /**
969 * show rules
970 */
971
972 if (data.rp_files_cnt)
973 {
974 uint i;
975
976 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
977 {
978 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
979 }
980
981 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
982
983 log_info ("Rules.Type.....: %s", tmp_buf);
984
985 tmp_len = 0;
986 }
987
988 if (data.rp_gen)
989 {
990 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
991
992 if (data.rp_gen_seed)
993 {
994 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
995 }
996 }
997
998 /**
999 * show input
1000 */
1001
1002 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1003 {
1004 if (data.wordlist_mode == WL_MODE_FILE)
1005 {
1006 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1007 }
1008 else if (data.wordlist_mode == WL_MODE_STDIN)
1009 {
1010 log_info ("Input.Mode.....: Pipe");
1011 }
1012 }
1013 else if (data.attack_mode == ATTACK_MODE_COMBI)
1014 {
1015 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1016 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1017 }
1018 else if (data.attack_mode == ATTACK_MODE_BF)
1019 {
1020 char *mask = data.mask;
1021
1022 if (mask != NULL)
1023 {
1024 uint mask_len = data.css_cnt;
1025
1026 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1027
1028 if (mask_len > 0)
1029 {
1030 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1031 {
1032 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1033 {
1034 mask_len -= data.salts_buf[0].salt_len;
1035 }
1036 }
1037
1038 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1039
1040 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1041 }
1042
1043 if (data.maskcnt > 1)
1044 {
1045 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1046
1047 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1048 }
1049
1050 log_info ("Input.Mode.....: %s", tmp_buf);
1051 }
1052
1053 tmp_len = 0;
1054 }
1055 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1056 {
1057 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1058 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1059 }
1060 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1061 {
1062 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1063 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1064 }
1065
1066 if (data.digests_cnt == 1)
1067 {
1068 if (data.hash_mode == 2500)
1069 {
1070 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1071
1072 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1073 (char *) data.salts_buf[0].salt_buf,
1074 wpa->orig_mac1[0],
1075 wpa->orig_mac1[1],
1076 wpa->orig_mac1[2],
1077 wpa->orig_mac1[3],
1078 wpa->orig_mac1[4],
1079 wpa->orig_mac1[5],
1080 wpa->orig_mac2[0],
1081 wpa->orig_mac2[1],
1082 wpa->orig_mac2[2],
1083 wpa->orig_mac2[3],
1084 wpa->orig_mac2[4],
1085 wpa->orig_mac2[5]);
1086 }
1087 else if (data.hash_mode == 5200)
1088 {
1089 log_info ("Hash.Target....: File (%s)", data.hashfile);
1090 }
1091 else if (data.hash_mode == 9000)
1092 {
1093 log_info ("Hash.Target....: File (%s)", data.hashfile);
1094 }
1095 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1096 {
1097 log_info ("Hash.Target....: File (%s)", data.hashfile);
1098 }
1099 else
1100 {
1101 char out_buf[HCBUFSIZ] = { 0 };
1102
1103 ascii_digest (out_buf, 0, 0);
1104
1105 // limit length
1106 if (strlen (out_buf) > 40)
1107 {
1108 out_buf[41] = '.';
1109 out_buf[42] = '.';
1110 out_buf[43] = '.';
1111 out_buf[44] = 0;
1112 }
1113
1114 log_info ("Hash.Target....: %s", out_buf);
1115 }
1116 }
1117 else
1118 {
1119 if (data.hash_mode == 3000)
1120 {
1121 char out_buf1[32] = { 0 };
1122 char out_buf2[32] = { 0 };
1123
1124 ascii_digest (out_buf1, 0, 0);
1125 ascii_digest (out_buf2, 0, 1);
1126
1127 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1128 }
1129 else
1130 {
1131 log_info ("Hash.Target....: File (%s)", data.hashfile);
1132 }
1133 }
1134
1135 log_info ("Hash.Type......: %s", hash_type);
1136
1137 /**
1138 * speed new
1139 */
1140
1141 u64 speed_cnt[DEVICES_MAX] = { 0 };
1142 double speed_ms[DEVICES_MAX] = { 0 };
1143
1144 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1145 {
1146 hc_device_param_t *device_param = &data.devices_param[device_id];
1147
1148 if (device_param->skipped) continue;
1149
1150 speed_cnt[device_id] = 0;
1151 speed_ms[device_id] = 0;
1152
1153 for (int i = 0; i < SPEED_CACHE; i++)
1154 {
1155 speed_cnt[device_id] += device_param->speed_cnt[i];
1156 speed_ms[device_id] += device_param->speed_ms[i];
1157 }
1158
1159 speed_cnt[device_id] /= SPEED_CACHE;
1160 speed_ms[device_id] /= SPEED_CACHE;
1161 }
1162
1163 float hashes_all_ms = 0;
1164
1165 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1166
1167 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1168 {
1169 hc_device_param_t *device_param = &data.devices_param[device_id];
1170
1171 if (device_param->skipped) continue;
1172
1173 hashes_dev_ms[device_id] = 0;
1174
1175 if (speed_ms[device_id])
1176 {
1177 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1178
1179 hashes_all_ms += hashes_dev_ms[device_id];
1180 }
1181 }
1182
1183 /**
1184 * exec time
1185 */
1186
1187 double exec_all_ms[DEVICES_MAX] = { 0 };
1188
1189 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1190 {
1191 hc_device_param_t *device_param = &data.devices_param[device_id];
1192
1193 if (device_param->skipped) continue;
1194
1195 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1196
1197 exec_all_ms[device_id] = exec_ms_avg;
1198 }
1199
1200 /**
1201 * timers
1202 */
1203
1204 double ms_running = 0;
1205
1206 hc_timer_get (data.timer_running, ms_running);
1207
1208 double ms_paused = data.ms_paused;
1209
1210 if (data.devices_status == STATUS_PAUSED)
1211 {
1212 double ms_paused_tmp = 0;
1213
1214 hc_timer_get (data.timer_paused, ms_paused_tmp);
1215
1216 ms_paused += ms_paused_tmp;
1217 }
1218
1219 #ifdef WIN
1220
1221 __time64_t sec_run = ms_running / 1000;
1222
1223 #else
1224
1225 time_t sec_run = ms_running / 1000;
1226
1227 #endif
1228
1229 if (sec_run)
1230 {
1231 char display_run[32] = { 0 };
1232
1233 struct tm tm_run;
1234
1235 struct tm *tmp = NULL;
1236
1237 #ifdef WIN
1238
1239 tmp = _gmtime64 (&sec_run);
1240
1241 #else
1242
1243 tmp = gmtime (&sec_run);
1244
1245 #endif
1246
1247 if (tmp != NULL)
1248 {
1249 memset (&tm_run, 0, sizeof (tm_run));
1250
1251 memcpy (&tm_run, tmp, sizeof (tm_run));
1252
1253 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1254
1255 char *start = ctime (&data.proc_start);
1256
1257 size_t start_len = strlen (start);
1258
1259 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1260 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1261
1262 log_info ("Time.Started...: %s (%s)", start, display_run);
1263 }
1264 }
1265 else
1266 {
1267 log_info ("Time.Started...: 0 secs");
1268 }
1269
1270 /**
1271 * counters
1272 */
1273
1274 u64 progress_total = data.words_cnt * data.salts_cnt;
1275
1276 u64 all_done = 0;
1277 u64 all_rejected = 0;
1278 u64 all_restored = 0;
1279
1280 u64 progress_noneed = 0;
1281
1282 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1283 {
1284 all_done += data.words_progress_done[salt_pos];
1285 all_rejected += data.words_progress_rejected[salt_pos];
1286 all_restored += data.words_progress_restored[salt_pos];
1287
1288 // Important for ETA only
1289
1290 if (data.salts_shown[salt_pos] == 1)
1291 {
1292 const u64 all = data.words_progress_done[salt_pos]
1293 + data.words_progress_rejected[salt_pos]
1294 + data.words_progress_restored[salt_pos];
1295
1296 const u64 left = data.words_cnt - all;
1297
1298 progress_noneed += left;
1299 }
1300 }
1301
1302 u64 progress_cur = all_restored + all_done + all_rejected;
1303 u64 progress_end = progress_total;
1304
1305 u64 progress_skip = 0;
1306
1307 if (data.skip)
1308 {
1309 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1310
1311 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1312 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1313 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1314 }
1315
1316 if (data.limit)
1317 {
1318 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1319
1320 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1321 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1322 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1323 }
1324
1325 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1326 u64 progress_end_relative_skip = progress_end - progress_skip;
1327
1328 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1329 {
1330 if (data.devices_status != STATUS_CRACKED)
1331 {
1332 #ifdef WIN
1333 __time64_t sec_etc = 0;
1334 #else
1335 time_t sec_etc = 0;
1336 #endif
1337
1338 if (hashes_all_ms)
1339 {
1340 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1341
1342 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1343
1344 sec_etc = ms_left / 1000;
1345 }
1346
1347 if (sec_etc == 0)
1348 {
1349 //log_info ("Time.Estimated.: 0 secs");
1350 }
1351 else if ((u64) sec_etc > ETC_MAX)
1352 {
1353 log_info ("Time.Estimated.: > 10 Years");
1354 }
1355 else
1356 {
1357 char display_etc[32] = { 0 };
1358
1359 struct tm tm_etc;
1360
1361 struct tm *tmp = NULL;
1362
1363 #ifdef WIN
1364
1365 tmp = _gmtime64 (&sec_etc);
1366
1367 #else
1368
1369 tmp = gmtime (&sec_etc);
1370
1371 #endif
1372
1373 if (tmp != NULL)
1374 {
1375 memset (&tm_etc, 0, sizeof (tm_etc));
1376
1377 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1378
1379 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1380
1381 time_t now;
1382
1383 time (&now);
1384
1385 now += sec_etc;
1386
1387 char *etc = ctime (&now);
1388
1389 size_t etc_len = strlen (etc);
1390
1391 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1392 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1393
1394 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1395 }
1396 }
1397 }
1398 }
1399
1400 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1401 {
1402 hc_device_param_t *device_param = &data.devices_param[device_id];
1403
1404 if (device_param->skipped) continue;
1405
1406 char display_dev_cur[16] = { 0 };
1407
1408 strncpy (display_dev_cur, "0.00", 4);
1409
1410 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1411
1412 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1413 }
1414
1415 char display_all_cur[16] = { 0 };
1416
1417 strncpy (display_all_cur, "0.00", 4);
1418
1419 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1420
1421 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1422
1423 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1424 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1425
1426 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1427
1428 // crack-per-time
1429
1430 if (data.digests_cnt > 100)
1431 {
1432 time_t now = time (NULL);
1433
1434 int cpt_cur_min = 0;
1435 int cpt_cur_hour = 0;
1436 int cpt_cur_day = 0;
1437
1438 for (int i = 0; i < CPT_BUF; i++)
1439 {
1440 const uint cracked = data.cpt_buf[i].cracked;
1441 const time_t timestamp = data.cpt_buf[i].timestamp;
1442
1443 if ((timestamp + 60) > now)
1444 {
1445 cpt_cur_min += cracked;
1446 }
1447
1448 if ((timestamp + 3600) > now)
1449 {
1450 cpt_cur_hour += cracked;
1451 }
1452
1453 if ((timestamp + 86400) > now)
1454 {
1455 cpt_cur_day += cracked;
1456 }
1457 }
1458
1459 double ms_real = ms_running - ms_paused;
1460
1461 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1462 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1463 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1464
1465 if ((data.cpt_start + 86400) < now)
1466 {
1467 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1468 cpt_cur_min,
1469 cpt_cur_hour,
1470 cpt_cur_day,
1471 cpt_avg_min,
1472 cpt_avg_hour,
1473 cpt_avg_day);
1474 }
1475 else if ((data.cpt_start + 3600) < now)
1476 {
1477 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1478 cpt_cur_min,
1479 cpt_cur_hour,
1480 cpt_avg_min,
1481 cpt_avg_hour,
1482 cpt_avg_day);
1483 }
1484 else if ((data.cpt_start + 60) < now)
1485 {
1486 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1487 cpt_cur_min,
1488 cpt_avg_min,
1489 cpt_avg_hour,
1490 cpt_avg_day);
1491 }
1492 else
1493 {
1494 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1495 cpt_avg_min,
1496 cpt_avg_hour,
1497 cpt_avg_day);
1498 }
1499 }
1500
1501 // Restore point
1502
1503 u64 restore_point = get_lowest_words_done ();
1504
1505 u64 restore_total = data.words_base;
1506
1507 float percent_restore = 0;
1508
1509 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1510
1511 if (progress_end_relative_skip)
1512 {
1513 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1514 {
1515 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1516 float percent_rejected = 0.0;
1517
1518 if (progress_cur)
1519 {
1520 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1521 }
1522
1523 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1524 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1525
1526 if (data.restore_disable == 0)
1527 {
1528 if (percent_finished != 1)
1529 {
1530 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1531 }
1532 }
1533 }
1534 }
1535 else
1536 {
1537 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1538 {
1539 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1540 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1541
1542 if (data.restore_disable == 0)
1543 {
1544 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1545 }
1546 }
1547 else
1548 {
1549 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1550 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1551
1552 // --restore not allowed if stdin is used -- really? why?
1553
1554 //if (data.restore_disable == 0)
1555 //{
1556 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1557 //}
1558 }
1559 }
1560
1561 #ifdef HAVE_HWMON
1562 if (data.gpu_temp_disable == 0)
1563 {
1564 hc_thread_mutex_lock (mux_adl);
1565
1566 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1567 {
1568 hc_device_param_t *device_param = &data.devices_param[device_id];
1569
1570 if (device_param->skipped) continue;
1571
1572 #define HM_STR_BUF_SIZE 255
1573
1574 if (data.hm_device[device_id].fan_supported == 1)
1575 {
1576 char utilization[HM_STR_BUF_SIZE] = { 0 };
1577 char temperature[HM_STR_BUF_SIZE] = { 0 };
1578 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1579
1580 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1581 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1582
1583 if (device_param->vendor_id == VENDOR_ID_AMD)
1584 {
1585 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1586 }
1587 else if (device_param->vendor_id == VENDOR_ID_NV)
1588 {
1589 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1590 }
1591
1592 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1593 }
1594 else
1595 {
1596 char utilization[HM_STR_BUF_SIZE] = { 0 };
1597 char temperature[HM_STR_BUF_SIZE] = { 0 };
1598
1599 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1600 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1601
1602 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1603 }
1604 }
1605
1606 hc_thread_mutex_unlock (mux_adl);
1607 }
1608 #endif // HAVE_HWMON
1609 }
1610
1611 static void status_benchmark ()
1612 {
1613 if (data.devices_status == STATUS_INIT) return;
1614 if (data.devices_status == STATUS_STARTING) return;
1615
1616 if (data.words_cnt == 0) return;
1617
1618 u64 speed_cnt[DEVICES_MAX] = { 0 };
1619 double speed_ms[DEVICES_MAX] = { 0 };
1620
1621 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1622 {
1623 hc_device_param_t *device_param = &data.devices_param[device_id];
1624
1625 if (device_param->skipped) continue;
1626
1627 speed_cnt[device_id] = device_param->speed_cnt[0];
1628 speed_ms[device_id] = device_param->speed_ms[0];
1629 }
1630
1631 float hashes_all_ms = 0;
1632
1633 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1634
1635 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1636 {
1637 hc_device_param_t *device_param = &data.devices_param[device_id];
1638
1639 if (device_param->skipped) continue;
1640
1641 hashes_dev_ms[device_id] = 0;
1642
1643 if (speed_ms[device_id])
1644 {
1645 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1646
1647 hashes_all_ms += hashes_dev_ms[device_id];
1648 }
1649 }
1650
1651 /**
1652 * exec time
1653 */
1654
1655 double exec_all_ms[DEVICES_MAX] = { 0 };
1656
1657 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1658 {
1659 hc_device_param_t *device_param = &data.devices_param[device_id];
1660
1661 if (device_param->skipped) continue;
1662
1663 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1664
1665 exec_all_ms[device_id] = exec_ms_avg;
1666 }
1667
1668 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1669 {
1670 hc_device_param_t *device_param = &data.devices_param[device_id];
1671
1672 if (device_param->skipped) continue;
1673
1674 char display_dev_cur[16] = { 0 };
1675
1676 strncpy (display_dev_cur, "0.00", 4);
1677
1678 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1679
1680 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1681 }
1682
1683 char display_all_cur[16] = { 0 };
1684
1685 strncpy (display_all_cur, "0.00", 4);
1686
1687 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1688
1689 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1690 }
1691
1692 /**
1693 * hashcat -only- functions
1694 */
1695
1696 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1697 {
1698 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1699 {
1700 if (attack_kern == ATTACK_KERN_STRAIGHT)
1701 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1702 else if (attack_kern == ATTACK_KERN_COMBI)
1703 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1704 else if (attack_kern == ATTACK_KERN_BF)
1705 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1706 }
1707 else
1708 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1709 }
1710
1711 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1712 {
1713 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1714 {
1715 if (attack_kern == ATTACK_KERN_STRAIGHT)
1716 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1717 else if (attack_kern == ATTACK_KERN_COMBI)
1718 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1719 else if (attack_kern == ATTACK_KERN_BF)
1720 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1721 }
1722 else
1723 {
1724 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1725 }
1726 }
1727
1728 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1729 {
1730 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1731 {
1732 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1733 }
1734 else
1735 {
1736 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1737 }
1738 }
1739
1740 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1741 {
1742 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1743 {
1744 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1745 }
1746 else
1747 {
1748 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1749 }
1750 }
1751
1752 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1753 {
1754 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1755 }
1756
1757 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1758 {
1759 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1760 }
1761
1762 static uint convert_from_hex (char *line_buf, const uint line_len)
1763 {
1764 if (line_len & 1) return (line_len); // not in hex
1765
1766 if (data.hex_wordlist == 1)
1767 {
1768 uint i;
1769 uint j;
1770
1771 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1772 {
1773 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1774 }
1775
1776 memset (line_buf + i, 0, line_len - i);
1777
1778 return (i);
1779 }
1780 else if (line_len >= 6) // $HEX[] = 6
1781 {
1782 if (line_buf[0] != '$') return (line_len);
1783 if (line_buf[1] != 'H') return (line_len);
1784 if (line_buf[2] != 'E') return (line_len);
1785 if (line_buf[3] != 'X') return (line_len);
1786 if (line_buf[4] != '[') return (line_len);
1787 if (line_buf[line_len - 1] != ']') return (line_len);
1788
1789 uint i;
1790 uint j;
1791
1792 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1793 {
1794 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1795 }
1796
1797 memset (line_buf + i, 0, line_len - i);
1798
1799 return (i);
1800 }
1801
1802 return (line_len);
1803 }
1804
1805 static void clear_prompt ()
1806 {
1807 fputc ('\r', stdout);
1808
1809 for (size_t i = 0; i < strlen (PROMPT); i++)
1810 {
1811 fputc (' ', stdout);
1812 }
1813
1814 fputc ('\r', stdout);
1815
1816 fflush (stdout);
1817 }
1818
1819 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1820 {
1821 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1822 }
1823
1824 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1825 {
1826 char *outfile = data.outfile;
1827 uint quiet = data.quiet;
1828 FILE *pot_fp = data.pot_fp;
1829 uint loopback = data.loopback;
1830 uint debug_mode = data.debug_mode;
1831 char *debug_file = data.debug_file;
1832
1833 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1834 int debug_rule_len = 0; // -1 error
1835 uint debug_plain_len = 0;
1836
1837 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1838
1839 // hash
1840
1841 char out_buf[HCBUFSIZ] = { 0 };
1842
1843 ascii_digest (out_buf, salt_pos, digest_pos);
1844
1845 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1846
1847 // plain
1848
1849 plain_t plain;
1850
1851 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1852
1853 uint gidvid = plain.gidvid;
1854 uint il_pos = plain.il_pos;
1855
1856 u64 crackpos = device_param->words_off;
1857
1858 uint plain_buf[16] = { 0 };
1859
1860 u8 *plain_ptr = (u8 *) plain_buf;
1861 unsigned int plain_len = 0;
1862
1863 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1864 {
1865 u64 gidd = gidvid;
1866 u64 gidm = 0;
1867
1868 pw_t pw;
1869
1870 gidd_to_pw_t (device_param, gidd, &pw);
1871
1872 for (int i = 0, j = gidm; i < 16; i++, j++)
1873 {
1874 plain_buf[i] = pw.i[j];
1875 }
1876
1877 plain_len = pw.pw_len;
1878
1879 const uint off = device_param->innerloop_pos + il_pos;
1880
1881 if (debug_mode > 0)
1882 {
1883 debug_rule_len = 0;
1884
1885 // save rule
1886 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1887 {
1888 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1889
1890 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1891 }
1892
1893 // save plain
1894 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1895 {
1896 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1897
1898 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1899
1900 debug_plain_len = plain_len;
1901 }
1902 }
1903
1904 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1905
1906 crackpos += gidvid;
1907 crackpos *= data.kernel_rules_cnt;
1908 crackpos += device_param->innerloop_pos + il_pos;
1909
1910 if (plain_len > data.pw_max) plain_len = data.pw_max;
1911 }
1912 else if (data.attack_mode == ATTACK_MODE_COMBI)
1913 {
1914 u64 gidd = gidvid;
1915 u64 gidm = 0;
1916
1917 pw_t pw;
1918
1919 gidd_to_pw_t (device_param, gidd, &pw);
1920
1921 for (int i = 0, j = gidm; i < 16; i++, j++)
1922 {
1923 plain_buf[i] = pw.i[j];
1924 }
1925
1926 plain_len = pw.pw_len;
1927
1928 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1929 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1930
1931 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1932 {
1933 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1934 }
1935 else
1936 {
1937 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1938
1939 memcpy (plain_ptr, comb_buf, comb_len);
1940 }
1941
1942 plain_len += comb_len;
1943
1944 crackpos += gidvid;
1945 crackpos *= data.combs_cnt;
1946 crackpos += device_param->innerloop_pos + il_pos;
1947
1948 if (data.pw_max != PW_DICTMAX1)
1949 {
1950 if (plain_len > data.pw_max) plain_len = data.pw_max;
1951 }
1952 }
1953 else if (data.attack_mode == ATTACK_MODE_BF)
1954 {
1955 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1956 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1957
1958 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1959 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1960
1961 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1962 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1963
1964 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1965 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1966
1967 plain_len = data.css_cnt;
1968
1969 crackpos += gidvid;
1970 crackpos *= data.bfs_cnt;
1971 crackpos += device_param->innerloop_pos + il_pos;
1972 }
1973 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1974 {
1975 u64 gidd = gidvid;
1976 u64 gidm = 0;
1977
1978 pw_t pw;
1979
1980 gidd_to_pw_t (device_param, gidd, &pw);
1981
1982 for (int i = 0, j = gidm; i < 16; i++, j++)
1983 {
1984 plain_buf[i] = pw.i[j];
1985 }
1986
1987 plain_len = pw.pw_len;
1988
1989 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
1990
1991 uint start = 0;
1992 uint stop = device_param->kernel_params_mp_buf32[4];
1993
1994 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1995
1996 plain_len += start + stop;
1997
1998 crackpos += gidvid;
1999 crackpos *= data.combs_cnt;
2000 crackpos += device_param->innerloop_pos + il_pos;
2001
2002 if (data.pw_max != PW_DICTMAX1)
2003 {
2004 if (plain_len > data.pw_max) plain_len = data.pw_max;
2005 }
2006 }
2007 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2008 {
2009 u64 gidd = gidvid;
2010 u64 gidm = 0;
2011
2012 pw_t pw;
2013
2014 gidd_to_pw_t (device_param, gidd, &pw);
2015
2016 for (int i = 0, j = gidm; i < 16; i++, j++)
2017 {
2018 plain_buf[i] = pw.i[j];
2019 }
2020
2021 plain_len = pw.pw_len;
2022
2023 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2024
2025 uint start = 0;
2026 uint stop = device_param->kernel_params_mp_buf32[4];
2027
2028 memmove (plain_ptr + stop, plain_ptr, plain_len);
2029
2030 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2031
2032 plain_len += start + stop;
2033
2034 crackpos += gidvid;
2035 crackpos *= data.combs_cnt;
2036 crackpos += device_param->innerloop_pos + il_pos;
2037
2038 if (data.pw_max != PW_DICTMAX1)
2039 {
2040 if (plain_len > data.pw_max) plain_len = data.pw_max;
2041 }
2042 }
2043
2044 if (data.attack_mode == ATTACK_MODE_BF)
2045 {
2046 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2047 {
2048 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2049 {
2050 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2051 {
2052 plain_len = plain_len - data.salts_buf[0].salt_len;
2053 }
2054 }
2055
2056 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2057 {
2058 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2059 {
2060 plain_ptr[j] = plain_ptr[i];
2061 }
2062
2063 plain_len = plain_len / 2;
2064 }
2065 }
2066 }
2067
2068 // if enabled, update also the potfile
2069
2070 if (pot_fp)
2071 {
2072 lock_file (pot_fp);
2073
2074 fprintf (pot_fp, "%s:", out_buf);
2075
2076 format_plain (pot_fp, plain_ptr, plain_len, 1);
2077
2078 fputc ('\n', pot_fp);
2079
2080 fflush (pot_fp);
2081
2082 unlock_file (pot_fp);
2083 }
2084
2085 // outfile
2086
2087 FILE *out_fp = NULL;
2088
2089 if (outfile != NULL)
2090 {
2091 if ((out_fp = fopen (outfile, "ab")) == NULL)
2092 {
2093 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2094
2095 out_fp = stdout;
2096 }
2097 lock_file (out_fp);
2098 }
2099 else
2100 {
2101 out_fp = stdout;
2102
2103 if (quiet == 0) clear_prompt ();
2104 }
2105
2106 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2107
2108 if (outfile != NULL)
2109 {
2110 if (out_fp != stdout)
2111 {
2112 fclose (out_fp);
2113 }
2114 }
2115 else
2116 {
2117 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2118 {
2119 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2120 {
2121 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2122 if (quiet == 0) fflush (stdout);
2123 }
2124 }
2125 }
2126
2127 // loopback
2128
2129 if (loopback)
2130 {
2131 char *loopback_file = data.loopback_file;
2132
2133 FILE *fb_fp = NULL;
2134
2135 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2136 {
2137 lock_file (fb_fp);
2138
2139 format_plain (fb_fp, plain_ptr, plain_len, 1);
2140
2141 fputc ('\n', fb_fp);
2142
2143 fclose (fb_fp);
2144 }
2145 }
2146
2147 // (rule) debug mode
2148
2149 // the next check implies that:
2150 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2151 // - debug_mode > 0
2152
2153 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2154 {
2155 if (debug_rule_len < 0) debug_rule_len = 0;
2156
2157 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2158
2159 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2160
2161 if ((quiet == 0) && (debug_file == NULL))
2162 {
2163 fprintf (stdout, "%s", PROMPT);
2164
2165 fflush (stdout);
2166 }
2167 }
2168 }
2169
2170 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2171 {
2172 salt_t *salt_buf = &data.salts_buf[salt_pos];
2173
2174 int found = 0;
2175
2176 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2177
2178 for (uint i = 0; i < device_param->kernel_threads; i++) if (device_param->result[i] == 1) found = 1;
2179
2180 if (found == 1)
2181 {
2182 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2183
2184 log_info_nn ("");
2185
2186 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2187
2188 uint cpt_cracked = 0;
2189
2190 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2191 {
2192 uint idx = salt_buf->digests_offset + digest_pos;
2193
2194 if (data.digests_shown_tmp[idx] == 0) continue;
2195
2196 if (data.digests_shown[idx] == 1) continue;
2197
2198 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2199 {
2200 data.digests_shown[idx] = 1;
2201
2202 data.digests_done++;
2203
2204 cpt_cracked++;
2205
2206 salt_buf->digests_done++;
2207
2208 if (salt_buf->digests_done == salt_buf->digests_cnt)
2209 {
2210 data.salts_shown[salt_pos] = 1;
2211
2212 data.salts_done++;
2213 }
2214 }
2215
2216 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2217
2218 check_hash (device_param, salt_pos, digest_pos);
2219 }
2220
2221 if (cpt_cracked > 0)
2222 {
2223 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2224 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2225
2226 data.cpt_pos++;
2227
2228 data.cpt_total += cpt_cracked;
2229
2230 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2231 }
2232
2233 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2234 {
2235 // we need to reset cracked state on the device
2236 // otherwise host thinks again and again the hash was cracked
2237 // and returns invalid password each time
2238
2239 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2240
2241 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2242 }
2243
2244 memset (device_param->result, 0, device_param->size_results);
2245
2246 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2247 }
2248 }
2249
2250 static void save_hash ()
2251 {
2252 char *hashfile = data.hashfile;
2253
2254 char new_hashfile[256] = { 0 };
2255 char old_hashfile[256] = { 0 };
2256
2257 snprintf (new_hashfile, 255, "%s.new", hashfile);
2258 snprintf (old_hashfile, 255, "%s.old", hashfile);
2259
2260 unlink (new_hashfile);
2261
2262 char separator = data.separator;
2263
2264 FILE *fp = fopen (new_hashfile, "wb");
2265
2266 if (fp == NULL)
2267 {
2268 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2269
2270 exit (-1);
2271 }
2272
2273 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2274 {
2275 if (data.salts_shown[salt_pos] == 1) continue;
2276
2277 salt_t *salt_buf = &data.salts_buf[salt_pos];
2278
2279 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2280 {
2281 uint idx = salt_buf->digests_offset + digest_pos;
2282
2283 if (data.digests_shown[idx] == 1) continue;
2284
2285 if (data.hash_mode != 2500)
2286 {
2287 char out_buf[HCBUFSIZ] = { 0 };
2288
2289 if (data.username == 1)
2290 {
2291 user_t *user = data.hash_info[idx]->user;
2292
2293 uint i;
2294
2295 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2296
2297 fputc (separator, fp);
2298 }
2299
2300 ascii_digest (out_buf, salt_pos, digest_pos);
2301
2302 fputs (out_buf, fp);
2303
2304 log_out (fp, "");
2305 }
2306 else
2307 {
2308 hccap_t hccap;
2309
2310 to_hccap_t (&hccap, salt_pos, digest_pos);
2311
2312 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2313 }
2314 }
2315 }
2316
2317 fflush (fp);
2318
2319 fclose (fp);
2320
2321 unlink (old_hashfile);
2322
2323 if (rename (hashfile, old_hashfile) != 0)
2324 {
2325 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2326
2327 exit (-1);
2328 }
2329
2330 unlink (hashfile);
2331
2332 if (rename (new_hashfile, hashfile) != 0)
2333 {
2334 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2335
2336 exit (-1);
2337 }
2338
2339 unlink (old_hashfile);
2340 }
2341
2342 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2343 {
2344 // function called only in case kernel_power_all > words_left
2345
2346 float kernel_power_div = (float) (total_left) / kernel_power_all;
2347
2348 kernel_power_div += kernel_power_div / 100;
2349
2350 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2351
2352 while (kernel_power_new < total_left)
2353 {
2354 kernel_power_div += kernel_power_div / 100;
2355
2356 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2357 }
2358
2359 if (data.quiet == 0)
2360 {
2361 clear_prompt ();
2362
2363 //log_info ("");
2364
2365 log_info ("INFO: approaching final keyspace, workload adjusted");
2366 log_info ("");
2367
2368 fprintf (stdout, "%s", PROMPT);
2369
2370 fflush (stdout);
2371 }
2372
2373 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2374
2375 return kernel_power_div;
2376 }
2377
2378 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2379 {
2380 uint num_elements = num;
2381
2382 device_param->kernel_params_buf32[30] = data.combs_mode;
2383 device_param->kernel_params_buf32[31] = num;
2384
2385 uint kernel_threads = device_param->kernel_threads;
2386
2387 while (num_elements % kernel_threads) num_elements++;
2388
2389 cl_kernel kernel = NULL;
2390
2391 switch (kern_run)
2392 {
2393 case KERN_RUN_1: kernel = device_param->kernel1; break;
2394 case KERN_RUN_12: kernel = device_param->kernel12; break;
2395 case KERN_RUN_2: kernel = device_param->kernel2; break;
2396 case KERN_RUN_23: kernel = device_param->kernel23; break;
2397 case KERN_RUN_3: kernel = device_param->kernel3; break;
2398 }
2399
2400 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2401 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2402 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2403 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2404 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2405 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2406 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2407 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2408 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2409 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2410 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2411
2412 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 log_info ("");
5844 }
5845 else if (restore == 1)
5846 {
5847 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
5848 log_info ("");
5849 }
5850 else
5851 {
5852 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
5853 log_info ("");
5854 }
5855 }
5856
5857 /**
5858 * sanity check
5859 */
5860
5861 if (attack_mode > 7)
5862 {
5863 log_error ("ERROR: Invalid attack-mode specified");
5864
5865 return (-1);
5866 }
5867
5868 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5869 {
5870 log_error ("ERROR: Invalid runtime specified");
5871
5872 return (-1);
5873 }
5874
5875 if (hash_mode_chgd && hash_mode > 13600) // just added to remove compiler warnings for hash_mode_chgd
5876 {
5877 log_error ("ERROR: Invalid hash-type specified");
5878
5879 return (-1);
5880 }
5881
5882 // renamed hash modes
5883
5884 if (hash_mode_chgd)
5885 {
5886 int n = -1;
5887
5888 switch (hash_mode)
5889 {
5890 case 123: n = 124;
5891 break;
5892 }
5893
5894 if (n >= 0)
5895 {
5896 log_error ("Old -m specified, use -m %d instead", n);
5897
5898 return (-1);
5899 }
5900 }
5901
5902 if (username == 1)
5903 {
5904 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5905 {
5906 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5907
5908 return (-1);
5909 }
5910 }
5911
5912 if (outfile_format > 16)
5913 {
5914 log_error ("ERROR: Invalid outfile-format specified");
5915
5916 return (-1);
5917 }
5918
5919 if (left == 1)
5920 {
5921 if (outfile_format_chgd == 1)
5922 {
5923 if (outfile_format > 1)
5924 {
5925 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5926
5927 return (-1);
5928 }
5929 }
5930 else
5931 {
5932 outfile_format = OUTFILE_FMT_HASH;
5933 }
5934 }
5935
5936 if (show == 1)
5937 {
5938 if (outfile_format_chgd == 1)
5939 {
5940 if ((outfile_format > 7) && (outfile_format < 16))
5941 {
5942 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5943
5944 return (-1);
5945 }
5946 }
5947 }
5948
5949 if (increment_min < INCREMENT_MIN)
5950 {
5951 log_error ("ERROR: Invalid increment-min specified");
5952
5953 return (-1);
5954 }
5955
5956 if (increment_max > INCREMENT_MAX)
5957 {
5958 log_error ("ERROR: Invalid increment-max specified");
5959
5960 return (-1);
5961 }
5962
5963 if (increment_min > increment_max)
5964 {
5965 log_error ("ERROR: Invalid increment-min specified");
5966
5967 return (-1);
5968 }
5969
5970 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5971 {
5972 log_error ("ERROR: increment is not allowed in attack-mode 0");
5973
5974 return (-1);
5975 }
5976
5977 if ((increment == 0) && (increment_min_chgd == 1))
5978 {
5979 log_error ("ERROR: increment-min is only supported together with increment switch");
5980
5981 return (-1);
5982 }
5983
5984 if ((increment == 0) && (increment_max_chgd == 1))
5985 {
5986 log_error ("ERROR: increment-max is only supported together with increment switch");
5987
5988 return (-1);
5989 }
5990
5991 if (rp_files_cnt && rp_gen)
5992 {
5993 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5994
5995 return (-1);
5996 }
5997
5998 if (rp_files_cnt || rp_gen)
5999 {
6000 if (attack_mode != ATTACK_MODE_STRAIGHT)
6001 {
6002 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6003
6004 return (-1);
6005 }
6006 }
6007
6008 if (rp_gen_func_min > rp_gen_func_max)
6009 {
6010 log_error ("ERROR: Invalid rp-gen-func-min specified");
6011
6012 return (-1);
6013 }
6014
6015 if (kernel_accel_chgd == 1)
6016 {
6017 if (kernel_accel < 1)
6018 {
6019 log_error ("ERROR: Invalid kernel-accel specified");
6020
6021 return (-1);
6022 }
6023
6024 if (kernel_accel > 1024)
6025 {
6026 log_error ("ERROR: Invalid kernel-accel specified");
6027
6028 return (-1);
6029 }
6030 }
6031
6032 if (kernel_loops_chgd == 1)
6033 {
6034 if (kernel_loops < 1)
6035 {
6036 log_error ("ERROR: Invalid kernel-loops specified");
6037
6038 return (-1);
6039 }
6040
6041 if (kernel_loops > 1024)
6042 {
6043 log_error ("ERROR: Invalid kernel-loops specified");
6044
6045 return (-1);
6046 }
6047 }
6048
6049 if ((workload_profile < 1) || (workload_profile > 3))
6050 {
6051 log_error ("ERROR: workload-profile %i not available", workload_profile);
6052
6053 return (-1);
6054 }
6055
6056 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6057 {
6058 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6059
6060 return (-1);
6061 }
6062
6063 if (show == 1 || left == 1)
6064 {
6065 attack_mode = ATTACK_MODE_NONE;
6066
6067 if (remove == 1)
6068 {
6069 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6070
6071 return (-1);
6072 }
6073
6074 if (potfile_disable == 1)
6075 {
6076 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6077
6078 return (-1);
6079 }
6080 }
6081
6082 uint attack_kern = ATTACK_KERN_NONE;
6083
6084 switch (attack_mode)
6085 {
6086 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6087 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6088 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6089 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6090 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6091 }
6092
6093 if (benchmark == 0)
6094 {
6095 if (keyspace == 1)
6096 {
6097 int num_additional_params = 1;
6098
6099 if (attack_kern == ATTACK_KERN_COMBI)
6100 {
6101 num_additional_params = 2;
6102 }
6103
6104 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6105
6106 if (keyspace_wordlist_specified == 0) optind--;
6107 }
6108
6109 if (attack_kern == ATTACK_KERN_NONE)
6110 {
6111 if ((optind + 1) != myargc)
6112 {
6113 usage_mini_print (myargv[0]);
6114
6115 return (-1);
6116 }
6117 }
6118 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6119 {
6120 if ((optind + 1) > myargc)
6121 {
6122 usage_mini_print (myargv[0]);
6123
6124 return (-1);
6125 }
6126 }
6127 else if (attack_kern == ATTACK_KERN_COMBI)
6128 {
6129 if ((optind + 3) != myargc)
6130 {
6131 usage_mini_print (myargv[0]);
6132
6133 return (-1);
6134 }
6135 }
6136 else if (attack_kern == ATTACK_KERN_BF)
6137 {
6138 if ((optind + 1) > myargc)
6139 {
6140 usage_mini_print (myargv[0]);
6141
6142 return (-1);
6143 }
6144 }
6145 else
6146 {
6147 usage_mini_print (myargv[0]);
6148
6149 return (-1);
6150 }
6151 }
6152 else
6153 {
6154 if (myargv[optind] != 0)
6155 {
6156 log_error ("ERROR: Invalid argument for benchmark mode specified");
6157
6158 return (-1);
6159 }
6160
6161 if (attack_mode_chgd == 1)
6162 {
6163 if (attack_mode != ATTACK_MODE_BF)
6164 {
6165 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6166
6167 return (-1);
6168 }
6169 }
6170 }
6171
6172 if (skip != 0 && limit != 0)
6173 {
6174 limit += skip;
6175 }
6176
6177 if (keyspace == 1)
6178 {
6179 if (show == 1)
6180 {
6181 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6182
6183 return (-1);
6184 }
6185 else if (left == 1)
6186 {
6187 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6188
6189 return (-1);
6190 }
6191
6192 potfile_disable = 1;
6193
6194 restore_disable = 1;
6195
6196 restore = 0;
6197
6198 weak_hash_threshold = 0;
6199
6200 quiet = 1;
6201 }
6202
6203 if (remove_timer_chgd == 1)
6204 {
6205 if (remove == 0)
6206 {
6207 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6208
6209 return (-1);
6210 }
6211
6212 if (remove_timer < 1)
6213 {
6214 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6215
6216 return (-1);
6217 }
6218 }
6219
6220 if (loopback == 1)
6221 {
6222 if (attack_mode == ATTACK_MODE_STRAIGHT)
6223 {
6224 if ((rp_files_cnt == 0) && (rp_gen == 0))
6225 {
6226 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6227
6228 return (-1);
6229 }
6230 }
6231 else
6232 {
6233 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6234
6235 return (-1);
6236 }
6237 }
6238
6239 if (debug_mode > 0)
6240 {
6241 if (attack_mode != ATTACK_MODE_STRAIGHT)
6242 {
6243 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6244
6245 return (-1);
6246 }
6247
6248 if ((rp_files_cnt == 0) && (rp_gen == 0))
6249 {
6250 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6251
6252 return (-1);
6253 }
6254 }
6255
6256 if (debug_mode > 4)
6257 {
6258 log_error ("ERROR: Invalid debug-mode specified");
6259
6260 return (-1);
6261 }
6262
6263 if (debug_file != NULL)
6264 {
6265 if (debug_mode < 1)
6266 {
6267 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6268
6269 return (-1);
6270 }
6271 }
6272
6273 if (induction_dir != NULL)
6274 {
6275 if (attack_mode == ATTACK_MODE_BF)
6276 {
6277 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6278
6279 return (-1);
6280 }
6281 }
6282
6283 if (attack_mode != ATTACK_MODE_STRAIGHT)
6284 {
6285 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6286 {
6287 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6288
6289 return (-1);
6290 }
6291
6292 weak_hash_threshold = 0;
6293 }
6294
6295 /**
6296 * induction directory
6297 */
6298
6299 char *induction_directory = NULL;
6300
6301 if (attack_mode != ATTACK_MODE_BF)
6302 {
6303 if (induction_dir == NULL)
6304 {
6305 induction_directory = (char *) mymalloc (session_size);
6306
6307 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6308
6309 // create induction folder if it does not already exist
6310
6311 if (keyspace == 0)
6312 {
6313 if (rmdir (induction_directory) == -1)
6314 {
6315 if (errno == ENOENT)
6316 {
6317 // good, we can ignore
6318 }
6319 else if (errno == ENOTEMPTY)
6320 {
6321 char *induction_directory_mv = (char *) mymalloc (session_size);
6322
6323 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6324
6325 if (rename (induction_directory, induction_directory_mv) != 0)
6326 {
6327 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6328
6329 return (-1);
6330 }
6331 }
6332 else
6333 {
6334 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6335
6336 return (-1);
6337 }
6338 }
6339
6340 if (mkdir (induction_directory, 0700) == -1)
6341 {
6342 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6343
6344 return (-1);
6345 }
6346 }
6347 }
6348 else
6349 {
6350 induction_directory = induction_dir;
6351 }
6352 }
6353
6354 data.induction_directory = induction_directory;
6355
6356 /**
6357 * loopback
6358 */
6359
6360 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6361
6362 char *loopback_file = (char *) mymalloc (loopback_size);
6363
6364 /**
6365 * tuning db
6366 */
6367
6368 char tuning_db_file[256] = { 0 };
6369
6370 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6371
6372 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6373
6374 /**
6375 * outfile-check directory
6376 */
6377
6378 char *outfile_check_directory = NULL;
6379
6380 if (outfile_check_dir == NULL)
6381 {
6382 outfile_check_directory = (char *) mymalloc (session_size);
6383
6384 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6385 }
6386 else
6387 {
6388 outfile_check_directory = outfile_check_dir;
6389 }
6390
6391 data.outfile_check_directory = outfile_check_directory;
6392
6393 if (keyspace == 0)
6394 {
6395 struct stat outfile_check_stat;
6396
6397 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6398 {
6399 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6400
6401 if (is_dir == 0)
6402 {
6403 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6404
6405 return (-1);
6406 }
6407 }
6408 else if (outfile_check_dir == NULL)
6409 {
6410 if (mkdir (outfile_check_directory, 0700) == -1)
6411 {
6412 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6413
6414 return (-1);
6415 }
6416 }
6417 }
6418
6419 /**
6420 * special other stuff
6421 */
6422
6423 if (hash_mode == 9710)
6424 {
6425 outfile_format = 5;
6426 outfile_format_chgd = 1;
6427 }
6428
6429 if (hash_mode == 9810)
6430 {
6431 outfile_format = 5;
6432 outfile_format_chgd = 1;
6433 }
6434
6435 if (hash_mode == 10410)
6436 {
6437 outfile_format = 5;
6438 outfile_format_chgd = 1;
6439 }
6440
6441 /**
6442 * store stuff
6443 */
6444
6445 data.hash_mode = hash_mode;
6446 data.restore = restore;
6447 data.restore_timer = restore_timer;
6448 data.restore_disable = restore_disable;
6449 data.status = status;
6450 data.status_timer = status_timer;
6451 data.status_automat = status_automat;
6452 data.loopback = loopback;
6453 data.runtime = runtime;
6454 data.remove = remove;
6455 data.remove_timer = remove_timer;
6456 data.debug_mode = debug_mode;
6457 data.debug_file = debug_file;
6458 data.username = username;
6459 data.quiet = quiet;
6460 data.outfile = outfile;
6461 data.outfile_format = outfile_format;
6462 data.outfile_autohex = outfile_autohex;
6463 data.hex_charset = hex_charset;
6464 data.hex_salt = hex_salt;
6465 data.hex_wordlist = hex_wordlist;
6466 data.separator = separator;
6467 data.rp_files = rp_files;
6468 data.rp_files_cnt = rp_files_cnt;
6469 data.rp_gen = rp_gen;
6470 data.rp_gen_seed = rp_gen_seed;
6471 data.force = force;
6472 data.benchmark = benchmark;
6473 data.skip = skip;
6474 data.limit = limit;
6475 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6476 data.powertune_enable = powertune_enable;
6477 #endif
6478 data.logfile_disable = logfile_disable;
6479 data.truecrypt_keyfiles = truecrypt_keyfiles;
6480 data.scrypt_tmto = scrypt_tmto;
6481 data.workload_profile = workload_profile;
6482
6483 /**
6484 * cpu affinity
6485 */
6486
6487 if (cpu_affinity)
6488 {
6489 set_cpu_affinity (cpu_affinity);
6490 }
6491
6492 if (rp_gen_seed_chgd == 0)
6493 {
6494 srand (proc_start);
6495 }
6496 else
6497 {
6498 srand (rp_gen_seed);
6499 }
6500
6501 /**
6502 * logfile init
6503 */
6504
6505 if (logfile_disable == 0)
6506 {
6507 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6508
6509 char *logfile = (char *) mymalloc (logfile_size);
6510
6511 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6512
6513 data.logfile = logfile;
6514
6515 char *topid = logfile_generate_topid ();
6516
6517 data.topid = topid;
6518 }
6519
6520 // logfile_append() checks for logfile_disable internally to make it easier from here
6521
6522 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6523 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6524 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6525 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6526 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6527 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6528 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6529 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6530 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6531 #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));
6532
6533 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6534 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6535 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6536 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6537 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6538 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6539 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6540 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6541
6542 logfile_top_msg ("START");
6543
6544 logfile_top_uint (attack_mode);
6545 logfile_top_uint (attack_kern);
6546 logfile_top_uint (benchmark);
6547 logfile_top_uint (bitmap_min);
6548 logfile_top_uint (bitmap_max);
6549 logfile_top_uint (debug_mode);
6550 logfile_top_uint (force);
6551 logfile_top_uint (kernel_accel);
6552 logfile_top_uint (kernel_loops);
6553 logfile_top_uint (gpu_temp_disable);
6554 #ifdef HAVE_HWMON
6555 logfile_top_uint (gpu_temp_abort);
6556 logfile_top_uint (gpu_temp_retain);
6557 #endif
6558 logfile_top_uint (hash_mode);
6559 logfile_top_uint (hex_charset);
6560 logfile_top_uint (hex_salt);
6561 logfile_top_uint (hex_wordlist);
6562 logfile_top_uint (increment);
6563 logfile_top_uint (increment_max);
6564 logfile_top_uint (increment_min);
6565 logfile_top_uint (keyspace);
6566 logfile_top_uint (left);
6567 logfile_top_uint (logfile_disable);
6568 logfile_top_uint (loopback);
6569 logfile_top_uint (markov_classic);
6570 logfile_top_uint (markov_disable);
6571 logfile_top_uint (markov_threshold);
6572 logfile_top_uint (outfile_autohex);
6573 logfile_top_uint (outfile_check_timer);
6574 logfile_top_uint (outfile_format);
6575 logfile_top_uint (potfile_disable);
6576 logfile_top_string (potfile_path);
6577 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6578 logfile_top_uint (powertune_enable);
6579 #endif
6580 logfile_top_uint (scrypt_tmto);
6581 logfile_top_uint (quiet);
6582 logfile_top_uint (remove);
6583 logfile_top_uint (remove_timer);
6584 logfile_top_uint (restore);
6585 logfile_top_uint (restore_disable);
6586 logfile_top_uint (restore_timer);
6587 logfile_top_uint (rp_gen);
6588 logfile_top_uint (rp_gen_func_max);
6589 logfile_top_uint (rp_gen_func_min);
6590 logfile_top_uint (rp_gen_seed);
6591 logfile_top_uint (runtime);
6592 logfile_top_uint (segment_size);
6593 logfile_top_uint (show);
6594 logfile_top_uint (status);
6595 logfile_top_uint (status_automat);
6596 logfile_top_uint (status_timer);
6597 logfile_top_uint (usage);
6598 logfile_top_uint (username);
6599 logfile_top_uint (version);
6600 logfile_top_uint (weak_hash_threshold);
6601 logfile_top_uint (workload_profile);
6602 logfile_top_uint64 (limit);
6603 logfile_top_uint64 (skip);
6604 logfile_top_char (separator);
6605 logfile_top_string (cpu_affinity);
6606 logfile_top_string (custom_charset_1);
6607 logfile_top_string (custom_charset_2);
6608 logfile_top_string (custom_charset_3);
6609 logfile_top_string (custom_charset_4);
6610 logfile_top_string (debug_file);
6611 logfile_top_string (opencl_devices);
6612 logfile_top_string (opencl_platforms);
6613 logfile_top_string (opencl_device_types);
6614 logfile_top_uint (opencl_vector_width);
6615 logfile_top_string (induction_dir);
6616 logfile_top_string (markov_hcstat);
6617 logfile_top_string (outfile);
6618 logfile_top_string (outfile_check_dir);
6619 logfile_top_string (rule_buf_l);
6620 logfile_top_string (rule_buf_r);
6621 logfile_top_string (session);
6622 logfile_top_string (truecrypt_keyfiles);
6623
6624 /**
6625 * Init OpenCL library loader
6626 */
6627
6628 if (keyspace == 0)
6629 {
6630 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6631
6632 ocl_init (ocl);
6633
6634 data.ocl = ocl;
6635 }
6636
6637 /**
6638 * OpenCL platform selection
6639 */
6640
6641 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6642
6643 /**
6644 * OpenCL device selection
6645 */
6646
6647 u32 devices_filter = setup_devices_filter (opencl_devices);
6648
6649 /**
6650 * OpenCL device type selection
6651 */
6652
6653 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6654
6655 /**
6656 * benchmark
6657 */
6658
6659 if (benchmark == 1)
6660 {
6661 /**
6662 * disable useless stuff for benchmark
6663 */
6664
6665 status_timer = 0;
6666 restore_timer = 0;
6667 restore_disable = 1;
6668 potfile_disable = 1;
6669 weak_hash_threshold = 0;
6670 gpu_temp_disable = 1;
6671
6672 data.status_timer = status_timer;
6673 data.restore_timer = restore_timer;
6674 data.restore_disable = restore_disable;
6675
6676 /**
6677 * force attack mode to be bruteforce
6678 */
6679
6680 attack_mode = ATTACK_MODE_BF;
6681 attack_kern = ATTACK_KERN_BF;
6682
6683 if (workload_profile_chgd == 0)
6684 {
6685 workload_profile = 3;
6686
6687 data.workload_profile = workload_profile;
6688 }
6689 }
6690
6691 /**
6692 * config
6693 */
6694
6695 uint hash_type = 0;
6696 uint salt_type = 0;
6697 uint attack_exec = 0;
6698 uint opts_type = 0;
6699 uint kern_type = 0;
6700 uint dgst_size = 0;
6701 uint esalt_size = 0;
6702 uint opti_type = 0;
6703 uint dgst_pos0 = -1;
6704 uint dgst_pos1 = -1;
6705 uint dgst_pos2 = -1;
6706 uint dgst_pos3 = -1;
6707
6708 int (*parse_func) (char *, uint, hash_t *);
6709 int (*sort_by_digest) (const void *, const void *);
6710
6711 uint algorithm_pos = 0;
6712 uint algorithm_max = 1;
6713
6714 uint *algorithms = default_benchmark_algorithms;
6715
6716 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6717
6718 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6719 {
6720 /*
6721 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6722 * the following algos are skipped entirely
6723 */
6724
6725 if (algorithm_pos > 0)
6726 {
6727 local_free (rd);
6728
6729 rd = init_restore (argc, argv);
6730
6731 data.rd = rd;
6732 }
6733
6734 /**
6735 * update hash_mode in case of multihash benchmark
6736 */
6737
6738 if (benchmark == 1)
6739 {
6740 if (hash_mode_chgd == 0)
6741 {
6742 hash_mode = algorithms[algorithm_pos];
6743
6744 data.hash_mode = hash_mode;
6745 }
6746
6747 quiet = 1;
6748
6749 data.quiet = quiet;
6750 }
6751
6752 switch (hash_mode)
6753 {
6754 case 0: hash_type = HASH_TYPE_MD5;
6755 salt_type = SALT_TYPE_NONE;
6756 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6757 opts_type = OPTS_TYPE_PT_GENERATE_LE
6758 | OPTS_TYPE_PT_ADD80
6759 | OPTS_TYPE_PT_ADDBITS14;
6760 kern_type = KERN_TYPE_MD5;
6761 dgst_size = DGST_SIZE_4_4;
6762 parse_func = md5_parse_hash;
6763 sort_by_digest = sort_by_digest_4_4;
6764 opti_type = OPTI_TYPE_ZERO_BYTE
6765 | OPTI_TYPE_PRECOMPUTE_INIT
6766 | OPTI_TYPE_PRECOMPUTE_MERKLE
6767 | OPTI_TYPE_MEET_IN_MIDDLE
6768 | OPTI_TYPE_EARLY_SKIP
6769 | OPTI_TYPE_NOT_ITERATED
6770 | OPTI_TYPE_NOT_SALTED
6771 | OPTI_TYPE_RAW_HASH;
6772 dgst_pos0 = 0;
6773 dgst_pos1 = 3;
6774 dgst_pos2 = 2;
6775 dgst_pos3 = 1;
6776 break;
6777
6778 case 10: hash_type = HASH_TYPE_MD5;
6779 salt_type = SALT_TYPE_INTERN;
6780 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6781 opts_type = OPTS_TYPE_PT_GENERATE_LE
6782 | OPTS_TYPE_ST_ADD80
6783 | OPTS_TYPE_ST_ADDBITS14;
6784 kern_type = KERN_TYPE_MD5_PWSLT;
6785 dgst_size = DGST_SIZE_4_4;
6786 parse_func = md5s_parse_hash;
6787 sort_by_digest = sort_by_digest_4_4;
6788 opti_type = OPTI_TYPE_ZERO_BYTE
6789 | OPTI_TYPE_PRECOMPUTE_INIT
6790 | OPTI_TYPE_PRECOMPUTE_MERKLE
6791 | OPTI_TYPE_MEET_IN_MIDDLE
6792 | OPTI_TYPE_EARLY_SKIP
6793 | OPTI_TYPE_NOT_ITERATED
6794 | OPTI_TYPE_APPENDED_SALT
6795 | OPTI_TYPE_RAW_HASH;
6796 dgst_pos0 = 0;
6797 dgst_pos1 = 3;
6798 dgst_pos2 = 2;
6799 dgst_pos3 = 1;
6800 break;
6801
6802 case 11: hash_type = HASH_TYPE_MD5;
6803 salt_type = SALT_TYPE_INTERN;
6804 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6805 opts_type = OPTS_TYPE_PT_GENERATE_LE
6806 | OPTS_TYPE_ST_ADD80
6807 | OPTS_TYPE_ST_ADDBITS14;
6808 kern_type = KERN_TYPE_MD5_PWSLT;
6809 dgst_size = DGST_SIZE_4_4;
6810 parse_func = joomla_parse_hash;
6811 sort_by_digest = sort_by_digest_4_4;
6812 opti_type = OPTI_TYPE_ZERO_BYTE
6813 | OPTI_TYPE_PRECOMPUTE_INIT
6814 | OPTI_TYPE_PRECOMPUTE_MERKLE
6815 | OPTI_TYPE_MEET_IN_MIDDLE
6816 | OPTI_TYPE_EARLY_SKIP
6817 | OPTI_TYPE_NOT_ITERATED
6818 | OPTI_TYPE_APPENDED_SALT
6819 | OPTI_TYPE_RAW_HASH;
6820 dgst_pos0 = 0;
6821 dgst_pos1 = 3;
6822 dgst_pos2 = 2;
6823 dgst_pos3 = 1;
6824 break;
6825
6826 case 12: hash_type = HASH_TYPE_MD5;
6827 salt_type = SALT_TYPE_INTERN;
6828 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6829 opts_type = OPTS_TYPE_PT_GENERATE_LE
6830 | OPTS_TYPE_ST_ADD80
6831 | OPTS_TYPE_ST_ADDBITS14;
6832 kern_type = KERN_TYPE_MD5_PWSLT;
6833 dgst_size = DGST_SIZE_4_4;
6834 parse_func = postgresql_parse_hash;
6835 sort_by_digest = sort_by_digest_4_4;
6836 opti_type = OPTI_TYPE_ZERO_BYTE
6837 | OPTI_TYPE_PRECOMPUTE_INIT
6838 | OPTI_TYPE_PRECOMPUTE_MERKLE
6839 | OPTI_TYPE_MEET_IN_MIDDLE
6840 | OPTI_TYPE_EARLY_SKIP
6841 | OPTI_TYPE_NOT_ITERATED
6842 | OPTI_TYPE_APPENDED_SALT
6843 | OPTI_TYPE_RAW_HASH;
6844 dgst_pos0 = 0;
6845 dgst_pos1 = 3;
6846 dgst_pos2 = 2;
6847 dgst_pos3 = 1;
6848 break;
6849
6850 case 20: hash_type = HASH_TYPE_MD5;
6851 salt_type = SALT_TYPE_INTERN;
6852 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6853 opts_type = OPTS_TYPE_PT_GENERATE_LE
6854 | OPTS_TYPE_PT_ADD80
6855 | OPTS_TYPE_PT_ADDBITS14;
6856 kern_type = KERN_TYPE_MD5_SLTPW;
6857 dgst_size = DGST_SIZE_4_4;
6858 parse_func = md5s_parse_hash;
6859 sort_by_digest = sort_by_digest_4_4;
6860 opti_type = OPTI_TYPE_ZERO_BYTE
6861 | OPTI_TYPE_PRECOMPUTE_INIT
6862 | OPTI_TYPE_PRECOMPUTE_MERKLE
6863 | OPTI_TYPE_EARLY_SKIP
6864 | OPTI_TYPE_NOT_ITERATED
6865 | OPTI_TYPE_PREPENDED_SALT
6866 | OPTI_TYPE_RAW_HASH;
6867 dgst_pos0 = 0;
6868 dgst_pos1 = 3;
6869 dgst_pos2 = 2;
6870 dgst_pos3 = 1;
6871 break;
6872
6873 case 21: hash_type = HASH_TYPE_MD5;
6874 salt_type = SALT_TYPE_INTERN;
6875 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6876 opts_type = OPTS_TYPE_PT_GENERATE_LE
6877 | OPTS_TYPE_PT_ADD80
6878 | OPTS_TYPE_PT_ADDBITS14;
6879 kern_type = KERN_TYPE_MD5_SLTPW;
6880 dgst_size = DGST_SIZE_4_4;
6881 parse_func = osc_parse_hash;
6882 sort_by_digest = sort_by_digest_4_4;
6883 opti_type = OPTI_TYPE_ZERO_BYTE
6884 | OPTI_TYPE_PRECOMPUTE_INIT
6885 | OPTI_TYPE_PRECOMPUTE_MERKLE
6886 | OPTI_TYPE_EARLY_SKIP
6887 | OPTI_TYPE_NOT_ITERATED
6888 | OPTI_TYPE_PREPENDED_SALT
6889 | OPTI_TYPE_RAW_HASH;
6890 dgst_pos0 = 0;
6891 dgst_pos1 = 3;
6892 dgst_pos2 = 2;
6893 dgst_pos3 = 1;
6894 break;
6895
6896 case 22: hash_type = HASH_TYPE_MD5;
6897 salt_type = SALT_TYPE_EMBEDDED;
6898 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6899 opts_type = OPTS_TYPE_PT_GENERATE_LE
6900 | OPTS_TYPE_PT_ADD80
6901 | OPTS_TYPE_PT_ADDBITS14;
6902 kern_type = KERN_TYPE_MD5_SLTPW;
6903 dgst_size = DGST_SIZE_4_4;
6904 parse_func = netscreen_parse_hash;
6905 sort_by_digest = sort_by_digest_4_4;
6906 opti_type = OPTI_TYPE_ZERO_BYTE
6907 | OPTI_TYPE_PRECOMPUTE_INIT
6908 | OPTI_TYPE_PRECOMPUTE_MERKLE
6909 | OPTI_TYPE_EARLY_SKIP
6910 | OPTI_TYPE_NOT_ITERATED
6911 | OPTI_TYPE_PREPENDED_SALT
6912 | OPTI_TYPE_RAW_HASH;
6913 dgst_pos0 = 0;
6914 dgst_pos1 = 3;
6915 dgst_pos2 = 2;
6916 dgst_pos3 = 1;
6917 break;
6918
6919 case 23: hash_type = HASH_TYPE_MD5;
6920 salt_type = SALT_TYPE_EMBEDDED;
6921 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6922 opts_type = OPTS_TYPE_PT_GENERATE_LE
6923 | OPTS_TYPE_PT_ADD80
6924 | OPTS_TYPE_PT_ADDBITS14;
6925 kern_type = KERN_TYPE_MD5_SLTPW;
6926 dgst_size = DGST_SIZE_4_4;
6927 parse_func = skype_parse_hash;
6928 sort_by_digest = sort_by_digest_4_4;
6929 opti_type = OPTI_TYPE_ZERO_BYTE
6930 | OPTI_TYPE_PRECOMPUTE_INIT
6931 | OPTI_TYPE_PRECOMPUTE_MERKLE
6932 | OPTI_TYPE_EARLY_SKIP
6933 | OPTI_TYPE_NOT_ITERATED
6934 | OPTI_TYPE_PREPENDED_SALT
6935 | OPTI_TYPE_RAW_HASH;
6936 dgst_pos0 = 0;
6937 dgst_pos1 = 3;
6938 dgst_pos2 = 2;
6939 dgst_pos3 = 1;
6940 break;
6941
6942 case 30: hash_type = HASH_TYPE_MD5;
6943 salt_type = SALT_TYPE_INTERN;
6944 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6945 opts_type = OPTS_TYPE_PT_GENERATE_LE
6946 | OPTS_TYPE_PT_UNICODE
6947 | OPTS_TYPE_ST_ADD80
6948 | OPTS_TYPE_ST_ADDBITS14;
6949 kern_type = KERN_TYPE_MD5_PWUSLT;
6950 dgst_size = DGST_SIZE_4_4;
6951 parse_func = md5s_parse_hash;
6952 sort_by_digest = sort_by_digest_4_4;
6953 opti_type = OPTI_TYPE_ZERO_BYTE
6954 | OPTI_TYPE_PRECOMPUTE_INIT
6955 | OPTI_TYPE_PRECOMPUTE_MERKLE
6956 | OPTI_TYPE_MEET_IN_MIDDLE
6957 | OPTI_TYPE_EARLY_SKIP
6958 | OPTI_TYPE_NOT_ITERATED
6959 | OPTI_TYPE_APPENDED_SALT
6960 | OPTI_TYPE_RAW_HASH;
6961 dgst_pos0 = 0;
6962 dgst_pos1 = 3;
6963 dgst_pos2 = 2;
6964 dgst_pos3 = 1;
6965 break;
6966
6967 case 40: hash_type = HASH_TYPE_MD5;
6968 salt_type = SALT_TYPE_INTERN;
6969 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6970 opts_type = OPTS_TYPE_PT_GENERATE_LE
6971 | OPTS_TYPE_PT_ADD80
6972 | OPTS_TYPE_PT_ADDBITS14
6973 | OPTS_TYPE_PT_UNICODE;
6974 kern_type = KERN_TYPE_MD5_SLTPWU;
6975 dgst_size = DGST_SIZE_4_4;
6976 parse_func = md5s_parse_hash;
6977 sort_by_digest = sort_by_digest_4_4;
6978 opti_type = OPTI_TYPE_ZERO_BYTE
6979 | OPTI_TYPE_PRECOMPUTE_INIT
6980 | OPTI_TYPE_PRECOMPUTE_MERKLE
6981 | OPTI_TYPE_EARLY_SKIP
6982 | OPTI_TYPE_NOT_ITERATED
6983 | OPTI_TYPE_PREPENDED_SALT
6984 | OPTI_TYPE_RAW_HASH;
6985 dgst_pos0 = 0;
6986 dgst_pos1 = 3;
6987 dgst_pos2 = 2;
6988 dgst_pos3 = 1;
6989 break;
6990
6991 case 50: hash_type = HASH_TYPE_MD5;
6992 salt_type = SALT_TYPE_INTERN;
6993 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6994 opts_type = OPTS_TYPE_PT_GENERATE_LE
6995 | OPTS_TYPE_ST_ADD80
6996 | OPTS_TYPE_ST_ADDBITS14;
6997 kern_type = KERN_TYPE_HMACMD5_PW;
6998 dgst_size = DGST_SIZE_4_4;
6999 parse_func = hmacmd5_parse_hash;
7000 sort_by_digest = sort_by_digest_4_4;
7001 opti_type = OPTI_TYPE_ZERO_BYTE
7002 | OPTI_TYPE_NOT_ITERATED;
7003 dgst_pos0 = 0;
7004 dgst_pos1 = 3;
7005 dgst_pos2 = 2;
7006 dgst_pos3 = 1;
7007 break;
7008
7009 case 60: hash_type = HASH_TYPE_MD5;
7010 salt_type = SALT_TYPE_INTERN;
7011 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7012 opts_type = OPTS_TYPE_PT_GENERATE_LE
7013 | OPTS_TYPE_PT_ADD80
7014 | OPTS_TYPE_PT_ADDBITS14;
7015 kern_type = KERN_TYPE_HMACMD5_SLT;
7016 dgst_size = DGST_SIZE_4_4;
7017 parse_func = hmacmd5_parse_hash;
7018 sort_by_digest = sort_by_digest_4_4;
7019 opti_type = OPTI_TYPE_ZERO_BYTE
7020 | OPTI_TYPE_NOT_ITERATED;
7021 dgst_pos0 = 0;
7022 dgst_pos1 = 3;
7023 dgst_pos2 = 2;
7024 dgst_pos3 = 1;
7025 break;
7026
7027 case 100: hash_type = HASH_TYPE_SHA1;
7028 salt_type = SALT_TYPE_NONE;
7029 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7030 opts_type = OPTS_TYPE_PT_GENERATE_BE
7031 | OPTS_TYPE_PT_ADD80
7032 | OPTS_TYPE_PT_ADDBITS15;
7033 kern_type = KERN_TYPE_SHA1;
7034 dgst_size = DGST_SIZE_4_5;
7035 parse_func = sha1_parse_hash;
7036 sort_by_digest = sort_by_digest_4_5;
7037 opti_type = OPTI_TYPE_ZERO_BYTE
7038 | OPTI_TYPE_PRECOMPUTE_INIT
7039 | OPTI_TYPE_PRECOMPUTE_MERKLE
7040 | OPTI_TYPE_EARLY_SKIP
7041 | OPTI_TYPE_NOT_ITERATED
7042 | OPTI_TYPE_NOT_SALTED
7043 | OPTI_TYPE_RAW_HASH;
7044 dgst_pos0 = 3;
7045 dgst_pos1 = 4;
7046 dgst_pos2 = 2;
7047 dgst_pos3 = 1;
7048 break;
7049
7050 case 101: hash_type = HASH_TYPE_SHA1;
7051 salt_type = SALT_TYPE_NONE;
7052 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7053 opts_type = OPTS_TYPE_PT_GENERATE_BE
7054 | OPTS_TYPE_PT_ADD80
7055 | OPTS_TYPE_PT_ADDBITS15;
7056 kern_type = KERN_TYPE_SHA1;
7057 dgst_size = DGST_SIZE_4_5;
7058 parse_func = sha1b64_parse_hash;
7059 sort_by_digest = sort_by_digest_4_5;
7060 opti_type = OPTI_TYPE_ZERO_BYTE
7061 | OPTI_TYPE_PRECOMPUTE_INIT
7062 | OPTI_TYPE_PRECOMPUTE_MERKLE
7063 | OPTI_TYPE_EARLY_SKIP
7064 | OPTI_TYPE_NOT_ITERATED
7065 | OPTI_TYPE_NOT_SALTED
7066 | OPTI_TYPE_RAW_HASH;
7067 dgst_pos0 = 3;
7068 dgst_pos1 = 4;
7069 dgst_pos2 = 2;
7070 dgst_pos3 = 1;
7071 break;
7072
7073 case 110: hash_type = HASH_TYPE_SHA1;
7074 salt_type = SALT_TYPE_INTERN;
7075 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7076 opts_type = OPTS_TYPE_PT_GENERATE_BE
7077 | OPTS_TYPE_ST_ADD80
7078 | OPTS_TYPE_ST_ADDBITS15;
7079 kern_type = KERN_TYPE_SHA1_PWSLT;
7080 dgst_size = DGST_SIZE_4_5;
7081 parse_func = sha1s_parse_hash;
7082 sort_by_digest = sort_by_digest_4_5;
7083 opti_type = OPTI_TYPE_ZERO_BYTE
7084 | OPTI_TYPE_PRECOMPUTE_INIT
7085 | OPTI_TYPE_PRECOMPUTE_MERKLE
7086 | OPTI_TYPE_EARLY_SKIP
7087 | OPTI_TYPE_NOT_ITERATED
7088 | OPTI_TYPE_APPENDED_SALT
7089 | OPTI_TYPE_RAW_HASH;
7090 dgst_pos0 = 3;
7091 dgst_pos1 = 4;
7092 dgst_pos2 = 2;
7093 dgst_pos3 = 1;
7094 break;
7095
7096 case 111: hash_type = HASH_TYPE_SHA1;
7097 salt_type = SALT_TYPE_EMBEDDED;
7098 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7099 opts_type = OPTS_TYPE_PT_GENERATE_BE
7100 | OPTS_TYPE_ST_ADD80
7101 | OPTS_TYPE_ST_ADDBITS15;
7102 kern_type = KERN_TYPE_SHA1_PWSLT;
7103 dgst_size = DGST_SIZE_4_5;
7104 parse_func = sha1b64s_parse_hash;
7105 sort_by_digest = sort_by_digest_4_5;
7106 opti_type = OPTI_TYPE_ZERO_BYTE
7107 | OPTI_TYPE_PRECOMPUTE_INIT
7108 | OPTI_TYPE_PRECOMPUTE_MERKLE
7109 | OPTI_TYPE_EARLY_SKIP
7110 | OPTI_TYPE_NOT_ITERATED
7111 | OPTI_TYPE_APPENDED_SALT
7112 | OPTI_TYPE_RAW_HASH;
7113 dgst_pos0 = 3;
7114 dgst_pos1 = 4;
7115 dgst_pos2 = 2;
7116 dgst_pos3 = 1;
7117 break;
7118
7119 case 112: hash_type = HASH_TYPE_SHA1;
7120 salt_type = SALT_TYPE_INTERN;
7121 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7122 opts_type = OPTS_TYPE_PT_GENERATE_BE
7123 | OPTS_TYPE_ST_ADD80
7124 | OPTS_TYPE_ST_ADDBITS15
7125 | OPTS_TYPE_ST_HEX;
7126 kern_type = KERN_TYPE_SHA1_PWSLT;
7127 dgst_size = DGST_SIZE_4_5;
7128 parse_func = oracles_parse_hash;
7129 sort_by_digest = sort_by_digest_4_5;
7130 opti_type = OPTI_TYPE_ZERO_BYTE
7131 | OPTI_TYPE_PRECOMPUTE_INIT
7132 | OPTI_TYPE_PRECOMPUTE_MERKLE
7133 | OPTI_TYPE_EARLY_SKIP
7134 | OPTI_TYPE_NOT_ITERATED
7135 | OPTI_TYPE_APPENDED_SALT
7136 | OPTI_TYPE_RAW_HASH;
7137 dgst_pos0 = 3;
7138 dgst_pos1 = 4;
7139 dgst_pos2 = 2;
7140 dgst_pos3 = 1;
7141 break;
7142
7143 case 120: hash_type = HASH_TYPE_SHA1;
7144 salt_type = SALT_TYPE_INTERN;
7145 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7146 opts_type = OPTS_TYPE_PT_GENERATE_BE
7147 | OPTS_TYPE_PT_ADD80
7148 | OPTS_TYPE_PT_ADDBITS15;
7149 kern_type = KERN_TYPE_SHA1_SLTPW;
7150 dgst_size = DGST_SIZE_4_5;
7151 parse_func = sha1s_parse_hash;
7152 sort_by_digest = sort_by_digest_4_5;
7153 opti_type = OPTI_TYPE_ZERO_BYTE
7154 | OPTI_TYPE_PRECOMPUTE_INIT
7155 | OPTI_TYPE_PRECOMPUTE_MERKLE
7156 | OPTI_TYPE_EARLY_SKIP
7157 | OPTI_TYPE_NOT_ITERATED
7158 | OPTI_TYPE_PREPENDED_SALT
7159 | OPTI_TYPE_RAW_HASH;
7160 dgst_pos0 = 3;
7161 dgst_pos1 = 4;
7162 dgst_pos2 = 2;
7163 dgst_pos3 = 1;
7164 break;
7165
7166 case 121: hash_type = HASH_TYPE_SHA1;
7167 salt_type = SALT_TYPE_INTERN;
7168 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7169 opts_type = OPTS_TYPE_PT_GENERATE_BE
7170 | OPTS_TYPE_PT_ADD80
7171 | OPTS_TYPE_PT_ADDBITS15
7172 | OPTS_TYPE_ST_LOWER;
7173 kern_type = KERN_TYPE_SHA1_SLTPW;
7174 dgst_size = DGST_SIZE_4_5;
7175 parse_func = smf_parse_hash;
7176 sort_by_digest = sort_by_digest_4_5;
7177 opti_type = OPTI_TYPE_ZERO_BYTE
7178 | OPTI_TYPE_PRECOMPUTE_INIT
7179 | OPTI_TYPE_PRECOMPUTE_MERKLE
7180 | OPTI_TYPE_EARLY_SKIP
7181 | OPTI_TYPE_NOT_ITERATED
7182 | OPTI_TYPE_PREPENDED_SALT
7183 | OPTI_TYPE_RAW_HASH;
7184 dgst_pos0 = 3;
7185 dgst_pos1 = 4;
7186 dgst_pos2 = 2;
7187 dgst_pos3 = 1;
7188 break;
7189
7190 case 122: hash_type = HASH_TYPE_SHA1;
7191 salt_type = SALT_TYPE_EMBEDDED;
7192 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7193 opts_type = OPTS_TYPE_PT_GENERATE_BE
7194 | OPTS_TYPE_PT_ADD80
7195 | OPTS_TYPE_PT_ADDBITS15
7196 | OPTS_TYPE_ST_HEX;
7197 kern_type = KERN_TYPE_SHA1_SLTPW;
7198 dgst_size = DGST_SIZE_4_5;
7199 parse_func = osx1_parse_hash;
7200 sort_by_digest = sort_by_digest_4_5;
7201 opti_type = OPTI_TYPE_ZERO_BYTE
7202 | OPTI_TYPE_PRECOMPUTE_INIT
7203 | OPTI_TYPE_PRECOMPUTE_MERKLE
7204 | OPTI_TYPE_EARLY_SKIP
7205 | OPTI_TYPE_NOT_ITERATED
7206 | OPTI_TYPE_PREPENDED_SALT
7207 | OPTI_TYPE_RAW_HASH;
7208 dgst_pos0 = 3;
7209 dgst_pos1 = 4;
7210 dgst_pos2 = 2;
7211 dgst_pos3 = 1;
7212 break;
7213
7214 case 124: hash_type = HASH_TYPE_SHA1;
7215 salt_type = SALT_TYPE_EMBEDDED;
7216 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7217 opts_type = OPTS_TYPE_PT_GENERATE_BE
7218 | OPTS_TYPE_PT_ADD80
7219 | OPTS_TYPE_PT_ADDBITS15;
7220 kern_type = KERN_TYPE_SHA1_SLTPW;
7221 dgst_size = DGST_SIZE_4_5;
7222 parse_func = djangosha1_parse_hash;
7223 sort_by_digest = sort_by_digest_4_5;
7224 opti_type = OPTI_TYPE_ZERO_BYTE
7225 | OPTI_TYPE_PRECOMPUTE_INIT
7226 | OPTI_TYPE_PRECOMPUTE_MERKLE
7227 | OPTI_TYPE_EARLY_SKIP
7228 | OPTI_TYPE_NOT_ITERATED
7229 | OPTI_TYPE_PREPENDED_SALT
7230 | OPTI_TYPE_RAW_HASH;
7231 dgst_pos0 = 3;
7232 dgst_pos1 = 4;
7233 dgst_pos2 = 2;
7234 dgst_pos3 = 1;
7235 break;
7236
7237 case 125: hash_type = HASH_TYPE_SHA1;
7238 salt_type = SALT_TYPE_EMBEDDED;
7239 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7240 opts_type = OPTS_TYPE_PT_GENERATE_BE
7241 | OPTS_TYPE_PT_ADD80
7242 | OPTS_TYPE_PT_ADDBITS15
7243 | OPTS_TYPE_ST_HEX;
7244 kern_type = KERN_TYPE_SHA1_SLTPW;
7245 dgst_size = DGST_SIZE_4_5;
7246 parse_func = arubaos_parse_hash;
7247 sort_by_digest = sort_by_digest_4_5;
7248 opti_type = OPTI_TYPE_ZERO_BYTE
7249 | OPTI_TYPE_PRECOMPUTE_INIT
7250 | OPTI_TYPE_PRECOMPUTE_MERKLE
7251 | OPTI_TYPE_EARLY_SKIP
7252 | OPTI_TYPE_NOT_ITERATED
7253 | OPTI_TYPE_PREPENDED_SALT
7254 | OPTI_TYPE_RAW_HASH;
7255 dgst_pos0 = 3;
7256 dgst_pos1 = 4;
7257 dgst_pos2 = 2;
7258 dgst_pos3 = 1;
7259 break;
7260
7261 case 130: hash_type = HASH_TYPE_SHA1;
7262 salt_type = SALT_TYPE_INTERN;
7263 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7264 opts_type = OPTS_TYPE_PT_GENERATE_BE
7265 | OPTS_TYPE_PT_UNICODE
7266 | OPTS_TYPE_ST_ADD80
7267 | OPTS_TYPE_ST_ADDBITS15;
7268 kern_type = KERN_TYPE_SHA1_PWUSLT;
7269 dgst_size = DGST_SIZE_4_5;
7270 parse_func = sha1s_parse_hash;
7271 sort_by_digest = sort_by_digest_4_5;
7272 opti_type = OPTI_TYPE_ZERO_BYTE
7273 | OPTI_TYPE_PRECOMPUTE_INIT
7274 | OPTI_TYPE_PRECOMPUTE_MERKLE
7275 | OPTI_TYPE_EARLY_SKIP
7276 | OPTI_TYPE_NOT_ITERATED
7277 | OPTI_TYPE_APPENDED_SALT
7278 | OPTI_TYPE_RAW_HASH;
7279 dgst_pos0 = 3;
7280 dgst_pos1 = 4;
7281 dgst_pos2 = 2;
7282 dgst_pos3 = 1;
7283 break;
7284
7285 case 131: hash_type = HASH_TYPE_SHA1;
7286 salt_type = SALT_TYPE_EMBEDDED;
7287 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7288 opts_type = OPTS_TYPE_PT_GENERATE_BE
7289 | OPTS_TYPE_PT_UNICODE
7290 | OPTS_TYPE_PT_UPPER
7291 | OPTS_TYPE_ST_ADD80
7292 | OPTS_TYPE_ST_ADDBITS15
7293 | OPTS_TYPE_ST_HEX;
7294 kern_type = KERN_TYPE_SHA1_PWUSLT;
7295 dgst_size = DGST_SIZE_4_5;
7296 parse_func = mssql2000_parse_hash;
7297 sort_by_digest = sort_by_digest_4_5;
7298 opti_type = OPTI_TYPE_ZERO_BYTE
7299 | OPTI_TYPE_PRECOMPUTE_INIT
7300 | OPTI_TYPE_PRECOMPUTE_MERKLE
7301 | OPTI_TYPE_EARLY_SKIP
7302 | OPTI_TYPE_NOT_ITERATED
7303 | OPTI_TYPE_APPENDED_SALT
7304 | OPTI_TYPE_RAW_HASH;
7305 dgst_pos0 = 3;
7306 dgst_pos1 = 4;
7307 dgst_pos2 = 2;
7308 dgst_pos3 = 1;
7309 break;
7310
7311 case 132: hash_type = HASH_TYPE_SHA1;
7312 salt_type = SALT_TYPE_EMBEDDED;
7313 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7314 opts_type = OPTS_TYPE_PT_GENERATE_BE
7315 | OPTS_TYPE_PT_UNICODE
7316 | OPTS_TYPE_ST_ADD80
7317 | OPTS_TYPE_ST_ADDBITS15
7318 | OPTS_TYPE_ST_HEX;
7319 kern_type = KERN_TYPE_SHA1_PWUSLT;
7320 dgst_size = DGST_SIZE_4_5;
7321 parse_func = mssql2005_parse_hash;
7322 sort_by_digest = sort_by_digest_4_5;
7323 opti_type = OPTI_TYPE_ZERO_BYTE
7324 | OPTI_TYPE_PRECOMPUTE_INIT
7325 | OPTI_TYPE_PRECOMPUTE_MERKLE
7326 | OPTI_TYPE_EARLY_SKIP
7327 | OPTI_TYPE_NOT_ITERATED
7328 | OPTI_TYPE_APPENDED_SALT
7329 | OPTI_TYPE_RAW_HASH;
7330 dgst_pos0 = 3;
7331 dgst_pos1 = 4;
7332 dgst_pos2 = 2;
7333 dgst_pos3 = 1;
7334 break;
7335
7336 case 133: hash_type = HASH_TYPE_SHA1;
7337 salt_type = SALT_TYPE_EMBEDDED;
7338 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7339 opts_type = OPTS_TYPE_PT_GENERATE_BE
7340 | OPTS_TYPE_PT_UNICODE
7341 | OPTS_TYPE_ST_ADD80
7342 | OPTS_TYPE_ST_ADDBITS15;
7343 kern_type = KERN_TYPE_SHA1_PWUSLT;
7344 dgst_size = DGST_SIZE_4_5;
7345 parse_func = peoplesoft_parse_hash;
7346 sort_by_digest = sort_by_digest_4_5;
7347 opti_type = OPTI_TYPE_ZERO_BYTE
7348 | OPTI_TYPE_PRECOMPUTE_INIT
7349 | OPTI_TYPE_PRECOMPUTE_MERKLE
7350 | OPTI_TYPE_EARLY_SKIP
7351 | OPTI_TYPE_NOT_ITERATED
7352 | OPTI_TYPE_APPENDED_SALT
7353 | OPTI_TYPE_RAW_HASH;
7354 dgst_pos0 = 3;
7355 dgst_pos1 = 4;
7356 dgst_pos2 = 2;
7357 dgst_pos3 = 1;
7358 break;
7359
7360 case 140: hash_type = HASH_TYPE_SHA1;
7361 salt_type = SALT_TYPE_INTERN;
7362 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7363 opts_type = OPTS_TYPE_PT_GENERATE_BE
7364 | OPTS_TYPE_PT_ADD80
7365 | OPTS_TYPE_PT_ADDBITS15
7366 | OPTS_TYPE_PT_UNICODE;
7367 kern_type = KERN_TYPE_SHA1_SLTPWU;
7368 dgst_size = DGST_SIZE_4_5;
7369 parse_func = sha1s_parse_hash;
7370 sort_by_digest = sort_by_digest_4_5;
7371 opti_type = OPTI_TYPE_ZERO_BYTE
7372 | OPTI_TYPE_PRECOMPUTE_INIT
7373 | OPTI_TYPE_PRECOMPUTE_MERKLE
7374 | OPTI_TYPE_EARLY_SKIP
7375 | OPTI_TYPE_NOT_ITERATED
7376 | OPTI_TYPE_PREPENDED_SALT
7377 | OPTI_TYPE_RAW_HASH;
7378 dgst_pos0 = 3;
7379 dgst_pos1 = 4;
7380 dgst_pos2 = 2;
7381 dgst_pos3 = 1;
7382 break;
7383
7384 case 141: hash_type = HASH_TYPE_SHA1;
7385 salt_type = SALT_TYPE_EMBEDDED;
7386 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7387 opts_type = OPTS_TYPE_PT_GENERATE_BE
7388 | OPTS_TYPE_PT_ADD80
7389 | OPTS_TYPE_PT_ADDBITS15
7390 | OPTS_TYPE_PT_UNICODE
7391 | OPTS_TYPE_ST_BASE64;
7392 kern_type = KERN_TYPE_SHA1_SLTPWU;
7393 dgst_size = DGST_SIZE_4_5;
7394 parse_func = episerver_parse_hash;
7395 sort_by_digest = sort_by_digest_4_5;
7396 opti_type = OPTI_TYPE_ZERO_BYTE
7397 | OPTI_TYPE_PRECOMPUTE_INIT
7398 | OPTI_TYPE_PRECOMPUTE_MERKLE
7399 | OPTI_TYPE_EARLY_SKIP
7400 | OPTI_TYPE_NOT_ITERATED
7401 | OPTI_TYPE_PREPENDED_SALT
7402 | OPTI_TYPE_RAW_HASH;
7403 dgst_pos0 = 3;
7404 dgst_pos1 = 4;
7405 dgst_pos2 = 2;
7406 dgst_pos3 = 1;
7407 break;
7408
7409 case 150: hash_type = HASH_TYPE_SHA1;
7410 salt_type = SALT_TYPE_INTERN;
7411 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7412 opts_type = OPTS_TYPE_PT_GENERATE_BE
7413 | OPTS_TYPE_ST_ADD80
7414 | OPTS_TYPE_ST_ADDBITS15;
7415 kern_type = KERN_TYPE_HMACSHA1_PW;
7416 dgst_size = DGST_SIZE_4_5;
7417 parse_func = hmacsha1_parse_hash;
7418 sort_by_digest = sort_by_digest_4_5;
7419 opti_type = OPTI_TYPE_ZERO_BYTE
7420 | OPTI_TYPE_NOT_ITERATED;
7421 dgst_pos0 = 3;
7422 dgst_pos1 = 4;
7423 dgst_pos2 = 2;
7424 dgst_pos3 = 1;
7425 break;
7426
7427 case 160: hash_type = HASH_TYPE_SHA1;
7428 salt_type = SALT_TYPE_INTERN;
7429 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7430 opts_type = OPTS_TYPE_PT_GENERATE_BE
7431 | OPTS_TYPE_PT_ADD80
7432 | OPTS_TYPE_PT_ADDBITS15;
7433 kern_type = KERN_TYPE_HMACSHA1_SLT;
7434 dgst_size = DGST_SIZE_4_5;
7435 parse_func = hmacsha1_parse_hash;
7436 sort_by_digest = sort_by_digest_4_5;
7437 opti_type = OPTI_TYPE_ZERO_BYTE
7438 | OPTI_TYPE_NOT_ITERATED;
7439 dgst_pos0 = 3;
7440 dgst_pos1 = 4;
7441 dgst_pos2 = 2;
7442 dgst_pos3 = 1;
7443 break;
7444
7445 case 190: hash_type = HASH_TYPE_SHA1;
7446 salt_type = SALT_TYPE_NONE;
7447 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7448 opts_type = OPTS_TYPE_PT_GENERATE_BE
7449 | OPTS_TYPE_PT_ADD80
7450 | OPTS_TYPE_PT_ADDBITS15;
7451 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7452 dgst_size = DGST_SIZE_4_5;
7453 parse_func = sha1linkedin_parse_hash;
7454 sort_by_digest = sort_by_digest_4_5;
7455 opti_type = OPTI_TYPE_ZERO_BYTE
7456 | OPTI_TYPE_PRECOMPUTE_INIT
7457 | OPTI_TYPE_EARLY_SKIP
7458 | OPTI_TYPE_NOT_ITERATED
7459 | OPTI_TYPE_NOT_SALTED;
7460 dgst_pos0 = 0;
7461 dgst_pos1 = 4;
7462 dgst_pos2 = 3;
7463 dgst_pos3 = 2;
7464 break;
7465
7466 case 200: hash_type = HASH_TYPE_MYSQL;
7467 salt_type = SALT_TYPE_NONE;
7468 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7469 opts_type = 0;
7470 kern_type = KERN_TYPE_MYSQL;
7471 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7472 parse_func = mysql323_parse_hash;
7473 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7474 opti_type = OPTI_TYPE_ZERO_BYTE;
7475 dgst_pos0 = 0;
7476 dgst_pos1 = 1;
7477 dgst_pos2 = 2;
7478 dgst_pos3 = 3;
7479 break;
7480
7481 case 300: hash_type = HASH_TYPE_SHA1;
7482 salt_type = SALT_TYPE_NONE;
7483 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7484 opts_type = OPTS_TYPE_PT_GENERATE_BE
7485 | OPTS_TYPE_PT_ADD80
7486 | OPTS_TYPE_PT_ADDBITS15;
7487 kern_type = KERN_TYPE_MYSQL41;
7488 dgst_size = DGST_SIZE_4_5;
7489 parse_func = sha1_parse_hash;
7490 sort_by_digest = sort_by_digest_4_5;
7491 opti_type = OPTI_TYPE_ZERO_BYTE
7492 | OPTI_TYPE_PRECOMPUTE_INIT
7493 | OPTI_TYPE_PRECOMPUTE_MERKLE
7494 | OPTI_TYPE_EARLY_SKIP
7495 | OPTI_TYPE_NOT_ITERATED
7496 | OPTI_TYPE_NOT_SALTED;
7497 dgst_pos0 = 3;
7498 dgst_pos1 = 4;
7499 dgst_pos2 = 2;
7500 dgst_pos3 = 1;
7501 break;
7502
7503 case 400: hash_type = HASH_TYPE_MD5;
7504 salt_type = SALT_TYPE_EMBEDDED;
7505 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7506 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7507 kern_type = KERN_TYPE_PHPASS;
7508 dgst_size = DGST_SIZE_4_4;
7509 parse_func = phpass_parse_hash;
7510 sort_by_digest = sort_by_digest_4_4;
7511 opti_type = OPTI_TYPE_ZERO_BYTE
7512 | OPTI_TYPE_SLOW_HASH_SIMD;
7513 dgst_pos0 = 0;
7514 dgst_pos1 = 1;
7515 dgst_pos2 = 2;
7516 dgst_pos3 = 3;
7517 break;
7518
7519 case 500: hash_type = HASH_TYPE_MD5;
7520 salt_type = SALT_TYPE_EMBEDDED;
7521 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7522 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7523 kern_type = KERN_TYPE_MD5CRYPT;
7524 dgst_size = DGST_SIZE_4_4;
7525 parse_func = md5crypt_parse_hash;
7526 sort_by_digest = sort_by_digest_4_4;
7527 opti_type = OPTI_TYPE_ZERO_BYTE;
7528 dgst_pos0 = 0;
7529 dgst_pos1 = 1;
7530 dgst_pos2 = 2;
7531 dgst_pos3 = 3;
7532 break;
7533
7534 case 501: hash_type = HASH_TYPE_MD5;
7535 salt_type = SALT_TYPE_EMBEDDED;
7536 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7537 opts_type = OPTS_TYPE_PT_GENERATE_LE
7538 | OPTS_TYPE_HASH_COPY;
7539 kern_type = KERN_TYPE_MD5CRYPT;
7540 dgst_size = DGST_SIZE_4_4;
7541 parse_func = juniper_parse_hash;
7542 sort_by_digest = sort_by_digest_4_4;
7543 opti_type = OPTI_TYPE_ZERO_BYTE;
7544 dgst_pos0 = 0;
7545 dgst_pos1 = 1;
7546 dgst_pos2 = 2;
7547 dgst_pos3 = 3;
7548 break;
7549
7550 case 900: hash_type = HASH_TYPE_MD4;
7551 salt_type = SALT_TYPE_NONE;
7552 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7553 opts_type = OPTS_TYPE_PT_GENERATE_LE
7554 | OPTS_TYPE_PT_ADD80
7555 | OPTS_TYPE_PT_ADDBITS14;
7556 kern_type = KERN_TYPE_MD4;
7557 dgst_size = DGST_SIZE_4_4;
7558 parse_func = md4_parse_hash;
7559 sort_by_digest = sort_by_digest_4_4;
7560 opti_type = OPTI_TYPE_ZERO_BYTE
7561 | OPTI_TYPE_PRECOMPUTE_INIT
7562 | OPTI_TYPE_PRECOMPUTE_MERKLE
7563 | OPTI_TYPE_MEET_IN_MIDDLE
7564 | OPTI_TYPE_EARLY_SKIP
7565 | OPTI_TYPE_NOT_ITERATED
7566 | OPTI_TYPE_NOT_SALTED
7567 | OPTI_TYPE_RAW_HASH;
7568 dgst_pos0 = 0;
7569 dgst_pos1 = 3;
7570 dgst_pos2 = 2;
7571 dgst_pos3 = 1;
7572 break;
7573
7574 case 1000: hash_type = HASH_TYPE_MD4;
7575 salt_type = SALT_TYPE_NONE;
7576 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7577 opts_type = OPTS_TYPE_PT_GENERATE_LE
7578 | OPTS_TYPE_PT_ADD80
7579 | OPTS_TYPE_PT_ADDBITS14
7580 | OPTS_TYPE_PT_UNICODE;
7581 kern_type = KERN_TYPE_MD4_PWU;
7582 dgst_size = DGST_SIZE_4_4;
7583 parse_func = md4_parse_hash;
7584 sort_by_digest = sort_by_digest_4_4;
7585 opti_type = OPTI_TYPE_ZERO_BYTE
7586 | OPTI_TYPE_PRECOMPUTE_INIT
7587 | OPTI_TYPE_PRECOMPUTE_MERKLE
7588 | OPTI_TYPE_MEET_IN_MIDDLE
7589 | OPTI_TYPE_EARLY_SKIP
7590 | OPTI_TYPE_NOT_ITERATED
7591 | OPTI_TYPE_NOT_SALTED
7592 | OPTI_TYPE_RAW_HASH;
7593 dgst_pos0 = 0;
7594 dgst_pos1 = 3;
7595 dgst_pos2 = 2;
7596 dgst_pos3 = 1;
7597 break;
7598
7599 case 1100: hash_type = HASH_TYPE_MD4;
7600 salt_type = SALT_TYPE_INTERN;
7601 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7602 opts_type = OPTS_TYPE_PT_GENERATE_LE
7603 | OPTS_TYPE_PT_ADD80
7604 | OPTS_TYPE_PT_ADDBITS14
7605 | OPTS_TYPE_PT_UNICODE
7606 | OPTS_TYPE_ST_ADD80
7607 | OPTS_TYPE_ST_UNICODE
7608 | OPTS_TYPE_ST_LOWER;
7609 kern_type = KERN_TYPE_MD44_PWUSLT;
7610 dgst_size = DGST_SIZE_4_4;
7611 parse_func = dcc_parse_hash;
7612 sort_by_digest = sort_by_digest_4_4;
7613 opti_type = OPTI_TYPE_ZERO_BYTE
7614 | OPTI_TYPE_PRECOMPUTE_INIT
7615 | OPTI_TYPE_PRECOMPUTE_MERKLE
7616 | OPTI_TYPE_EARLY_SKIP
7617 | OPTI_TYPE_NOT_ITERATED;
7618 dgst_pos0 = 0;
7619 dgst_pos1 = 3;
7620 dgst_pos2 = 2;
7621 dgst_pos3 = 1;
7622 break;
7623
7624 case 1400: hash_type = HASH_TYPE_SHA256;
7625 salt_type = SALT_TYPE_NONE;
7626 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7627 opts_type = OPTS_TYPE_PT_GENERATE_BE
7628 | OPTS_TYPE_PT_ADD80
7629 | OPTS_TYPE_PT_ADDBITS15;
7630 kern_type = KERN_TYPE_SHA256;
7631 dgst_size = DGST_SIZE_4_8;
7632 parse_func = sha256_parse_hash;
7633 sort_by_digest = sort_by_digest_4_8;
7634 opti_type = OPTI_TYPE_ZERO_BYTE
7635 | OPTI_TYPE_PRECOMPUTE_INIT
7636 | OPTI_TYPE_PRECOMPUTE_MERKLE
7637 | OPTI_TYPE_EARLY_SKIP
7638 | OPTI_TYPE_NOT_ITERATED
7639 | OPTI_TYPE_NOT_SALTED
7640 | OPTI_TYPE_RAW_HASH;
7641 dgst_pos0 = 3;
7642 dgst_pos1 = 7;
7643 dgst_pos2 = 2;
7644 dgst_pos3 = 6;
7645 break;
7646
7647 case 1410: hash_type = HASH_TYPE_SHA256;
7648 salt_type = SALT_TYPE_INTERN;
7649 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7650 opts_type = OPTS_TYPE_PT_GENERATE_BE
7651 | OPTS_TYPE_ST_ADD80
7652 | OPTS_TYPE_ST_ADDBITS15;
7653 kern_type = KERN_TYPE_SHA256_PWSLT;
7654 dgst_size = DGST_SIZE_4_8;
7655 parse_func = sha256s_parse_hash;
7656 sort_by_digest = sort_by_digest_4_8;
7657 opti_type = OPTI_TYPE_ZERO_BYTE
7658 | OPTI_TYPE_PRECOMPUTE_INIT
7659 | OPTI_TYPE_PRECOMPUTE_MERKLE
7660 | OPTI_TYPE_EARLY_SKIP
7661 | OPTI_TYPE_NOT_ITERATED
7662 | OPTI_TYPE_APPENDED_SALT
7663 | OPTI_TYPE_RAW_HASH;
7664 dgst_pos0 = 3;
7665 dgst_pos1 = 7;
7666 dgst_pos2 = 2;
7667 dgst_pos3 = 6;
7668 break;
7669
7670 case 1420: hash_type = HASH_TYPE_SHA256;
7671 salt_type = SALT_TYPE_INTERN;
7672 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7673 opts_type = OPTS_TYPE_PT_GENERATE_BE
7674 | OPTS_TYPE_PT_ADD80
7675 | OPTS_TYPE_PT_ADDBITS15;
7676 kern_type = KERN_TYPE_SHA256_SLTPW;
7677 dgst_size = DGST_SIZE_4_8;
7678 parse_func = sha256s_parse_hash;
7679 sort_by_digest = sort_by_digest_4_8;
7680 opti_type = OPTI_TYPE_ZERO_BYTE
7681 | OPTI_TYPE_PRECOMPUTE_INIT
7682 | OPTI_TYPE_PRECOMPUTE_MERKLE
7683 | OPTI_TYPE_EARLY_SKIP
7684 | OPTI_TYPE_NOT_ITERATED
7685 | OPTI_TYPE_PREPENDED_SALT
7686 | OPTI_TYPE_RAW_HASH;
7687 dgst_pos0 = 3;
7688 dgst_pos1 = 7;
7689 dgst_pos2 = 2;
7690 dgst_pos3 = 6;
7691 break;
7692
7693 case 1421: hash_type = HASH_TYPE_SHA256;
7694 salt_type = SALT_TYPE_EMBEDDED;
7695 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7696 opts_type = OPTS_TYPE_PT_GENERATE_BE
7697 | OPTS_TYPE_PT_ADD80
7698 | OPTS_TYPE_PT_ADDBITS15;
7699 kern_type = KERN_TYPE_SHA256_SLTPW;
7700 dgst_size = DGST_SIZE_4_8;
7701 parse_func = hmailserver_parse_hash;
7702 sort_by_digest = sort_by_digest_4_8;
7703 opti_type = OPTI_TYPE_ZERO_BYTE
7704 | OPTI_TYPE_PRECOMPUTE_INIT
7705 | OPTI_TYPE_PRECOMPUTE_MERKLE
7706 | OPTI_TYPE_EARLY_SKIP
7707 | OPTI_TYPE_NOT_ITERATED
7708 | OPTI_TYPE_PREPENDED_SALT
7709 | OPTI_TYPE_RAW_HASH;
7710 dgst_pos0 = 3;
7711 dgst_pos1 = 7;
7712 dgst_pos2 = 2;
7713 dgst_pos3 = 6;
7714 break;
7715
7716 case 1430: hash_type = HASH_TYPE_SHA256;
7717 salt_type = SALT_TYPE_INTERN;
7718 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7719 opts_type = OPTS_TYPE_PT_GENERATE_BE
7720 | OPTS_TYPE_PT_UNICODE
7721 | OPTS_TYPE_ST_ADD80
7722 | OPTS_TYPE_ST_ADDBITS15;
7723 kern_type = KERN_TYPE_SHA256_PWUSLT;
7724 dgst_size = DGST_SIZE_4_8;
7725 parse_func = sha256s_parse_hash;
7726 sort_by_digest = sort_by_digest_4_8;
7727 opti_type = OPTI_TYPE_ZERO_BYTE
7728 | OPTI_TYPE_PRECOMPUTE_INIT
7729 | OPTI_TYPE_PRECOMPUTE_MERKLE
7730 | OPTI_TYPE_EARLY_SKIP
7731 | OPTI_TYPE_NOT_ITERATED
7732 | OPTI_TYPE_APPENDED_SALT
7733 | OPTI_TYPE_RAW_HASH;
7734 dgst_pos0 = 3;
7735 dgst_pos1 = 7;
7736 dgst_pos2 = 2;
7737 dgst_pos3 = 6;
7738 break;
7739
7740 case 1440: hash_type = HASH_TYPE_SHA256;
7741 salt_type = SALT_TYPE_INTERN;
7742 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7743 opts_type = OPTS_TYPE_PT_GENERATE_BE
7744 | OPTS_TYPE_PT_ADD80
7745 | OPTS_TYPE_PT_ADDBITS15
7746 | OPTS_TYPE_PT_UNICODE;
7747 kern_type = KERN_TYPE_SHA256_SLTPWU;
7748 dgst_size = DGST_SIZE_4_8;
7749 parse_func = sha256s_parse_hash;
7750 sort_by_digest = sort_by_digest_4_8;
7751 opti_type = OPTI_TYPE_ZERO_BYTE
7752 | OPTI_TYPE_PRECOMPUTE_INIT
7753 | OPTI_TYPE_PRECOMPUTE_MERKLE
7754 | OPTI_TYPE_EARLY_SKIP
7755 | OPTI_TYPE_NOT_ITERATED
7756 | OPTI_TYPE_PREPENDED_SALT
7757 | OPTI_TYPE_RAW_HASH;
7758 dgst_pos0 = 3;
7759 dgst_pos1 = 7;
7760 dgst_pos2 = 2;
7761 dgst_pos3 = 6;
7762 break;
7763
7764 case 1441: hash_type = HASH_TYPE_SHA256;
7765 salt_type = SALT_TYPE_EMBEDDED;
7766 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7767 opts_type = OPTS_TYPE_PT_GENERATE_BE
7768 | OPTS_TYPE_PT_ADD80
7769 | OPTS_TYPE_PT_ADDBITS15
7770 | OPTS_TYPE_PT_UNICODE
7771 | OPTS_TYPE_ST_BASE64;
7772 kern_type = KERN_TYPE_SHA256_SLTPWU;
7773 dgst_size = DGST_SIZE_4_8;
7774 parse_func = episerver4_parse_hash;
7775 sort_by_digest = sort_by_digest_4_8;
7776 opti_type = OPTI_TYPE_ZERO_BYTE
7777 | OPTI_TYPE_PRECOMPUTE_INIT
7778 | OPTI_TYPE_PRECOMPUTE_MERKLE
7779 | OPTI_TYPE_EARLY_SKIP
7780 | OPTI_TYPE_NOT_ITERATED
7781 | OPTI_TYPE_PREPENDED_SALT
7782 | OPTI_TYPE_RAW_HASH;
7783 dgst_pos0 = 3;
7784 dgst_pos1 = 7;
7785 dgst_pos2 = 2;
7786 dgst_pos3 = 6;
7787 break;
7788
7789 case 1450: hash_type = HASH_TYPE_SHA256;
7790 salt_type = SALT_TYPE_INTERN;
7791 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7792 opts_type = OPTS_TYPE_PT_GENERATE_BE
7793 | OPTS_TYPE_ST_ADD80;
7794 kern_type = KERN_TYPE_HMACSHA256_PW;
7795 dgst_size = DGST_SIZE_4_8;
7796 parse_func = hmacsha256_parse_hash;
7797 sort_by_digest = sort_by_digest_4_8;
7798 opti_type = OPTI_TYPE_ZERO_BYTE
7799 | OPTI_TYPE_NOT_ITERATED;
7800 dgst_pos0 = 3;
7801 dgst_pos1 = 7;
7802 dgst_pos2 = 2;
7803 dgst_pos3 = 6;
7804 break;
7805
7806 case 1460: hash_type = HASH_TYPE_SHA256;
7807 salt_type = SALT_TYPE_INTERN;
7808 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7809 opts_type = OPTS_TYPE_PT_GENERATE_BE
7810 | OPTS_TYPE_PT_ADD80
7811 | OPTS_TYPE_PT_ADDBITS15;
7812 kern_type = KERN_TYPE_HMACSHA256_SLT;
7813 dgst_size = DGST_SIZE_4_8;
7814 parse_func = hmacsha256_parse_hash;
7815 sort_by_digest = sort_by_digest_4_8;
7816 opti_type = OPTI_TYPE_ZERO_BYTE
7817 | OPTI_TYPE_NOT_ITERATED;
7818 dgst_pos0 = 3;
7819 dgst_pos1 = 7;
7820 dgst_pos2 = 2;
7821 dgst_pos3 = 6;
7822 break;
7823
7824 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7825 salt_type = SALT_TYPE_EMBEDDED;
7826 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7827 opts_type = OPTS_TYPE_PT_GENERATE_LE
7828 | OPTS_TYPE_PT_BITSLICE;
7829 kern_type = KERN_TYPE_DESCRYPT;
7830 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7831 parse_func = descrypt_parse_hash;
7832 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7833 opti_type = OPTI_TYPE_ZERO_BYTE
7834 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7835 dgst_pos0 = 0;
7836 dgst_pos1 = 1;
7837 dgst_pos2 = 2;
7838 dgst_pos3 = 3;
7839 break;
7840
7841 case 1600: hash_type = HASH_TYPE_MD5;
7842 salt_type = SALT_TYPE_EMBEDDED;
7843 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7844 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7845 kern_type = KERN_TYPE_APR1CRYPT;
7846 dgst_size = DGST_SIZE_4_4;
7847 parse_func = md5apr1_parse_hash;
7848 sort_by_digest = sort_by_digest_4_4;
7849 opti_type = OPTI_TYPE_ZERO_BYTE;
7850 dgst_pos0 = 0;
7851 dgst_pos1 = 1;
7852 dgst_pos2 = 2;
7853 dgst_pos3 = 3;
7854 break;
7855
7856 case 1700: hash_type = HASH_TYPE_SHA512;
7857 salt_type = SALT_TYPE_NONE;
7858 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7859 opts_type = OPTS_TYPE_PT_GENERATE_BE
7860 | OPTS_TYPE_PT_ADD80
7861 | OPTS_TYPE_PT_ADDBITS15;
7862 kern_type = KERN_TYPE_SHA512;
7863 dgst_size = DGST_SIZE_8_8;
7864 parse_func = sha512_parse_hash;
7865 sort_by_digest = sort_by_digest_8_8;
7866 opti_type = OPTI_TYPE_ZERO_BYTE
7867 | OPTI_TYPE_PRECOMPUTE_INIT
7868 | OPTI_TYPE_PRECOMPUTE_MERKLE
7869 | OPTI_TYPE_EARLY_SKIP
7870 | OPTI_TYPE_NOT_ITERATED
7871 | OPTI_TYPE_NOT_SALTED
7872 | OPTI_TYPE_USES_BITS_64
7873 | OPTI_TYPE_RAW_HASH;
7874 dgst_pos0 = 14;
7875 dgst_pos1 = 15;
7876 dgst_pos2 = 6;
7877 dgst_pos3 = 7;
7878 break;
7879
7880 case 1710: hash_type = HASH_TYPE_SHA512;
7881 salt_type = SALT_TYPE_INTERN;
7882 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7883 opts_type = OPTS_TYPE_PT_GENERATE_BE
7884 | OPTS_TYPE_ST_ADD80
7885 | OPTS_TYPE_ST_ADDBITS15;
7886 kern_type = KERN_TYPE_SHA512_PWSLT;
7887 dgst_size = DGST_SIZE_8_8;
7888 parse_func = sha512s_parse_hash;
7889 sort_by_digest = sort_by_digest_8_8;
7890 opti_type = OPTI_TYPE_ZERO_BYTE
7891 | OPTI_TYPE_PRECOMPUTE_INIT
7892 | OPTI_TYPE_PRECOMPUTE_MERKLE
7893 | OPTI_TYPE_EARLY_SKIP
7894 | OPTI_TYPE_NOT_ITERATED
7895 | OPTI_TYPE_APPENDED_SALT
7896 | OPTI_TYPE_USES_BITS_64
7897 | OPTI_TYPE_RAW_HASH;
7898 dgst_pos0 = 14;
7899 dgst_pos1 = 15;
7900 dgst_pos2 = 6;
7901 dgst_pos3 = 7;
7902 break;
7903
7904 case 1711: hash_type = HASH_TYPE_SHA512;
7905 salt_type = SALT_TYPE_EMBEDDED;
7906 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7907 opts_type = OPTS_TYPE_PT_GENERATE_BE
7908 | OPTS_TYPE_ST_ADD80
7909 | OPTS_TYPE_ST_ADDBITS15;
7910 kern_type = KERN_TYPE_SHA512_PWSLT;
7911 dgst_size = DGST_SIZE_8_8;
7912 parse_func = sha512b64s_parse_hash;
7913 sort_by_digest = sort_by_digest_8_8;
7914 opti_type = OPTI_TYPE_ZERO_BYTE
7915 | OPTI_TYPE_PRECOMPUTE_INIT
7916 | OPTI_TYPE_PRECOMPUTE_MERKLE
7917 | OPTI_TYPE_EARLY_SKIP
7918 | OPTI_TYPE_NOT_ITERATED
7919 | OPTI_TYPE_APPENDED_SALT
7920 | OPTI_TYPE_USES_BITS_64
7921 | OPTI_TYPE_RAW_HASH;
7922 dgst_pos0 = 14;
7923 dgst_pos1 = 15;
7924 dgst_pos2 = 6;
7925 dgst_pos3 = 7;
7926 break;
7927
7928 case 1720: hash_type = HASH_TYPE_SHA512;
7929 salt_type = SALT_TYPE_INTERN;
7930 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7931 opts_type = OPTS_TYPE_PT_GENERATE_BE
7932 | OPTS_TYPE_PT_ADD80
7933 | OPTS_TYPE_PT_ADDBITS15;
7934 kern_type = KERN_TYPE_SHA512_SLTPW;
7935 dgst_size = DGST_SIZE_8_8;
7936 parse_func = sha512s_parse_hash;
7937 sort_by_digest = sort_by_digest_8_8;
7938 opti_type = OPTI_TYPE_ZERO_BYTE
7939 | OPTI_TYPE_PRECOMPUTE_INIT
7940 | OPTI_TYPE_PRECOMPUTE_MERKLE
7941 | OPTI_TYPE_EARLY_SKIP
7942 | OPTI_TYPE_NOT_ITERATED
7943 | OPTI_TYPE_PREPENDED_SALT
7944 | OPTI_TYPE_USES_BITS_64
7945 | OPTI_TYPE_RAW_HASH;
7946 dgst_pos0 = 14;
7947 dgst_pos1 = 15;
7948 dgst_pos2 = 6;
7949 dgst_pos3 = 7;
7950 break;
7951
7952 case 1722: hash_type = HASH_TYPE_SHA512;
7953 salt_type = SALT_TYPE_EMBEDDED;
7954 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7955 opts_type = OPTS_TYPE_PT_GENERATE_BE
7956 | OPTS_TYPE_PT_ADD80
7957 | OPTS_TYPE_PT_ADDBITS15
7958 | OPTS_TYPE_ST_HEX;
7959 kern_type = KERN_TYPE_SHA512_SLTPW;
7960 dgst_size = DGST_SIZE_8_8;
7961 parse_func = osx512_parse_hash;
7962 sort_by_digest = sort_by_digest_8_8;
7963 opti_type = OPTI_TYPE_ZERO_BYTE
7964 | OPTI_TYPE_PRECOMPUTE_INIT
7965 | OPTI_TYPE_PRECOMPUTE_MERKLE
7966 | OPTI_TYPE_EARLY_SKIP
7967 | OPTI_TYPE_NOT_ITERATED
7968 | OPTI_TYPE_PREPENDED_SALT
7969 | OPTI_TYPE_USES_BITS_64
7970 | OPTI_TYPE_RAW_HASH;
7971 dgst_pos0 = 14;
7972 dgst_pos1 = 15;
7973 dgst_pos2 = 6;
7974 dgst_pos3 = 7;
7975 break;
7976
7977 case 1730: hash_type = HASH_TYPE_SHA512;
7978 salt_type = SALT_TYPE_INTERN;
7979 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7980 opts_type = OPTS_TYPE_PT_GENERATE_BE
7981 | OPTS_TYPE_PT_UNICODE
7982 | OPTS_TYPE_ST_ADD80
7983 | OPTS_TYPE_ST_ADDBITS15;
7984 kern_type = KERN_TYPE_SHA512_PWSLTU;
7985 dgst_size = DGST_SIZE_8_8;
7986 parse_func = sha512s_parse_hash;
7987 sort_by_digest = sort_by_digest_8_8;
7988 opti_type = OPTI_TYPE_ZERO_BYTE
7989 | OPTI_TYPE_PRECOMPUTE_INIT
7990 | OPTI_TYPE_PRECOMPUTE_MERKLE
7991 | OPTI_TYPE_EARLY_SKIP
7992 | OPTI_TYPE_NOT_ITERATED
7993 | OPTI_TYPE_APPENDED_SALT
7994 | OPTI_TYPE_USES_BITS_64
7995 | OPTI_TYPE_RAW_HASH;
7996 dgst_pos0 = 14;
7997 dgst_pos1 = 15;
7998 dgst_pos2 = 6;
7999 dgst_pos3 = 7;
8000 break;
8001
8002 case 1731: hash_type = HASH_TYPE_SHA512;
8003 salt_type = SALT_TYPE_EMBEDDED;
8004 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8005 opts_type = OPTS_TYPE_PT_GENERATE_BE
8006 | OPTS_TYPE_PT_UNICODE
8007 | OPTS_TYPE_ST_ADD80
8008 | OPTS_TYPE_ST_ADDBITS15
8009 | OPTS_TYPE_ST_HEX;
8010 kern_type = KERN_TYPE_SHA512_PWSLTU;
8011 dgst_size = DGST_SIZE_8_8;
8012 parse_func = mssql2012_parse_hash;
8013 sort_by_digest = sort_by_digest_8_8;
8014 opti_type = OPTI_TYPE_ZERO_BYTE
8015 | OPTI_TYPE_PRECOMPUTE_INIT
8016 | OPTI_TYPE_PRECOMPUTE_MERKLE
8017 | OPTI_TYPE_EARLY_SKIP
8018 | OPTI_TYPE_NOT_ITERATED
8019 | OPTI_TYPE_APPENDED_SALT
8020 | OPTI_TYPE_USES_BITS_64
8021 | OPTI_TYPE_RAW_HASH;
8022 dgst_pos0 = 14;
8023 dgst_pos1 = 15;
8024 dgst_pos2 = 6;
8025 dgst_pos3 = 7;
8026 break;
8027
8028 case 1740: hash_type = HASH_TYPE_SHA512;
8029 salt_type = SALT_TYPE_INTERN;
8030 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8031 opts_type = OPTS_TYPE_PT_GENERATE_BE
8032 | OPTS_TYPE_PT_ADD80
8033 | OPTS_TYPE_PT_ADDBITS15
8034 | OPTS_TYPE_PT_UNICODE;
8035 kern_type = KERN_TYPE_SHA512_SLTPWU;
8036 dgst_size = DGST_SIZE_8_8;
8037 parse_func = sha512s_parse_hash;
8038 sort_by_digest = sort_by_digest_8_8;
8039 opti_type = OPTI_TYPE_ZERO_BYTE
8040 | OPTI_TYPE_PRECOMPUTE_INIT
8041 | OPTI_TYPE_PRECOMPUTE_MERKLE
8042 | OPTI_TYPE_EARLY_SKIP
8043 | OPTI_TYPE_NOT_ITERATED
8044 | OPTI_TYPE_PREPENDED_SALT
8045 | OPTI_TYPE_USES_BITS_64
8046 | OPTI_TYPE_RAW_HASH;
8047 dgst_pos0 = 14;
8048 dgst_pos1 = 15;
8049 dgst_pos2 = 6;
8050 dgst_pos3 = 7;
8051 break;
8052
8053 case 1750: hash_type = HASH_TYPE_SHA512;
8054 salt_type = SALT_TYPE_INTERN;
8055 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8056 opts_type = OPTS_TYPE_PT_GENERATE_BE
8057 | OPTS_TYPE_ST_ADD80;
8058 kern_type = KERN_TYPE_HMACSHA512_PW;
8059 dgst_size = DGST_SIZE_8_8;
8060 parse_func = hmacsha512_parse_hash;
8061 sort_by_digest = sort_by_digest_8_8;
8062 opti_type = OPTI_TYPE_ZERO_BYTE
8063 | OPTI_TYPE_USES_BITS_64
8064 | OPTI_TYPE_NOT_ITERATED;
8065 dgst_pos0 = 14;
8066 dgst_pos1 = 15;
8067 dgst_pos2 = 6;
8068 dgst_pos3 = 7;
8069 break;
8070
8071 case 1760: hash_type = HASH_TYPE_SHA512;
8072 salt_type = SALT_TYPE_INTERN;
8073 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8074 opts_type = OPTS_TYPE_PT_GENERATE_BE
8075 | OPTS_TYPE_PT_ADD80
8076 | OPTS_TYPE_PT_ADDBITS15;
8077 kern_type = KERN_TYPE_HMACSHA512_SLT;
8078 dgst_size = DGST_SIZE_8_8;
8079 parse_func = hmacsha512_parse_hash;
8080 sort_by_digest = sort_by_digest_8_8;
8081 opti_type = OPTI_TYPE_ZERO_BYTE
8082 | OPTI_TYPE_USES_BITS_64
8083 | OPTI_TYPE_NOT_ITERATED;
8084 dgst_pos0 = 14;
8085 dgst_pos1 = 15;
8086 dgst_pos2 = 6;
8087 dgst_pos3 = 7;
8088 break;
8089
8090 case 1800: hash_type = HASH_TYPE_SHA512;
8091 salt_type = SALT_TYPE_EMBEDDED;
8092 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8093 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8094 kern_type = KERN_TYPE_SHA512CRYPT;
8095 dgst_size = DGST_SIZE_8_8;
8096 parse_func = sha512crypt_parse_hash;
8097 sort_by_digest = sort_by_digest_8_8;
8098 opti_type = OPTI_TYPE_ZERO_BYTE
8099 | OPTI_TYPE_USES_BITS_64;
8100 dgst_pos0 = 0;
8101 dgst_pos1 = 1;
8102 dgst_pos2 = 2;
8103 dgst_pos3 = 3;
8104 break;
8105
8106 case 2100: hash_type = HASH_TYPE_DCC2;
8107 salt_type = SALT_TYPE_EMBEDDED;
8108 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8109 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8110 | OPTS_TYPE_ST_LOWER
8111 | OPTS_TYPE_ST_UNICODE;
8112 kern_type = KERN_TYPE_DCC2;
8113 dgst_size = DGST_SIZE_4_4;
8114 parse_func = dcc2_parse_hash;
8115 sort_by_digest = sort_by_digest_4_4;
8116 opti_type = OPTI_TYPE_ZERO_BYTE
8117 | OPTI_TYPE_SLOW_HASH_SIMD;
8118 dgst_pos0 = 0;
8119 dgst_pos1 = 1;
8120 dgst_pos2 = 2;
8121 dgst_pos3 = 3;
8122 break;
8123
8124 case 2400: hash_type = HASH_TYPE_MD5;
8125 salt_type = SALT_TYPE_NONE;
8126 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8127 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8128 kern_type = KERN_TYPE_MD5PIX;
8129 dgst_size = DGST_SIZE_4_4;
8130 parse_func = md5pix_parse_hash;
8131 sort_by_digest = sort_by_digest_4_4;
8132 opti_type = OPTI_TYPE_ZERO_BYTE
8133 | OPTI_TYPE_PRECOMPUTE_INIT
8134 | OPTI_TYPE_PRECOMPUTE_MERKLE
8135 | OPTI_TYPE_EARLY_SKIP
8136 | OPTI_TYPE_NOT_ITERATED
8137 | OPTI_TYPE_NOT_SALTED;
8138 dgst_pos0 = 0;
8139 dgst_pos1 = 3;
8140 dgst_pos2 = 2;
8141 dgst_pos3 = 1;
8142 break;
8143
8144 case 2410: hash_type = HASH_TYPE_MD5;
8145 salt_type = SALT_TYPE_INTERN;
8146 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8147 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8148 kern_type = KERN_TYPE_MD5ASA;
8149 dgst_size = DGST_SIZE_4_4;
8150 parse_func = md5asa_parse_hash;
8151 sort_by_digest = sort_by_digest_4_4;
8152 opti_type = OPTI_TYPE_ZERO_BYTE
8153 | OPTI_TYPE_PRECOMPUTE_INIT
8154 | OPTI_TYPE_PRECOMPUTE_MERKLE
8155 | OPTI_TYPE_EARLY_SKIP
8156 | OPTI_TYPE_NOT_ITERATED;
8157 dgst_pos0 = 0;
8158 dgst_pos1 = 3;
8159 dgst_pos2 = 2;
8160 dgst_pos3 = 1;
8161 break;
8162
8163 case 2500: hash_type = HASH_TYPE_WPA;
8164 salt_type = SALT_TYPE_EMBEDDED;
8165 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8166 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8167 kern_type = KERN_TYPE_WPA;
8168 dgst_size = DGST_SIZE_4_4;
8169 parse_func = wpa_parse_hash;
8170 sort_by_digest = sort_by_digest_4_4;
8171 opti_type = OPTI_TYPE_ZERO_BYTE
8172 | OPTI_TYPE_SLOW_HASH_SIMD;
8173 dgst_pos0 = 0;
8174 dgst_pos1 = 1;
8175 dgst_pos2 = 2;
8176 dgst_pos3 = 3;
8177 break;
8178
8179 case 2600: hash_type = HASH_TYPE_MD5;
8180 salt_type = SALT_TYPE_VIRTUAL;
8181 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8182 opts_type = OPTS_TYPE_PT_GENERATE_LE
8183 | OPTS_TYPE_PT_ADD80
8184 | OPTS_TYPE_PT_ADDBITS14
8185 | OPTS_TYPE_ST_ADD80;
8186 kern_type = KERN_TYPE_MD55_PWSLT1;
8187 dgst_size = DGST_SIZE_4_4;
8188 parse_func = md5md5_parse_hash;
8189 sort_by_digest = sort_by_digest_4_4;
8190 opti_type = OPTI_TYPE_ZERO_BYTE
8191 | OPTI_TYPE_PRECOMPUTE_INIT
8192 | OPTI_TYPE_PRECOMPUTE_MERKLE
8193 | OPTI_TYPE_EARLY_SKIP;
8194 dgst_pos0 = 0;
8195 dgst_pos1 = 3;
8196 dgst_pos2 = 2;
8197 dgst_pos3 = 1;
8198 break;
8199
8200 case 2611: hash_type = HASH_TYPE_MD5;
8201 salt_type = SALT_TYPE_INTERN;
8202 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8203 opts_type = OPTS_TYPE_PT_GENERATE_LE
8204 | OPTS_TYPE_PT_ADD80
8205 | OPTS_TYPE_PT_ADDBITS14
8206 | OPTS_TYPE_ST_ADD80;
8207 kern_type = KERN_TYPE_MD55_PWSLT1;
8208 dgst_size = DGST_SIZE_4_4;
8209 parse_func = vb3_parse_hash;
8210 sort_by_digest = sort_by_digest_4_4;
8211 opti_type = OPTI_TYPE_ZERO_BYTE
8212 | OPTI_TYPE_PRECOMPUTE_INIT
8213 | OPTI_TYPE_PRECOMPUTE_MERKLE
8214 | OPTI_TYPE_EARLY_SKIP;
8215 dgst_pos0 = 0;
8216 dgst_pos1 = 3;
8217 dgst_pos2 = 2;
8218 dgst_pos3 = 1;
8219 break;
8220
8221 case 2612: hash_type = HASH_TYPE_MD5;
8222 salt_type = SALT_TYPE_EMBEDDED;
8223 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8224 opts_type = OPTS_TYPE_PT_GENERATE_LE
8225 | OPTS_TYPE_PT_ADD80
8226 | OPTS_TYPE_PT_ADDBITS14
8227 | OPTS_TYPE_ST_ADD80
8228 | OPTS_TYPE_ST_HEX;
8229 kern_type = KERN_TYPE_MD55_PWSLT1;
8230 dgst_size = DGST_SIZE_4_4;
8231 parse_func = phps_parse_hash;
8232 sort_by_digest = sort_by_digest_4_4;
8233 opti_type = OPTI_TYPE_ZERO_BYTE
8234 | OPTI_TYPE_PRECOMPUTE_INIT
8235 | OPTI_TYPE_PRECOMPUTE_MERKLE
8236 | OPTI_TYPE_EARLY_SKIP;
8237 dgst_pos0 = 0;
8238 dgst_pos1 = 3;
8239 dgst_pos2 = 2;
8240 dgst_pos3 = 1;
8241 break;
8242
8243 case 2711: hash_type = HASH_TYPE_MD5;
8244 salt_type = SALT_TYPE_INTERN;
8245 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8246 opts_type = OPTS_TYPE_PT_GENERATE_LE
8247 | OPTS_TYPE_PT_ADD80
8248 | OPTS_TYPE_PT_ADDBITS14
8249 | OPTS_TYPE_ST_ADD80;
8250 kern_type = KERN_TYPE_MD55_PWSLT2;
8251 dgst_size = DGST_SIZE_4_4;
8252 parse_func = vb30_parse_hash;
8253 sort_by_digest = sort_by_digest_4_4;
8254 opti_type = OPTI_TYPE_ZERO_BYTE
8255 | OPTI_TYPE_PRECOMPUTE_INIT
8256 | OPTI_TYPE_EARLY_SKIP;
8257 dgst_pos0 = 0;
8258 dgst_pos1 = 3;
8259 dgst_pos2 = 2;
8260 dgst_pos3 = 1;
8261 break;
8262
8263 case 2811: hash_type = HASH_TYPE_MD5;
8264 salt_type = SALT_TYPE_INTERN;
8265 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8266 opts_type = OPTS_TYPE_PT_GENERATE_LE
8267 | OPTS_TYPE_PT_ADD80
8268 | OPTS_TYPE_PT_ADDBITS14;
8269 kern_type = KERN_TYPE_MD55_SLTPW;
8270 dgst_size = DGST_SIZE_4_4;
8271 parse_func = ipb2_parse_hash;
8272 sort_by_digest = sort_by_digest_4_4;
8273 opti_type = OPTI_TYPE_ZERO_BYTE
8274 | OPTI_TYPE_PRECOMPUTE_INIT
8275 | OPTI_TYPE_EARLY_SKIP;
8276 dgst_pos0 = 0;
8277 dgst_pos1 = 3;
8278 dgst_pos2 = 2;
8279 dgst_pos3 = 1;
8280 break;
8281
8282 case 3000: hash_type = HASH_TYPE_LM;
8283 salt_type = SALT_TYPE_NONE;
8284 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8285 opts_type = OPTS_TYPE_PT_GENERATE_LE
8286 | OPTS_TYPE_PT_UPPER
8287 | OPTS_TYPE_PT_BITSLICE;
8288 kern_type = KERN_TYPE_LM;
8289 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8290 parse_func = lm_parse_hash;
8291 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8292 opti_type = OPTI_TYPE_ZERO_BYTE
8293 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8294 dgst_pos0 = 0;
8295 dgst_pos1 = 1;
8296 dgst_pos2 = 2;
8297 dgst_pos3 = 3;
8298 break;
8299
8300 case 3100: hash_type = HASH_TYPE_ORACLEH;
8301 salt_type = SALT_TYPE_INTERN;
8302 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8303 opts_type = OPTS_TYPE_PT_GENERATE_LE
8304 | OPTS_TYPE_PT_UPPER
8305 | OPTS_TYPE_ST_UPPER;
8306 kern_type = KERN_TYPE_ORACLEH;
8307 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8308 parse_func = oracleh_parse_hash;
8309 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8310 opti_type = OPTI_TYPE_ZERO_BYTE;
8311 dgst_pos0 = 0;
8312 dgst_pos1 = 1;
8313 dgst_pos2 = 2;
8314 dgst_pos3 = 3;
8315 break;
8316
8317 case 3200: hash_type = HASH_TYPE_BCRYPT;
8318 salt_type = SALT_TYPE_EMBEDDED;
8319 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8320 opts_type = OPTS_TYPE_PT_GENERATE_LE
8321 | OPTS_TYPE_ST_GENERATE_LE;
8322 kern_type = KERN_TYPE_BCRYPT;
8323 dgst_size = DGST_SIZE_4_6;
8324 parse_func = bcrypt_parse_hash;
8325 sort_by_digest = sort_by_digest_4_6;
8326 opti_type = OPTI_TYPE_ZERO_BYTE;
8327 dgst_pos0 = 0;
8328 dgst_pos1 = 1;
8329 dgst_pos2 = 2;
8330 dgst_pos3 = 3;
8331 break;
8332
8333 case 3710: hash_type = HASH_TYPE_MD5;
8334 salt_type = SALT_TYPE_INTERN;
8335 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8336 opts_type = OPTS_TYPE_PT_GENERATE_LE
8337 | OPTS_TYPE_PT_ADD80
8338 | OPTS_TYPE_PT_ADDBITS14;
8339 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8340 dgst_size = DGST_SIZE_4_4;
8341 parse_func = md5s_parse_hash;
8342 sort_by_digest = sort_by_digest_4_4;
8343 opti_type = OPTI_TYPE_ZERO_BYTE
8344 | OPTI_TYPE_PRECOMPUTE_INIT
8345 | OPTI_TYPE_PRECOMPUTE_MERKLE
8346 | OPTI_TYPE_EARLY_SKIP;
8347 dgst_pos0 = 0;
8348 dgst_pos1 = 3;
8349 dgst_pos2 = 2;
8350 dgst_pos3 = 1;
8351 break;
8352
8353 case 3711: hash_type = HASH_TYPE_MD5;
8354 salt_type = SALT_TYPE_EMBEDDED;
8355 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8356 opts_type = OPTS_TYPE_PT_GENERATE_LE
8357 | OPTS_TYPE_PT_ADD80
8358 | OPTS_TYPE_PT_ADDBITS14;
8359 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8360 dgst_size = DGST_SIZE_4_4;
8361 parse_func = mediawiki_b_parse_hash;
8362 sort_by_digest = sort_by_digest_4_4;
8363 opti_type = OPTI_TYPE_ZERO_BYTE
8364 | OPTI_TYPE_PRECOMPUTE_INIT
8365 | OPTI_TYPE_PRECOMPUTE_MERKLE
8366 | OPTI_TYPE_EARLY_SKIP;
8367 dgst_pos0 = 0;
8368 dgst_pos1 = 3;
8369 dgst_pos2 = 2;
8370 dgst_pos3 = 1;
8371 break;
8372
8373 case 3800: hash_type = HASH_TYPE_MD5;
8374 salt_type = SALT_TYPE_INTERN;
8375 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8376 opts_type = OPTS_TYPE_PT_GENERATE_LE
8377 | OPTS_TYPE_ST_ADDBITS14;
8378 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8379 dgst_size = DGST_SIZE_4_4;
8380 parse_func = md5s_parse_hash;
8381 sort_by_digest = sort_by_digest_4_4;
8382 opti_type = OPTI_TYPE_ZERO_BYTE
8383 | OPTI_TYPE_PRECOMPUTE_INIT
8384 | OPTI_TYPE_PRECOMPUTE_MERKLE
8385 | OPTI_TYPE_EARLY_SKIP
8386 | OPTI_TYPE_NOT_ITERATED
8387 | OPTI_TYPE_RAW_HASH;
8388 dgst_pos0 = 0;
8389 dgst_pos1 = 3;
8390 dgst_pos2 = 2;
8391 dgst_pos3 = 1;
8392 break;
8393
8394 case 4300: hash_type = HASH_TYPE_MD5;
8395 salt_type = SALT_TYPE_VIRTUAL;
8396 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8397 opts_type = OPTS_TYPE_PT_GENERATE_LE
8398 | OPTS_TYPE_PT_ADD80
8399 | OPTS_TYPE_PT_ADDBITS14
8400 | OPTS_TYPE_ST_ADD80;
8401 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8402 dgst_size = DGST_SIZE_4_4;
8403 parse_func = md5md5_parse_hash;
8404 sort_by_digest = sort_by_digest_4_4;
8405 opti_type = OPTI_TYPE_ZERO_BYTE
8406 | OPTI_TYPE_PRECOMPUTE_INIT
8407 | OPTI_TYPE_PRECOMPUTE_MERKLE
8408 | OPTI_TYPE_EARLY_SKIP;
8409 dgst_pos0 = 0;
8410 dgst_pos1 = 3;
8411 dgst_pos2 = 2;
8412 dgst_pos3 = 1;
8413 break;
8414
8415
8416 case 4400: hash_type = HASH_TYPE_MD5;
8417 salt_type = SALT_TYPE_NONE;
8418 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8419 opts_type = OPTS_TYPE_PT_GENERATE_BE
8420 | OPTS_TYPE_PT_ADD80
8421 | OPTS_TYPE_PT_ADDBITS15;
8422 kern_type = KERN_TYPE_MD5_SHA1;
8423 dgst_size = DGST_SIZE_4_4;
8424 parse_func = md5_parse_hash;
8425 sort_by_digest = sort_by_digest_4_4;
8426 opti_type = OPTI_TYPE_ZERO_BYTE
8427 | OPTI_TYPE_PRECOMPUTE_INIT
8428 | OPTI_TYPE_PRECOMPUTE_MERKLE
8429 | OPTI_TYPE_EARLY_SKIP
8430 | OPTI_TYPE_NOT_ITERATED
8431 | OPTI_TYPE_NOT_SALTED
8432 | OPTI_TYPE_RAW_HASH;
8433 dgst_pos0 = 0;
8434 dgst_pos1 = 3;
8435 dgst_pos2 = 2;
8436 dgst_pos3 = 1;
8437 break;
8438
8439 case 4500: hash_type = HASH_TYPE_SHA1;
8440 salt_type = SALT_TYPE_NONE;
8441 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8442 opts_type = OPTS_TYPE_PT_GENERATE_BE
8443 | OPTS_TYPE_PT_ADD80
8444 | OPTS_TYPE_PT_ADDBITS15;
8445 kern_type = KERN_TYPE_SHA11;
8446 dgst_size = DGST_SIZE_4_5;
8447 parse_func = sha1_parse_hash;
8448 sort_by_digest = sort_by_digest_4_5;
8449 opti_type = OPTI_TYPE_ZERO_BYTE
8450 | OPTI_TYPE_PRECOMPUTE_INIT
8451 | OPTI_TYPE_PRECOMPUTE_MERKLE
8452 | OPTI_TYPE_EARLY_SKIP
8453 | OPTI_TYPE_NOT_SALTED;
8454 dgst_pos0 = 3;
8455 dgst_pos1 = 4;
8456 dgst_pos2 = 2;
8457 dgst_pos3 = 1;
8458 break;
8459
8460 case 4700: hash_type = HASH_TYPE_SHA1;
8461 salt_type = SALT_TYPE_NONE;
8462 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8463 opts_type = OPTS_TYPE_PT_GENERATE_LE
8464 | OPTS_TYPE_PT_ADD80
8465 | OPTS_TYPE_PT_ADDBITS14;
8466 kern_type = KERN_TYPE_SHA1_MD5;
8467 dgst_size = DGST_SIZE_4_5;
8468 parse_func = sha1_parse_hash;
8469 sort_by_digest = sort_by_digest_4_5;
8470 opti_type = OPTI_TYPE_ZERO_BYTE
8471 | OPTI_TYPE_PRECOMPUTE_INIT
8472 | OPTI_TYPE_PRECOMPUTE_MERKLE
8473 | OPTI_TYPE_EARLY_SKIP
8474 | OPTI_TYPE_NOT_ITERATED
8475 | OPTI_TYPE_NOT_SALTED
8476 | OPTI_TYPE_RAW_HASH;
8477 dgst_pos0 = 3;
8478 dgst_pos1 = 4;
8479 dgst_pos2 = 2;
8480 dgst_pos3 = 1;
8481 break;
8482
8483 case 4800: hash_type = HASH_TYPE_MD5;
8484 salt_type = SALT_TYPE_EMBEDDED;
8485 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8486 opts_type = OPTS_TYPE_PT_GENERATE_LE
8487 | OPTS_TYPE_PT_ADDBITS14;
8488 kern_type = KERN_TYPE_MD5_CHAP;
8489 dgst_size = DGST_SIZE_4_4;
8490 parse_func = chap_parse_hash;
8491 sort_by_digest = sort_by_digest_4_4;
8492 opti_type = OPTI_TYPE_ZERO_BYTE
8493 | OPTI_TYPE_PRECOMPUTE_INIT
8494 | OPTI_TYPE_PRECOMPUTE_MERKLE
8495 | OPTI_TYPE_MEET_IN_MIDDLE
8496 | OPTI_TYPE_EARLY_SKIP
8497 | OPTI_TYPE_NOT_ITERATED
8498 | OPTI_TYPE_RAW_HASH;
8499 dgst_pos0 = 0;
8500 dgst_pos1 = 3;
8501 dgst_pos2 = 2;
8502 dgst_pos3 = 1;
8503 break;
8504
8505 case 4900: hash_type = HASH_TYPE_SHA1;
8506 salt_type = SALT_TYPE_INTERN;
8507 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8508 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8509 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8510 dgst_size = DGST_SIZE_4_5;
8511 parse_func = sha1s_parse_hash;
8512 sort_by_digest = sort_by_digest_4_5;
8513 opti_type = OPTI_TYPE_ZERO_BYTE
8514 | OPTI_TYPE_PRECOMPUTE_INIT
8515 | OPTI_TYPE_PRECOMPUTE_MERKLE
8516 | OPTI_TYPE_EARLY_SKIP;
8517 dgst_pos0 = 3;
8518 dgst_pos1 = 4;
8519 dgst_pos2 = 2;
8520 dgst_pos3 = 1;
8521 break;
8522
8523 case 5000: hash_type = HASH_TYPE_KECCAK;
8524 salt_type = SALT_TYPE_EMBEDDED;
8525 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8526 opts_type = OPTS_TYPE_PT_GENERATE_LE
8527 | OPTS_TYPE_PT_ADD01;
8528 kern_type = KERN_TYPE_KECCAK;
8529 dgst_size = DGST_SIZE_8_25;
8530 parse_func = keccak_parse_hash;
8531 sort_by_digest = sort_by_digest_8_25;
8532 opti_type = OPTI_TYPE_ZERO_BYTE
8533 | OPTI_TYPE_USES_BITS_64
8534 | OPTI_TYPE_RAW_HASH;
8535 dgst_pos0 = 2;
8536 dgst_pos1 = 3;
8537 dgst_pos2 = 4;
8538 dgst_pos3 = 5;
8539 break;
8540
8541 case 5100: hash_type = HASH_TYPE_MD5H;
8542 salt_type = SALT_TYPE_NONE;
8543 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8544 opts_type = OPTS_TYPE_PT_GENERATE_LE
8545 | OPTS_TYPE_PT_ADD80
8546 | OPTS_TYPE_PT_ADDBITS14;
8547 kern_type = KERN_TYPE_MD5H;
8548 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8549 parse_func = md5half_parse_hash;
8550 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8551 opti_type = OPTI_TYPE_ZERO_BYTE
8552 | OPTI_TYPE_RAW_HASH;
8553 dgst_pos0 = 0;
8554 dgst_pos1 = 1;
8555 dgst_pos2 = 2;
8556 dgst_pos3 = 3;
8557 break;
8558
8559 case 5200: hash_type = HASH_TYPE_SHA256;
8560 salt_type = SALT_TYPE_EMBEDDED;
8561 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8562 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8563 kern_type = KERN_TYPE_PSAFE3;
8564 dgst_size = DGST_SIZE_4_8;
8565 parse_func = psafe3_parse_hash;
8566 sort_by_digest = sort_by_digest_4_8;
8567 opti_type = OPTI_TYPE_ZERO_BYTE;
8568 dgst_pos0 = 0;
8569 dgst_pos1 = 1;
8570 dgst_pos2 = 2;
8571 dgst_pos3 = 3;
8572 break;
8573
8574 case 5300: hash_type = HASH_TYPE_MD5;
8575 salt_type = SALT_TYPE_EMBEDDED;
8576 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8577 opts_type = OPTS_TYPE_PT_GENERATE_LE
8578 | OPTS_TYPE_ST_ADD80;
8579 kern_type = KERN_TYPE_IKEPSK_MD5;
8580 dgst_size = DGST_SIZE_4_4;
8581 parse_func = ikepsk_md5_parse_hash;
8582 sort_by_digest = sort_by_digest_4_4;
8583 opti_type = OPTI_TYPE_ZERO_BYTE;
8584 dgst_pos0 = 0;
8585 dgst_pos1 = 3;
8586 dgst_pos2 = 2;
8587 dgst_pos3 = 1;
8588 break;
8589
8590 case 5400: hash_type = HASH_TYPE_SHA1;
8591 salt_type = SALT_TYPE_EMBEDDED;
8592 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8593 opts_type = OPTS_TYPE_PT_GENERATE_BE
8594 | OPTS_TYPE_ST_ADD80;
8595 kern_type = KERN_TYPE_IKEPSK_SHA1;
8596 dgst_size = DGST_SIZE_4_5;
8597 parse_func = ikepsk_sha1_parse_hash;
8598 sort_by_digest = sort_by_digest_4_5;
8599 opti_type = OPTI_TYPE_ZERO_BYTE;
8600 dgst_pos0 = 3;
8601 dgst_pos1 = 4;
8602 dgst_pos2 = 2;
8603 dgst_pos3 = 1;
8604 break;
8605
8606 case 5500: hash_type = HASH_TYPE_NETNTLM;
8607 salt_type = SALT_TYPE_EMBEDDED;
8608 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8609 opts_type = OPTS_TYPE_PT_GENERATE_LE
8610 | OPTS_TYPE_PT_ADD80
8611 | OPTS_TYPE_PT_ADDBITS14
8612 | OPTS_TYPE_PT_UNICODE
8613 | OPTS_TYPE_ST_HEX;
8614 kern_type = KERN_TYPE_NETNTLMv1;
8615 dgst_size = DGST_SIZE_4_4;
8616 parse_func = netntlmv1_parse_hash;
8617 sort_by_digest = sort_by_digest_4_4;
8618 opti_type = OPTI_TYPE_ZERO_BYTE
8619 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8620 dgst_pos0 = 0;
8621 dgst_pos1 = 1;
8622 dgst_pos2 = 2;
8623 dgst_pos3 = 3;
8624 break;
8625
8626 case 5600: hash_type = HASH_TYPE_MD5;
8627 salt_type = SALT_TYPE_EMBEDDED;
8628 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8629 opts_type = OPTS_TYPE_PT_GENERATE_LE
8630 | OPTS_TYPE_PT_ADD80
8631 | OPTS_TYPE_PT_ADDBITS14
8632 | OPTS_TYPE_PT_UNICODE;
8633 kern_type = KERN_TYPE_NETNTLMv2;
8634 dgst_size = DGST_SIZE_4_4;
8635 parse_func = netntlmv2_parse_hash;
8636 sort_by_digest = sort_by_digest_4_4;
8637 opti_type = OPTI_TYPE_ZERO_BYTE;
8638 dgst_pos0 = 0;
8639 dgst_pos1 = 3;
8640 dgst_pos2 = 2;
8641 dgst_pos3 = 1;
8642 break;
8643
8644 case 5700: hash_type = HASH_TYPE_SHA256;
8645 salt_type = SALT_TYPE_NONE;
8646 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8647 opts_type = OPTS_TYPE_PT_GENERATE_BE
8648 | OPTS_TYPE_PT_ADD80
8649 | OPTS_TYPE_PT_ADDBITS15;
8650 kern_type = KERN_TYPE_SHA256;
8651 dgst_size = DGST_SIZE_4_8;
8652 parse_func = cisco4_parse_hash;
8653 sort_by_digest = sort_by_digest_4_8;
8654 opti_type = OPTI_TYPE_ZERO_BYTE
8655 | OPTI_TYPE_PRECOMPUTE_INIT
8656 | OPTI_TYPE_PRECOMPUTE_MERKLE
8657 | OPTI_TYPE_EARLY_SKIP
8658 | OPTI_TYPE_NOT_ITERATED
8659 | OPTI_TYPE_NOT_SALTED
8660 | OPTI_TYPE_RAW_HASH;
8661 dgst_pos0 = 3;
8662 dgst_pos1 = 7;
8663 dgst_pos2 = 2;
8664 dgst_pos3 = 6;
8665 break;
8666
8667 case 5800: hash_type = HASH_TYPE_SHA1;
8668 salt_type = SALT_TYPE_INTERN;
8669 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8670 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8671 | OPTS_TYPE_ST_ADD80;
8672 kern_type = KERN_TYPE_ANDROIDPIN;
8673 dgst_size = DGST_SIZE_4_5;
8674 parse_func = androidpin_parse_hash;
8675 sort_by_digest = sort_by_digest_4_5;
8676 opti_type = OPTI_TYPE_ZERO_BYTE;
8677 dgst_pos0 = 0;
8678 dgst_pos1 = 1;
8679 dgst_pos2 = 2;
8680 dgst_pos3 = 3;
8681 break;
8682
8683 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8684 salt_type = SALT_TYPE_NONE;
8685 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8686 opts_type = OPTS_TYPE_PT_GENERATE_LE
8687 | OPTS_TYPE_PT_ADD80;
8688 kern_type = KERN_TYPE_RIPEMD160;
8689 dgst_size = DGST_SIZE_4_5;
8690 parse_func = ripemd160_parse_hash;
8691 sort_by_digest = sort_by_digest_4_5;
8692 opti_type = OPTI_TYPE_ZERO_BYTE;
8693 dgst_pos0 = 0;
8694 dgst_pos1 = 1;
8695 dgst_pos2 = 2;
8696 dgst_pos3 = 3;
8697 break;
8698
8699 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8700 salt_type = SALT_TYPE_NONE;
8701 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8702 opts_type = OPTS_TYPE_PT_GENERATE_BE
8703 | OPTS_TYPE_PT_ADD80;
8704 kern_type = KERN_TYPE_WHIRLPOOL;
8705 dgst_size = DGST_SIZE_4_16;
8706 parse_func = whirlpool_parse_hash;
8707 sort_by_digest = sort_by_digest_4_16;
8708 opti_type = OPTI_TYPE_ZERO_BYTE;
8709 dgst_pos0 = 0;
8710 dgst_pos1 = 1;
8711 dgst_pos2 = 2;
8712 dgst_pos3 = 3;
8713 break;
8714
8715 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8716 salt_type = SALT_TYPE_EMBEDDED;
8717 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8718 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8719 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8720 dgst_size = DGST_SIZE_4_5;
8721 parse_func = truecrypt_parse_hash_2k;
8722 sort_by_digest = sort_by_digest_4_5;
8723 opti_type = OPTI_TYPE_ZERO_BYTE;
8724 dgst_pos0 = 0;
8725 dgst_pos1 = 1;
8726 dgst_pos2 = 2;
8727 dgst_pos3 = 3;
8728 break;
8729
8730 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8731 salt_type = SALT_TYPE_EMBEDDED;
8732 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8733 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8734 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8735 dgst_size = DGST_SIZE_4_5;
8736 parse_func = truecrypt_parse_hash_2k;
8737 sort_by_digest = sort_by_digest_4_5;
8738 opti_type = OPTI_TYPE_ZERO_BYTE;
8739 dgst_pos0 = 0;
8740 dgst_pos1 = 1;
8741 dgst_pos2 = 2;
8742 dgst_pos3 = 3;
8743 break;
8744
8745 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8746 salt_type = SALT_TYPE_EMBEDDED;
8747 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8748 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8749 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8750 dgst_size = DGST_SIZE_4_5;
8751 parse_func = truecrypt_parse_hash_2k;
8752 sort_by_digest = sort_by_digest_4_5;
8753 opti_type = OPTI_TYPE_ZERO_BYTE;
8754 dgst_pos0 = 0;
8755 dgst_pos1 = 1;
8756 dgst_pos2 = 2;
8757 dgst_pos3 = 3;
8758 break;
8759
8760 case 6221: hash_type = HASH_TYPE_SHA512;
8761 salt_type = SALT_TYPE_EMBEDDED;
8762 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8763 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8764 kern_type = KERN_TYPE_TCSHA512_XTS512;
8765 dgst_size = DGST_SIZE_8_8;
8766 parse_func = truecrypt_parse_hash_1k;
8767 sort_by_digest = sort_by_digest_8_8;
8768 opti_type = OPTI_TYPE_ZERO_BYTE
8769 | OPTI_TYPE_USES_BITS_64;
8770 dgst_pos0 = 0;
8771 dgst_pos1 = 1;
8772 dgst_pos2 = 2;
8773 dgst_pos3 = 3;
8774 break;
8775
8776 case 6222: hash_type = HASH_TYPE_SHA512;
8777 salt_type = SALT_TYPE_EMBEDDED;
8778 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8779 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8780 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8781 dgst_size = DGST_SIZE_8_8;
8782 parse_func = truecrypt_parse_hash_1k;
8783 sort_by_digest = sort_by_digest_8_8;
8784 opti_type = OPTI_TYPE_ZERO_BYTE
8785 | OPTI_TYPE_USES_BITS_64;
8786 dgst_pos0 = 0;
8787 dgst_pos1 = 1;
8788 dgst_pos2 = 2;
8789 dgst_pos3 = 3;
8790 break;
8791
8792 case 6223: hash_type = HASH_TYPE_SHA512;
8793 salt_type = SALT_TYPE_EMBEDDED;
8794 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8795 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8796 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8797 dgst_size = DGST_SIZE_8_8;
8798 parse_func = truecrypt_parse_hash_1k;
8799 sort_by_digest = sort_by_digest_8_8;
8800 opti_type = OPTI_TYPE_ZERO_BYTE
8801 | OPTI_TYPE_USES_BITS_64;
8802 dgst_pos0 = 0;
8803 dgst_pos1 = 1;
8804 dgst_pos2 = 2;
8805 dgst_pos3 = 3;
8806 break;
8807
8808 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8809 salt_type = SALT_TYPE_EMBEDDED;
8810 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8811 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8812 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8813 dgst_size = DGST_SIZE_4_8;
8814 parse_func = truecrypt_parse_hash_1k;
8815 sort_by_digest = sort_by_digest_4_8;
8816 opti_type = OPTI_TYPE_ZERO_BYTE;
8817 dgst_pos0 = 0;
8818 dgst_pos1 = 1;
8819 dgst_pos2 = 2;
8820 dgst_pos3 = 3;
8821 break;
8822
8823 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8824 salt_type = SALT_TYPE_EMBEDDED;
8825 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8826 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8827 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8828 dgst_size = DGST_SIZE_4_8;
8829 parse_func = truecrypt_parse_hash_1k;
8830 sort_by_digest = sort_by_digest_4_8;
8831 opti_type = OPTI_TYPE_ZERO_BYTE;
8832 dgst_pos0 = 0;
8833 dgst_pos1 = 1;
8834 dgst_pos2 = 2;
8835 dgst_pos3 = 3;
8836 break;
8837
8838 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8839 salt_type = SALT_TYPE_EMBEDDED;
8840 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8841 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8842 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8843 dgst_size = DGST_SIZE_4_8;
8844 parse_func = truecrypt_parse_hash_1k;
8845 sort_by_digest = sort_by_digest_4_8;
8846 opti_type = OPTI_TYPE_ZERO_BYTE;
8847 dgst_pos0 = 0;
8848 dgst_pos1 = 1;
8849 dgst_pos2 = 2;
8850 dgst_pos3 = 3;
8851 break;
8852
8853 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8854 salt_type = SALT_TYPE_EMBEDDED;
8855 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8856 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8857 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8858 dgst_size = DGST_SIZE_4_5;
8859 parse_func = truecrypt_parse_hash_1k;
8860 sort_by_digest = sort_by_digest_4_5;
8861 opti_type = OPTI_TYPE_ZERO_BYTE;
8862 dgst_pos0 = 0;
8863 dgst_pos1 = 1;
8864 dgst_pos2 = 2;
8865 dgst_pos3 = 3;
8866 break;
8867
8868 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8869 salt_type = SALT_TYPE_EMBEDDED;
8870 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8871 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8872 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8873 dgst_size = DGST_SIZE_4_5;
8874 parse_func = truecrypt_parse_hash_1k;
8875 sort_by_digest = sort_by_digest_4_5;
8876 opti_type = OPTI_TYPE_ZERO_BYTE;
8877 dgst_pos0 = 0;
8878 dgst_pos1 = 1;
8879 dgst_pos2 = 2;
8880 dgst_pos3 = 3;
8881 break;
8882
8883 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8884 salt_type = SALT_TYPE_EMBEDDED;
8885 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8886 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8887 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8888 dgst_size = DGST_SIZE_4_5;
8889 parse_func = truecrypt_parse_hash_1k;
8890 sort_by_digest = sort_by_digest_4_5;
8891 opti_type = OPTI_TYPE_ZERO_BYTE;
8892 dgst_pos0 = 0;
8893 dgst_pos1 = 1;
8894 dgst_pos2 = 2;
8895 dgst_pos3 = 3;
8896 break;
8897
8898 case 6300: hash_type = HASH_TYPE_MD5;
8899 salt_type = SALT_TYPE_EMBEDDED;
8900 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8901 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8902 kern_type = KERN_TYPE_MD5AIX;
8903 dgst_size = DGST_SIZE_4_4;
8904 parse_func = md5aix_parse_hash;
8905 sort_by_digest = sort_by_digest_4_4;
8906 opti_type = OPTI_TYPE_ZERO_BYTE;
8907 dgst_pos0 = 0;
8908 dgst_pos1 = 1;
8909 dgst_pos2 = 2;
8910 dgst_pos3 = 3;
8911 break;
8912
8913 case 6400: hash_type = HASH_TYPE_SHA256;
8914 salt_type = SALT_TYPE_EMBEDDED;
8915 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8916 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8917 kern_type = KERN_TYPE_SHA256AIX;
8918 dgst_size = DGST_SIZE_4_8;
8919 parse_func = sha256aix_parse_hash;
8920 sort_by_digest = sort_by_digest_4_8;
8921 opti_type = OPTI_TYPE_ZERO_BYTE;
8922 dgst_pos0 = 0;
8923 dgst_pos1 = 1;
8924 dgst_pos2 = 2;
8925 dgst_pos3 = 3;
8926 break;
8927
8928 case 6500: hash_type = HASH_TYPE_SHA512;
8929 salt_type = SALT_TYPE_EMBEDDED;
8930 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8931 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8932 kern_type = KERN_TYPE_SHA512AIX;
8933 dgst_size = DGST_SIZE_8_8;
8934 parse_func = sha512aix_parse_hash;
8935 sort_by_digest = sort_by_digest_8_8;
8936 opti_type = OPTI_TYPE_ZERO_BYTE
8937 | OPTI_TYPE_USES_BITS_64;
8938 dgst_pos0 = 0;
8939 dgst_pos1 = 1;
8940 dgst_pos2 = 2;
8941 dgst_pos3 = 3;
8942 break;
8943
8944 case 6600: hash_type = HASH_TYPE_AES;
8945 salt_type = SALT_TYPE_EMBEDDED;
8946 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8947 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8948 kern_type = KERN_TYPE_AGILEKEY;
8949 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8950 parse_func = agilekey_parse_hash;
8951 sort_by_digest = sort_by_digest_4_5;
8952 opti_type = OPTI_TYPE_ZERO_BYTE;
8953 dgst_pos0 = 0;
8954 dgst_pos1 = 1;
8955 dgst_pos2 = 2;
8956 dgst_pos3 = 3;
8957 break;
8958
8959 case 6700: hash_type = HASH_TYPE_SHA1;
8960 salt_type = SALT_TYPE_EMBEDDED;
8961 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8962 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8963 kern_type = KERN_TYPE_SHA1AIX;
8964 dgst_size = DGST_SIZE_4_5;
8965 parse_func = sha1aix_parse_hash;
8966 sort_by_digest = sort_by_digest_4_5;
8967 opti_type = OPTI_TYPE_ZERO_BYTE;
8968 dgst_pos0 = 0;
8969 dgst_pos1 = 1;
8970 dgst_pos2 = 2;
8971 dgst_pos3 = 3;
8972 break;
8973
8974 case 6800: hash_type = HASH_TYPE_AES;
8975 salt_type = SALT_TYPE_EMBEDDED;
8976 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8977 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8978 kern_type = KERN_TYPE_LASTPASS;
8979 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8980 parse_func = lastpass_parse_hash;
8981 sort_by_digest = sort_by_digest_4_8;
8982 opti_type = OPTI_TYPE_ZERO_BYTE;
8983 dgst_pos0 = 0;
8984 dgst_pos1 = 1;
8985 dgst_pos2 = 2;
8986 dgst_pos3 = 3;
8987 break;
8988
8989 case 6900: hash_type = HASH_TYPE_GOST;
8990 salt_type = SALT_TYPE_NONE;
8991 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8992 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8993 kern_type = KERN_TYPE_GOST;
8994 dgst_size = DGST_SIZE_4_8;
8995 parse_func = gost_parse_hash;
8996 sort_by_digest = sort_by_digest_4_8;
8997 opti_type = OPTI_TYPE_ZERO_BYTE;
8998 dgst_pos0 = 0;
8999 dgst_pos1 = 1;
9000 dgst_pos2 = 2;
9001 dgst_pos3 = 3;
9002 break;
9003
9004 case 7100: hash_type = HASH_TYPE_SHA512;
9005 salt_type = SALT_TYPE_EMBEDDED;
9006 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9007 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9008 kern_type = KERN_TYPE_PBKDF2_SHA512;
9009 dgst_size = DGST_SIZE_8_16;
9010 parse_func = sha512osx_parse_hash;
9011 sort_by_digest = sort_by_digest_8_16;
9012 opti_type = OPTI_TYPE_ZERO_BYTE
9013 | OPTI_TYPE_USES_BITS_64;
9014 dgst_pos0 = 0;
9015 dgst_pos1 = 1;
9016 dgst_pos2 = 2;
9017 dgst_pos3 = 3;
9018 break;
9019
9020 case 7200: hash_type = HASH_TYPE_SHA512;
9021 salt_type = SALT_TYPE_EMBEDDED;
9022 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9023 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9024 kern_type = KERN_TYPE_PBKDF2_SHA512;
9025 dgst_size = DGST_SIZE_8_16;
9026 parse_func = sha512grub_parse_hash;
9027 sort_by_digest = sort_by_digest_8_16;
9028 opti_type = OPTI_TYPE_ZERO_BYTE
9029 | OPTI_TYPE_USES_BITS_64;
9030 dgst_pos0 = 0;
9031 dgst_pos1 = 1;
9032 dgst_pos2 = 2;
9033 dgst_pos3 = 3;
9034 break;
9035
9036 case 7300: hash_type = HASH_TYPE_SHA1;
9037 salt_type = SALT_TYPE_EMBEDDED;
9038 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9039 opts_type = OPTS_TYPE_PT_GENERATE_BE
9040 | OPTS_TYPE_ST_ADD80
9041 | OPTS_TYPE_ST_ADDBITS15;
9042 kern_type = KERN_TYPE_RAKP;
9043 dgst_size = DGST_SIZE_4_5;
9044 parse_func = rakp_parse_hash;
9045 sort_by_digest = sort_by_digest_4_5;
9046 opti_type = OPTI_TYPE_ZERO_BYTE
9047 | OPTI_TYPE_NOT_ITERATED;
9048 dgst_pos0 = 3;
9049 dgst_pos1 = 4;
9050 dgst_pos2 = 2;
9051 dgst_pos3 = 1;
9052 break;
9053
9054 case 7400: hash_type = HASH_TYPE_SHA256;
9055 salt_type = SALT_TYPE_EMBEDDED;
9056 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9057 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9058 kern_type = KERN_TYPE_SHA256CRYPT;
9059 dgst_size = DGST_SIZE_4_8;
9060 parse_func = sha256crypt_parse_hash;
9061 sort_by_digest = sort_by_digest_4_8;
9062 opti_type = OPTI_TYPE_ZERO_BYTE;
9063 dgst_pos0 = 0;
9064 dgst_pos1 = 1;
9065 dgst_pos2 = 2;
9066 dgst_pos3 = 3;
9067 break;
9068
9069 case 7500: hash_type = HASH_TYPE_KRB5PA;
9070 salt_type = SALT_TYPE_EMBEDDED;
9071 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9072 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9073 kern_type = KERN_TYPE_KRB5PA;
9074 dgst_size = DGST_SIZE_4_4;
9075 parse_func = krb5pa_parse_hash;
9076 sort_by_digest = sort_by_digest_4_4;
9077 opti_type = OPTI_TYPE_ZERO_BYTE
9078 | OPTI_TYPE_NOT_ITERATED;
9079 dgst_pos0 = 0;
9080 dgst_pos1 = 1;
9081 dgst_pos2 = 2;
9082 dgst_pos3 = 3;
9083 break;
9084
9085 case 7600: hash_type = HASH_TYPE_SHA1;
9086 salt_type = SALT_TYPE_INTERN;
9087 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9088 opts_type = OPTS_TYPE_PT_GENERATE_BE
9089 | OPTS_TYPE_PT_ADD80
9090 | OPTS_TYPE_PT_ADDBITS15;
9091 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9092 dgst_size = DGST_SIZE_4_5;
9093 parse_func = redmine_parse_hash;
9094 sort_by_digest = sort_by_digest_4_5;
9095 opti_type = OPTI_TYPE_ZERO_BYTE
9096 | OPTI_TYPE_PRECOMPUTE_INIT
9097 | OPTI_TYPE_EARLY_SKIP
9098 | OPTI_TYPE_NOT_ITERATED
9099 | OPTI_TYPE_PREPENDED_SALT;
9100 dgst_pos0 = 3;
9101 dgst_pos1 = 4;
9102 dgst_pos2 = 2;
9103 dgst_pos3 = 1;
9104 break;
9105
9106 case 7700: hash_type = HASH_TYPE_SAPB;
9107 salt_type = SALT_TYPE_EMBEDDED;
9108 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9109 opts_type = OPTS_TYPE_PT_GENERATE_LE
9110 | OPTS_TYPE_PT_UPPER
9111 | OPTS_TYPE_ST_UPPER;
9112 kern_type = KERN_TYPE_SAPB;
9113 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9114 parse_func = sapb_parse_hash;
9115 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9116 opti_type = OPTI_TYPE_ZERO_BYTE
9117 | OPTI_TYPE_PRECOMPUTE_INIT
9118 | OPTI_TYPE_NOT_ITERATED;
9119 dgst_pos0 = 0;
9120 dgst_pos1 = 1;
9121 dgst_pos2 = 2;
9122 dgst_pos3 = 3;
9123 break;
9124
9125 case 7800: hash_type = HASH_TYPE_SAPG;
9126 salt_type = SALT_TYPE_EMBEDDED;
9127 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9128 opts_type = OPTS_TYPE_PT_GENERATE_BE
9129 | OPTS_TYPE_ST_ADD80
9130 | OPTS_TYPE_ST_UPPER;
9131 kern_type = KERN_TYPE_SAPG;
9132 dgst_size = DGST_SIZE_4_5;
9133 parse_func = sapg_parse_hash;
9134 sort_by_digest = sort_by_digest_4_5;
9135 opti_type = OPTI_TYPE_ZERO_BYTE
9136 | OPTI_TYPE_PRECOMPUTE_INIT
9137 | OPTI_TYPE_NOT_ITERATED;
9138 dgst_pos0 = 3;
9139 dgst_pos1 = 4;
9140 dgst_pos2 = 2;
9141 dgst_pos3 = 1;
9142 break;
9143
9144 case 7900: hash_type = HASH_TYPE_SHA512;
9145 salt_type = SALT_TYPE_EMBEDDED;
9146 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9147 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9148 kern_type = KERN_TYPE_DRUPAL7;
9149 dgst_size = DGST_SIZE_8_8;
9150 parse_func = drupal7_parse_hash;
9151 sort_by_digest = sort_by_digest_8_8;
9152 opti_type = OPTI_TYPE_ZERO_BYTE
9153 | OPTI_TYPE_USES_BITS_64;
9154 dgst_pos0 = 0;
9155 dgst_pos1 = 1;
9156 dgst_pos2 = 2;
9157 dgst_pos3 = 3;
9158 break;
9159
9160 case 8000: hash_type = HASH_TYPE_SHA256;
9161 salt_type = SALT_TYPE_EMBEDDED;
9162 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9163 opts_type = OPTS_TYPE_PT_GENERATE_BE
9164 | OPTS_TYPE_PT_UNICODE
9165 | OPTS_TYPE_ST_ADD80
9166 | OPTS_TYPE_ST_HEX;
9167 kern_type = KERN_TYPE_SYBASEASE;
9168 dgst_size = DGST_SIZE_4_8;
9169 parse_func = sybasease_parse_hash;
9170 sort_by_digest = sort_by_digest_4_8;
9171 opti_type = OPTI_TYPE_ZERO_BYTE
9172 | OPTI_TYPE_PRECOMPUTE_INIT
9173 | OPTI_TYPE_EARLY_SKIP
9174 | OPTI_TYPE_NOT_ITERATED
9175 | OPTI_TYPE_RAW_HASH;
9176 dgst_pos0 = 3;
9177 dgst_pos1 = 7;
9178 dgst_pos2 = 2;
9179 dgst_pos3 = 6;
9180 break;
9181
9182 case 8100: hash_type = HASH_TYPE_SHA1;
9183 salt_type = SALT_TYPE_EMBEDDED;
9184 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9185 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9186 kern_type = KERN_TYPE_NETSCALER;
9187 dgst_size = DGST_SIZE_4_5;
9188 parse_func = netscaler_parse_hash;
9189 sort_by_digest = sort_by_digest_4_5;
9190 opti_type = OPTI_TYPE_ZERO_BYTE
9191 | OPTI_TYPE_PRECOMPUTE_INIT
9192 | OPTI_TYPE_PRECOMPUTE_MERKLE
9193 | OPTI_TYPE_EARLY_SKIP
9194 | OPTI_TYPE_NOT_ITERATED
9195 | OPTI_TYPE_PREPENDED_SALT
9196 | OPTI_TYPE_RAW_HASH;
9197 dgst_pos0 = 3;
9198 dgst_pos1 = 4;
9199 dgst_pos2 = 2;
9200 dgst_pos3 = 1;
9201 break;
9202
9203 case 8200: hash_type = HASH_TYPE_SHA256;
9204 salt_type = SALT_TYPE_EMBEDDED;
9205 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9206 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9207 kern_type = KERN_TYPE_CLOUDKEY;
9208 dgst_size = DGST_SIZE_4_8;
9209 parse_func = cloudkey_parse_hash;
9210 sort_by_digest = sort_by_digest_4_8;
9211 opti_type = OPTI_TYPE_ZERO_BYTE;
9212 dgst_pos0 = 0;
9213 dgst_pos1 = 1;
9214 dgst_pos2 = 2;
9215 dgst_pos3 = 3;
9216 break;
9217
9218 case 8300: hash_type = HASH_TYPE_SHA1;
9219 salt_type = SALT_TYPE_EMBEDDED;
9220 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9221 opts_type = OPTS_TYPE_PT_GENERATE_BE
9222 | OPTS_TYPE_ST_HEX
9223 | OPTS_TYPE_ST_ADD80;
9224 kern_type = KERN_TYPE_NSEC3;
9225 dgst_size = DGST_SIZE_4_5;
9226 parse_func = nsec3_parse_hash;
9227 sort_by_digest = sort_by_digest_4_5;
9228 opti_type = OPTI_TYPE_ZERO_BYTE;
9229 dgst_pos0 = 3;
9230 dgst_pos1 = 4;
9231 dgst_pos2 = 2;
9232 dgst_pos3 = 1;
9233 break;
9234
9235 case 8400: hash_type = HASH_TYPE_SHA1;
9236 salt_type = SALT_TYPE_INTERN;
9237 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9238 opts_type = OPTS_TYPE_PT_GENERATE_BE
9239 | OPTS_TYPE_PT_ADD80
9240 | OPTS_TYPE_PT_ADDBITS15;
9241 kern_type = KERN_TYPE_WBB3;
9242 dgst_size = DGST_SIZE_4_5;
9243 parse_func = wbb3_parse_hash;
9244 sort_by_digest = sort_by_digest_4_5;
9245 opti_type = OPTI_TYPE_ZERO_BYTE
9246 | OPTI_TYPE_PRECOMPUTE_INIT
9247 | OPTI_TYPE_NOT_ITERATED;
9248 dgst_pos0 = 3;
9249 dgst_pos1 = 4;
9250 dgst_pos2 = 2;
9251 dgst_pos3 = 1;
9252 break;
9253
9254 case 8500: hash_type = HASH_TYPE_DESRACF;
9255 salt_type = SALT_TYPE_EMBEDDED;
9256 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9257 opts_type = OPTS_TYPE_PT_GENERATE_LE
9258 | OPTS_TYPE_ST_UPPER;
9259 kern_type = KERN_TYPE_RACF;
9260 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9261 parse_func = racf_parse_hash;
9262 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9263 opti_type = OPTI_TYPE_ZERO_BYTE
9264 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9265 dgst_pos0 = 0;
9266 dgst_pos1 = 1;
9267 dgst_pos2 = 2;
9268 dgst_pos3 = 3;
9269 break;
9270
9271 case 8600: hash_type = HASH_TYPE_LOTUS5;
9272 salt_type = SALT_TYPE_NONE;
9273 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9274 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9275 kern_type = KERN_TYPE_LOTUS5;
9276 dgst_size = DGST_SIZE_4_4;
9277 parse_func = lotus5_parse_hash;
9278 sort_by_digest = sort_by_digest_4_4;
9279 opti_type = OPTI_TYPE_EARLY_SKIP
9280 | OPTI_TYPE_NOT_ITERATED
9281 | OPTI_TYPE_NOT_SALTED
9282 | OPTI_TYPE_RAW_HASH;
9283 dgst_pos0 = 0;
9284 dgst_pos1 = 1;
9285 dgst_pos2 = 2;
9286 dgst_pos3 = 3;
9287 break;
9288
9289 case 8700: hash_type = HASH_TYPE_LOTUS6;
9290 salt_type = SALT_TYPE_EMBEDDED;
9291 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9292 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9293 kern_type = KERN_TYPE_LOTUS6;
9294 dgst_size = DGST_SIZE_4_4;
9295 parse_func = lotus6_parse_hash;
9296 sort_by_digest = sort_by_digest_4_4;
9297 opti_type = OPTI_TYPE_EARLY_SKIP
9298 | OPTI_TYPE_NOT_ITERATED
9299 | OPTI_TYPE_RAW_HASH;
9300 dgst_pos0 = 0;
9301 dgst_pos1 = 1;
9302 dgst_pos2 = 2;
9303 dgst_pos3 = 3;
9304 break;
9305
9306 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9307 salt_type = SALT_TYPE_EMBEDDED;
9308 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9309 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9310 kern_type = KERN_TYPE_ANDROIDFDE;
9311 dgst_size = DGST_SIZE_4_4;
9312 parse_func = androidfde_parse_hash;
9313 sort_by_digest = sort_by_digest_4_4;
9314 opti_type = OPTI_TYPE_ZERO_BYTE;
9315 dgst_pos0 = 0;
9316 dgst_pos1 = 1;
9317 dgst_pos2 = 2;
9318 dgst_pos3 = 3;
9319 break;
9320
9321 case 8900: hash_type = HASH_TYPE_SCRYPT;
9322 salt_type = SALT_TYPE_EMBEDDED;
9323 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9324 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9325 kern_type = KERN_TYPE_SCRYPT;
9326 dgst_size = DGST_SIZE_4_8;
9327 parse_func = scrypt_parse_hash;
9328 sort_by_digest = sort_by_digest_4_8;
9329 opti_type = OPTI_TYPE_ZERO_BYTE;
9330 dgst_pos0 = 0;
9331 dgst_pos1 = 1;
9332 dgst_pos2 = 2;
9333 dgst_pos3 = 3;
9334 break;
9335
9336 case 9000: hash_type = HASH_TYPE_SHA1;
9337 salt_type = SALT_TYPE_EMBEDDED;
9338 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9339 opts_type = OPTS_TYPE_PT_GENERATE_LE
9340 | OPTS_TYPE_ST_GENERATE_LE;
9341 kern_type = KERN_TYPE_PSAFE2;
9342 dgst_size = DGST_SIZE_4_5;
9343 parse_func = psafe2_parse_hash;
9344 sort_by_digest = sort_by_digest_4_5;
9345 opti_type = OPTI_TYPE_ZERO_BYTE;
9346 dgst_pos0 = 0;
9347 dgst_pos1 = 1;
9348 dgst_pos2 = 2;
9349 dgst_pos3 = 3;
9350 break;
9351
9352 case 9100: hash_type = HASH_TYPE_LOTUS8;
9353 salt_type = SALT_TYPE_EMBEDDED;
9354 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9355 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9356 kern_type = KERN_TYPE_LOTUS8;
9357 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9358 parse_func = lotus8_parse_hash;
9359 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9360 opti_type = OPTI_TYPE_ZERO_BYTE;
9361 dgst_pos0 = 0;
9362 dgst_pos1 = 1;
9363 dgst_pos2 = 2;
9364 dgst_pos3 = 3;
9365 break;
9366
9367 case 9200: hash_type = HASH_TYPE_SHA256;
9368 salt_type = SALT_TYPE_EMBEDDED;
9369 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9370 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9371 kern_type = KERN_TYPE_PBKDF2_SHA256;
9372 dgst_size = DGST_SIZE_4_32;
9373 parse_func = cisco8_parse_hash;
9374 sort_by_digest = sort_by_digest_4_32;
9375 opti_type = OPTI_TYPE_ZERO_BYTE;
9376 dgst_pos0 = 0;
9377 dgst_pos1 = 1;
9378 dgst_pos2 = 2;
9379 dgst_pos3 = 3;
9380 break;
9381
9382 case 9300: hash_type = HASH_TYPE_SCRYPT;
9383 salt_type = SALT_TYPE_EMBEDDED;
9384 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9385 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9386 kern_type = KERN_TYPE_SCRYPT;
9387 dgst_size = DGST_SIZE_4_8;
9388 parse_func = cisco9_parse_hash;
9389 sort_by_digest = sort_by_digest_4_8;
9390 opti_type = OPTI_TYPE_ZERO_BYTE;
9391 dgst_pos0 = 0;
9392 dgst_pos1 = 1;
9393 dgst_pos2 = 2;
9394 dgst_pos3 = 3;
9395 break;
9396
9397 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9398 salt_type = SALT_TYPE_EMBEDDED;
9399 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9400 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9401 kern_type = KERN_TYPE_OFFICE2007;
9402 dgst_size = DGST_SIZE_4_4;
9403 parse_func = office2007_parse_hash;
9404 sort_by_digest = sort_by_digest_4_4;
9405 opti_type = OPTI_TYPE_ZERO_BYTE;
9406 dgst_pos0 = 0;
9407 dgst_pos1 = 1;
9408 dgst_pos2 = 2;
9409 dgst_pos3 = 3;
9410 break;
9411
9412 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9413 salt_type = SALT_TYPE_EMBEDDED;
9414 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9415 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9416 kern_type = KERN_TYPE_OFFICE2010;
9417 dgst_size = DGST_SIZE_4_4;
9418 parse_func = office2010_parse_hash;
9419 sort_by_digest = sort_by_digest_4_4;
9420 opti_type = OPTI_TYPE_ZERO_BYTE;
9421 dgst_pos0 = 0;
9422 dgst_pos1 = 1;
9423 dgst_pos2 = 2;
9424 dgst_pos3 = 3;
9425 break;
9426
9427 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9428 salt_type = SALT_TYPE_EMBEDDED;
9429 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9430 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9431 kern_type = KERN_TYPE_OFFICE2013;
9432 dgst_size = DGST_SIZE_4_4;
9433 parse_func = office2013_parse_hash;
9434 sort_by_digest = sort_by_digest_4_4;
9435 opti_type = OPTI_TYPE_ZERO_BYTE;
9436 dgst_pos0 = 0;
9437 dgst_pos1 = 1;
9438 dgst_pos2 = 2;
9439 dgst_pos3 = 3;
9440 break;
9441
9442 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9443 salt_type = SALT_TYPE_EMBEDDED;
9444 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9445 opts_type = OPTS_TYPE_PT_GENERATE_LE
9446 | OPTS_TYPE_PT_ADD80
9447 | OPTS_TYPE_PT_UNICODE;
9448 kern_type = KERN_TYPE_OLDOFFICE01;
9449 dgst_size = DGST_SIZE_4_4;
9450 parse_func = oldoffice01_parse_hash;
9451 sort_by_digest = sort_by_digest_4_4;
9452 opti_type = OPTI_TYPE_ZERO_BYTE
9453 | OPTI_TYPE_PRECOMPUTE_INIT
9454 | OPTI_TYPE_NOT_ITERATED;
9455 dgst_pos0 = 0;
9456 dgst_pos1 = 1;
9457 dgst_pos2 = 2;
9458 dgst_pos3 = 3;
9459 break;
9460
9461 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9462 salt_type = SALT_TYPE_EMBEDDED;
9463 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9464 opts_type = OPTS_TYPE_PT_GENERATE_LE
9465 | OPTS_TYPE_PT_ADD80;
9466 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9467 dgst_size = DGST_SIZE_4_4;
9468 parse_func = oldoffice01cm1_parse_hash;
9469 sort_by_digest = sort_by_digest_4_4;
9470 opti_type = OPTI_TYPE_ZERO_BYTE
9471 | OPTI_TYPE_PRECOMPUTE_INIT
9472 | OPTI_TYPE_NOT_ITERATED;
9473 dgst_pos0 = 0;
9474 dgst_pos1 = 1;
9475 dgst_pos2 = 2;
9476 dgst_pos3 = 3;
9477 break;
9478
9479 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9480 salt_type = SALT_TYPE_EMBEDDED;
9481 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9482 opts_type = OPTS_TYPE_PT_GENERATE_LE
9483 | OPTS_TYPE_PT_ADD80
9484 | OPTS_TYPE_PT_UNICODE
9485 | OPTS_TYPE_PT_NEVERCRACK;
9486 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9487 dgst_size = DGST_SIZE_4_4;
9488 parse_func = oldoffice01cm2_parse_hash;
9489 sort_by_digest = sort_by_digest_4_4;
9490 opti_type = OPTI_TYPE_ZERO_BYTE
9491 | OPTI_TYPE_PRECOMPUTE_INIT
9492 | OPTI_TYPE_NOT_ITERATED;
9493 dgst_pos0 = 0;
9494 dgst_pos1 = 1;
9495 dgst_pos2 = 2;
9496 dgst_pos3 = 3;
9497 break;
9498
9499 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9500 salt_type = SALT_TYPE_EMBEDDED;
9501 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9502 opts_type = OPTS_TYPE_PT_GENERATE_BE
9503 | OPTS_TYPE_PT_ADD80
9504 | OPTS_TYPE_PT_UNICODE;
9505 kern_type = KERN_TYPE_OLDOFFICE34;
9506 dgst_size = DGST_SIZE_4_4;
9507 parse_func = oldoffice34_parse_hash;
9508 sort_by_digest = sort_by_digest_4_4;
9509 opti_type = OPTI_TYPE_ZERO_BYTE
9510 | OPTI_TYPE_PRECOMPUTE_INIT
9511 | OPTI_TYPE_NOT_ITERATED;
9512 dgst_pos0 = 0;
9513 dgst_pos1 = 1;
9514 dgst_pos2 = 2;
9515 dgst_pos3 = 3;
9516 break;
9517
9518 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9519 salt_type = SALT_TYPE_EMBEDDED;
9520 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9521 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9522 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9523 dgst_size = DGST_SIZE_4_4;
9524 parse_func = oldoffice34cm1_parse_hash;
9525 sort_by_digest = sort_by_digest_4_4;
9526 opti_type = OPTI_TYPE_ZERO_BYTE
9527 | OPTI_TYPE_PRECOMPUTE_INIT
9528 | OPTI_TYPE_NOT_ITERATED;
9529 dgst_pos0 = 0;
9530 dgst_pos1 = 1;
9531 dgst_pos2 = 2;
9532 dgst_pos3 = 3;
9533 break;
9534
9535 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9536 salt_type = SALT_TYPE_EMBEDDED;
9537 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9538 opts_type = OPTS_TYPE_PT_GENERATE_BE
9539 | OPTS_TYPE_PT_ADD80
9540 | OPTS_TYPE_PT_UNICODE
9541 | OPTS_TYPE_PT_NEVERCRACK;
9542 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9543 dgst_size = DGST_SIZE_4_4;
9544 parse_func = oldoffice34cm2_parse_hash;
9545 sort_by_digest = sort_by_digest_4_4;
9546 opti_type = OPTI_TYPE_ZERO_BYTE
9547 | OPTI_TYPE_PRECOMPUTE_INIT
9548 | OPTI_TYPE_NOT_ITERATED;
9549 dgst_pos0 = 0;
9550 dgst_pos1 = 1;
9551 dgst_pos2 = 2;
9552 dgst_pos3 = 3;
9553 break;
9554
9555 case 9900: hash_type = HASH_TYPE_MD5;
9556 salt_type = SALT_TYPE_NONE;
9557 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9558 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9559 kern_type = KERN_TYPE_RADMIN2;
9560 dgst_size = DGST_SIZE_4_4;
9561 parse_func = radmin2_parse_hash;
9562 sort_by_digest = sort_by_digest_4_4;
9563 opti_type = OPTI_TYPE_ZERO_BYTE
9564 | OPTI_TYPE_PRECOMPUTE_INIT
9565 | OPTI_TYPE_EARLY_SKIP
9566 | OPTI_TYPE_NOT_ITERATED
9567 | OPTI_TYPE_NOT_SALTED;
9568 dgst_pos0 = 0;
9569 dgst_pos1 = 3;
9570 dgst_pos2 = 2;
9571 dgst_pos3 = 1;
9572 break;
9573
9574 case 10000: hash_type = HASH_TYPE_SHA256;
9575 salt_type = SALT_TYPE_EMBEDDED;
9576 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9577 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9578 kern_type = KERN_TYPE_PBKDF2_SHA256;
9579 dgst_size = DGST_SIZE_4_32;
9580 parse_func = djangopbkdf2_parse_hash;
9581 sort_by_digest = sort_by_digest_4_32;
9582 opti_type = OPTI_TYPE_ZERO_BYTE;
9583 dgst_pos0 = 0;
9584 dgst_pos1 = 1;
9585 dgst_pos2 = 2;
9586 dgst_pos3 = 3;
9587 break;
9588
9589 case 10100: hash_type = HASH_TYPE_SIPHASH;
9590 salt_type = SALT_TYPE_EMBEDDED;
9591 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9592 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9593 kern_type = KERN_TYPE_SIPHASH;
9594 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9595 parse_func = siphash_parse_hash;
9596 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9597 opti_type = OPTI_TYPE_ZERO_BYTE
9598 | OPTI_TYPE_NOT_ITERATED
9599 | OPTI_TYPE_RAW_HASH;
9600 dgst_pos0 = 0;
9601 dgst_pos1 = 1;
9602 dgst_pos2 = 2;
9603 dgst_pos3 = 3;
9604 break;
9605
9606 case 10200: hash_type = HASH_TYPE_MD5;
9607 salt_type = SALT_TYPE_EMBEDDED;
9608 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9609 opts_type = OPTS_TYPE_PT_GENERATE_LE
9610 | OPTS_TYPE_ST_ADD80
9611 | OPTS_TYPE_ST_ADDBITS14;
9612 kern_type = KERN_TYPE_HMACMD5_PW;
9613 dgst_size = DGST_SIZE_4_4;
9614 parse_func = crammd5_parse_hash;
9615 sort_by_digest = sort_by_digest_4_4;
9616 opti_type = OPTI_TYPE_ZERO_BYTE
9617 | OPTI_TYPE_NOT_ITERATED;
9618 dgst_pos0 = 0;
9619 dgst_pos1 = 3;
9620 dgst_pos2 = 2;
9621 dgst_pos3 = 1;
9622 break;
9623
9624 case 10300: hash_type = HASH_TYPE_SHA1;
9625 salt_type = SALT_TYPE_EMBEDDED;
9626 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9627 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9628 kern_type = KERN_TYPE_SAPH_SHA1;
9629 dgst_size = DGST_SIZE_4_5;
9630 parse_func = saph_sha1_parse_hash;
9631 sort_by_digest = sort_by_digest_4_5;
9632 opti_type = OPTI_TYPE_ZERO_BYTE;
9633 dgst_pos0 = 0;
9634 dgst_pos1 = 1;
9635 dgst_pos2 = 2;
9636 dgst_pos3 = 3;
9637 break;
9638
9639 case 10400: hash_type = HASH_TYPE_PDFU16;
9640 salt_type = SALT_TYPE_EMBEDDED;
9641 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9642 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9643 kern_type = KERN_TYPE_PDF11;
9644 dgst_size = DGST_SIZE_4_4;
9645 parse_func = pdf11_parse_hash;
9646 sort_by_digest = sort_by_digest_4_4;
9647 opti_type = OPTI_TYPE_ZERO_BYTE
9648 | OPTI_TYPE_NOT_ITERATED;
9649 dgst_pos0 = 0;
9650 dgst_pos1 = 1;
9651 dgst_pos2 = 2;
9652 dgst_pos3 = 3;
9653 break;
9654
9655 case 10410: hash_type = HASH_TYPE_PDFU16;
9656 salt_type = SALT_TYPE_EMBEDDED;
9657 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9658 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9659 kern_type = KERN_TYPE_PDF11CM1;
9660 dgst_size = DGST_SIZE_4_4;
9661 parse_func = pdf11cm1_parse_hash;
9662 sort_by_digest = sort_by_digest_4_4;
9663 opti_type = OPTI_TYPE_ZERO_BYTE
9664 | OPTI_TYPE_NOT_ITERATED;
9665 dgst_pos0 = 0;
9666 dgst_pos1 = 1;
9667 dgst_pos2 = 2;
9668 dgst_pos3 = 3;
9669 break;
9670
9671 case 10420: hash_type = HASH_TYPE_PDFU16;
9672 salt_type = SALT_TYPE_EMBEDDED;
9673 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9674 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9675 kern_type = KERN_TYPE_PDF11CM2;
9676 dgst_size = DGST_SIZE_4_4;
9677 parse_func = pdf11cm2_parse_hash;
9678 sort_by_digest = sort_by_digest_4_4;
9679 opti_type = OPTI_TYPE_ZERO_BYTE
9680 | OPTI_TYPE_NOT_ITERATED;
9681 dgst_pos0 = 0;
9682 dgst_pos1 = 1;
9683 dgst_pos2 = 2;
9684 dgst_pos3 = 3;
9685 break;
9686
9687 case 10500: hash_type = HASH_TYPE_PDFU16;
9688 salt_type = SALT_TYPE_EMBEDDED;
9689 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9690 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9691 kern_type = KERN_TYPE_PDF14;
9692 dgst_size = DGST_SIZE_4_4;
9693 parse_func = pdf14_parse_hash;
9694 sort_by_digest = sort_by_digest_4_4;
9695 opti_type = OPTI_TYPE_ZERO_BYTE
9696 | OPTI_TYPE_NOT_ITERATED;
9697 dgst_pos0 = 0;
9698 dgst_pos1 = 1;
9699 dgst_pos2 = 2;
9700 dgst_pos3 = 3;
9701 break;
9702
9703 case 10600: hash_type = HASH_TYPE_SHA256;
9704 salt_type = SALT_TYPE_EMBEDDED;
9705 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9706 opts_type = OPTS_TYPE_PT_GENERATE_BE
9707 | OPTS_TYPE_ST_ADD80
9708 | OPTS_TYPE_ST_ADDBITS15
9709 | OPTS_TYPE_HASH_COPY;
9710 kern_type = KERN_TYPE_SHA256_PWSLT;
9711 dgst_size = DGST_SIZE_4_8;
9712 parse_func = pdf17l3_parse_hash;
9713 sort_by_digest = sort_by_digest_4_8;
9714 opti_type = OPTI_TYPE_ZERO_BYTE
9715 | OPTI_TYPE_PRECOMPUTE_INIT
9716 | OPTI_TYPE_PRECOMPUTE_MERKLE
9717 | OPTI_TYPE_EARLY_SKIP
9718 | OPTI_TYPE_NOT_ITERATED
9719 | OPTI_TYPE_APPENDED_SALT
9720 | OPTI_TYPE_RAW_HASH;
9721 dgst_pos0 = 3;
9722 dgst_pos1 = 7;
9723 dgst_pos2 = 2;
9724 dgst_pos3 = 6;
9725 break;
9726
9727 case 10700: hash_type = HASH_TYPE_PDFU32;
9728 salt_type = SALT_TYPE_EMBEDDED;
9729 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9730 opts_type = OPTS_TYPE_PT_GENERATE_LE
9731 | OPTS_TYPE_HASH_COPY;
9732 kern_type = KERN_TYPE_PDF17L8;
9733 dgst_size = DGST_SIZE_4_8;
9734 parse_func = pdf17l8_parse_hash;
9735 sort_by_digest = sort_by_digest_4_8;
9736 opti_type = OPTI_TYPE_ZERO_BYTE
9737 | OPTI_TYPE_NOT_ITERATED;
9738 dgst_pos0 = 0;
9739 dgst_pos1 = 1;
9740 dgst_pos2 = 2;
9741 dgst_pos3 = 3;
9742 break;
9743
9744 case 10800: hash_type = HASH_TYPE_SHA384;
9745 salt_type = SALT_TYPE_NONE;
9746 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9747 opts_type = OPTS_TYPE_PT_GENERATE_BE
9748 | OPTS_TYPE_PT_ADD80
9749 | OPTS_TYPE_PT_ADDBITS15;
9750 kern_type = KERN_TYPE_SHA384;
9751 dgst_size = DGST_SIZE_8_8;
9752 parse_func = sha384_parse_hash;
9753 sort_by_digest = sort_by_digest_8_8;
9754 opti_type = OPTI_TYPE_ZERO_BYTE
9755 | OPTI_TYPE_PRECOMPUTE_INIT
9756 | OPTI_TYPE_PRECOMPUTE_MERKLE
9757 | OPTI_TYPE_EARLY_SKIP
9758 | OPTI_TYPE_NOT_ITERATED
9759 | OPTI_TYPE_NOT_SALTED
9760 | OPTI_TYPE_USES_BITS_64
9761 | OPTI_TYPE_RAW_HASH;
9762 dgst_pos0 = 6;
9763 dgst_pos1 = 7;
9764 dgst_pos2 = 4;
9765 dgst_pos3 = 5;
9766 break;
9767
9768 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9769 salt_type = SALT_TYPE_EMBEDDED;
9770 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9771 opts_type = OPTS_TYPE_PT_GENERATE_LE
9772 | OPTS_TYPE_ST_BASE64
9773 | OPTS_TYPE_HASH_COPY;
9774 kern_type = KERN_TYPE_PBKDF2_SHA256;
9775 dgst_size = DGST_SIZE_4_32;
9776 parse_func = pbkdf2_sha256_parse_hash;
9777 sort_by_digest = sort_by_digest_4_32;
9778 opti_type = OPTI_TYPE_ZERO_BYTE;
9779 dgst_pos0 = 0;
9780 dgst_pos1 = 1;
9781 dgst_pos2 = 2;
9782 dgst_pos3 = 3;
9783 break;
9784
9785 case 11000: hash_type = HASH_TYPE_MD5;
9786 salt_type = SALT_TYPE_INTERN;
9787 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9788 opts_type = OPTS_TYPE_PT_GENERATE_LE
9789 | OPTS_TYPE_PT_ADD80;
9790 kern_type = KERN_TYPE_PRESTASHOP;
9791 dgst_size = DGST_SIZE_4_4;
9792 parse_func = prestashop_parse_hash;
9793 sort_by_digest = sort_by_digest_4_4;
9794 opti_type = OPTI_TYPE_ZERO_BYTE
9795 | OPTI_TYPE_PRECOMPUTE_INIT
9796 | OPTI_TYPE_NOT_ITERATED
9797 | OPTI_TYPE_PREPENDED_SALT;
9798 dgst_pos0 = 0;
9799 dgst_pos1 = 3;
9800 dgst_pos2 = 2;
9801 dgst_pos3 = 1;
9802 break;
9803
9804 case 11100: hash_type = HASH_TYPE_MD5;
9805 salt_type = SALT_TYPE_EMBEDDED;
9806 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9807 opts_type = OPTS_TYPE_PT_GENERATE_LE
9808 | OPTS_TYPE_ST_ADD80;
9809 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9810 dgst_size = DGST_SIZE_4_4;
9811 parse_func = postgresql_auth_parse_hash;
9812 sort_by_digest = sort_by_digest_4_4;
9813 opti_type = OPTI_TYPE_ZERO_BYTE
9814 | OPTI_TYPE_PRECOMPUTE_INIT
9815 | OPTI_TYPE_PRECOMPUTE_MERKLE
9816 | OPTI_TYPE_EARLY_SKIP;
9817 dgst_pos0 = 0;
9818 dgst_pos1 = 3;
9819 dgst_pos2 = 2;
9820 dgst_pos3 = 1;
9821 break;
9822
9823 case 11200: hash_type = HASH_TYPE_SHA1;
9824 salt_type = SALT_TYPE_EMBEDDED;
9825 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9826 opts_type = OPTS_TYPE_PT_GENERATE_BE
9827 | OPTS_TYPE_PT_ADD80
9828 | OPTS_TYPE_ST_HEX;
9829 kern_type = KERN_TYPE_MYSQL_AUTH;
9830 dgst_size = DGST_SIZE_4_5;
9831 parse_func = mysql_auth_parse_hash;
9832 sort_by_digest = sort_by_digest_4_5;
9833 opti_type = OPTI_TYPE_ZERO_BYTE
9834 | OPTI_TYPE_EARLY_SKIP;
9835 dgst_pos0 = 3;
9836 dgst_pos1 = 4;
9837 dgst_pos2 = 2;
9838 dgst_pos3 = 1;
9839 break;
9840
9841 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9842 salt_type = SALT_TYPE_EMBEDDED;
9843 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9844 opts_type = OPTS_TYPE_PT_GENERATE_LE
9845 | OPTS_TYPE_ST_HEX
9846 | OPTS_TYPE_ST_ADD80;
9847 kern_type = KERN_TYPE_BITCOIN_WALLET;
9848 dgst_size = DGST_SIZE_4_4;
9849 parse_func = bitcoin_wallet_parse_hash;
9850 sort_by_digest = sort_by_digest_4_4;
9851 opti_type = OPTI_TYPE_ZERO_BYTE;
9852 dgst_pos0 = 0;
9853 dgst_pos1 = 1;
9854 dgst_pos2 = 2;
9855 dgst_pos3 = 3;
9856 break;
9857
9858 case 11400: hash_type = HASH_TYPE_MD5;
9859 salt_type = SALT_TYPE_EMBEDDED;
9860 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9861 opts_type = OPTS_TYPE_PT_GENERATE_LE
9862 | OPTS_TYPE_PT_ADD80
9863 | OPTS_TYPE_HASH_COPY;
9864 kern_type = KERN_TYPE_SIP_AUTH;
9865 dgst_size = DGST_SIZE_4_4;
9866 parse_func = sip_auth_parse_hash;
9867 sort_by_digest = sort_by_digest_4_4;
9868 opti_type = OPTI_TYPE_ZERO_BYTE;
9869 dgst_pos0 = 0;
9870 dgst_pos1 = 3;
9871 dgst_pos2 = 2;
9872 dgst_pos3 = 1;
9873 break;
9874
9875 case 11500: hash_type = HASH_TYPE_CRC32;
9876 salt_type = SALT_TYPE_INTERN;
9877 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9878 opts_type = OPTS_TYPE_PT_GENERATE_LE
9879 | OPTS_TYPE_ST_GENERATE_LE
9880 | OPTS_TYPE_ST_HEX;
9881 kern_type = KERN_TYPE_CRC32;
9882 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9883 parse_func = crc32_parse_hash;
9884 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9885 opti_type = OPTI_TYPE_ZERO_BYTE;
9886 dgst_pos0 = 0;
9887 dgst_pos1 = 1;
9888 dgst_pos2 = 2;
9889 dgst_pos3 = 3;
9890 break;
9891
9892 case 11600: hash_type = HASH_TYPE_AES;
9893 salt_type = SALT_TYPE_EMBEDDED;
9894 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9895 opts_type = OPTS_TYPE_PT_GENERATE_LE
9896 | OPTS_TYPE_PT_NEVERCRACK;
9897 kern_type = KERN_TYPE_SEVEN_ZIP;
9898 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9899 parse_func = seven_zip_parse_hash;
9900 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9901 opti_type = OPTI_TYPE_ZERO_BYTE;
9902 dgst_pos0 = 0;
9903 dgst_pos1 = 1;
9904 dgst_pos2 = 2;
9905 dgst_pos3 = 3;
9906 break;
9907
9908 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9909 salt_type = SALT_TYPE_NONE;
9910 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9911 opts_type = OPTS_TYPE_PT_GENERATE_LE
9912 | OPTS_TYPE_PT_ADD01;
9913 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9914 dgst_size = DGST_SIZE_4_8;
9915 parse_func = gost2012sbog_256_parse_hash;
9916 sort_by_digest = sort_by_digest_4_8;
9917 opti_type = OPTI_TYPE_ZERO_BYTE;
9918 dgst_pos0 = 0;
9919 dgst_pos1 = 1;
9920 dgst_pos2 = 2;
9921 dgst_pos3 = 3;
9922 break;
9923
9924 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9925 salt_type = SALT_TYPE_NONE;
9926 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9927 opts_type = OPTS_TYPE_PT_GENERATE_LE
9928 | OPTS_TYPE_PT_ADD01;
9929 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9930 dgst_size = DGST_SIZE_4_16;
9931 parse_func = gost2012sbog_512_parse_hash;
9932 sort_by_digest = sort_by_digest_4_16;
9933 opti_type = OPTI_TYPE_ZERO_BYTE;
9934 dgst_pos0 = 0;
9935 dgst_pos1 = 1;
9936 dgst_pos2 = 2;
9937 dgst_pos3 = 3;
9938 break;
9939
9940 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9941 salt_type = SALT_TYPE_EMBEDDED;
9942 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9943 opts_type = OPTS_TYPE_PT_GENERATE_LE
9944 | OPTS_TYPE_ST_BASE64
9945 | OPTS_TYPE_HASH_COPY;
9946 kern_type = KERN_TYPE_PBKDF2_MD5;
9947 dgst_size = DGST_SIZE_4_32;
9948 parse_func = pbkdf2_md5_parse_hash;
9949 sort_by_digest = sort_by_digest_4_32;
9950 opti_type = OPTI_TYPE_ZERO_BYTE;
9951 dgst_pos0 = 0;
9952 dgst_pos1 = 1;
9953 dgst_pos2 = 2;
9954 dgst_pos3 = 3;
9955 break;
9956
9957 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9958 salt_type = SALT_TYPE_EMBEDDED;
9959 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9960 opts_type = OPTS_TYPE_PT_GENERATE_LE
9961 | OPTS_TYPE_ST_BASE64
9962 | OPTS_TYPE_HASH_COPY;
9963 kern_type = KERN_TYPE_PBKDF2_SHA1;
9964 dgst_size = DGST_SIZE_4_32;
9965 parse_func = pbkdf2_sha1_parse_hash;
9966 sort_by_digest = sort_by_digest_4_32;
9967 opti_type = OPTI_TYPE_ZERO_BYTE;
9968 dgst_pos0 = 0;
9969 dgst_pos1 = 1;
9970 dgst_pos2 = 2;
9971 dgst_pos3 = 3;
9972 break;
9973
9974 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9975 salt_type = SALT_TYPE_EMBEDDED;
9976 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9977 opts_type = OPTS_TYPE_PT_GENERATE_LE
9978 | OPTS_TYPE_ST_BASE64
9979 | OPTS_TYPE_HASH_COPY;
9980 kern_type = KERN_TYPE_PBKDF2_SHA512;
9981 dgst_size = DGST_SIZE_8_16;
9982 parse_func = pbkdf2_sha512_parse_hash;
9983 sort_by_digest = sort_by_digest_8_16;
9984 opti_type = OPTI_TYPE_ZERO_BYTE
9985 | OPTI_TYPE_USES_BITS_64;
9986 dgst_pos0 = 0;
9987 dgst_pos1 = 1;
9988 dgst_pos2 = 2;
9989 dgst_pos3 = 3;
9990 break;
9991
9992 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9993 salt_type = SALT_TYPE_EMBEDDED;
9994 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9995 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9996 kern_type = KERN_TYPE_ECRYPTFS;
9997 dgst_size = DGST_SIZE_8_8;
9998 parse_func = ecryptfs_parse_hash;
9999 sort_by_digest = sort_by_digest_8_8;
10000 opti_type = OPTI_TYPE_ZERO_BYTE
10001 | OPTI_TYPE_USES_BITS_64;
10002 dgst_pos0 = 0;
10003 dgst_pos1 = 1;
10004 dgst_pos2 = 2;
10005 dgst_pos3 = 3;
10006 break;
10007
10008 case 12300: hash_type = HASH_TYPE_ORACLET;
10009 salt_type = SALT_TYPE_EMBEDDED;
10010 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10011 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10012 kern_type = KERN_TYPE_ORACLET;
10013 dgst_size = DGST_SIZE_8_16;
10014 parse_func = oraclet_parse_hash;
10015 sort_by_digest = sort_by_digest_8_16;
10016 opti_type = OPTI_TYPE_ZERO_BYTE
10017 | OPTI_TYPE_USES_BITS_64;
10018 dgst_pos0 = 0;
10019 dgst_pos1 = 1;
10020 dgst_pos2 = 2;
10021 dgst_pos3 = 3;
10022 break;
10023
10024 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10025 salt_type = SALT_TYPE_EMBEDDED;
10026 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10027 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10028 kern_type = KERN_TYPE_BSDICRYPT;
10029 dgst_size = DGST_SIZE_4_4;
10030 parse_func = bsdicrypt_parse_hash;
10031 sort_by_digest = sort_by_digest_4_4;
10032 opti_type = OPTI_TYPE_ZERO_BYTE
10033 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10034 dgst_pos0 = 0;
10035 dgst_pos1 = 1;
10036 dgst_pos2 = 2;
10037 dgst_pos3 = 3;
10038 break;
10039
10040 case 12500: hash_type = HASH_TYPE_RAR3HP;
10041 salt_type = SALT_TYPE_EMBEDDED;
10042 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10043 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10044 kern_type = KERN_TYPE_RAR3;
10045 dgst_size = DGST_SIZE_4_4;
10046 parse_func = rar3hp_parse_hash;
10047 sort_by_digest = sort_by_digest_4_4;
10048 opti_type = OPTI_TYPE_ZERO_BYTE;
10049 dgst_pos0 = 0;
10050 dgst_pos1 = 1;
10051 dgst_pos2 = 2;
10052 dgst_pos3 = 3;
10053 break;
10054
10055 case 12600: hash_type = HASH_TYPE_SHA256;
10056 salt_type = SALT_TYPE_INTERN;
10057 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10058 opts_type = OPTS_TYPE_PT_GENERATE_BE
10059 | OPTS_TYPE_PT_ADD80;
10060 kern_type = KERN_TYPE_CF10;
10061 dgst_size = DGST_SIZE_4_8;
10062 parse_func = cf10_parse_hash;
10063 sort_by_digest = sort_by_digest_4_8;
10064 opti_type = OPTI_TYPE_ZERO_BYTE
10065 | OPTI_TYPE_PRECOMPUTE_INIT
10066 | OPTI_TYPE_EARLY_SKIP
10067 | OPTI_TYPE_NOT_ITERATED;
10068 dgst_pos0 = 3;
10069 dgst_pos1 = 7;
10070 dgst_pos2 = 2;
10071 dgst_pos3 = 6;
10072 break;
10073
10074 case 12700: hash_type = HASH_TYPE_AES;
10075 salt_type = SALT_TYPE_EMBEDDED;
10076 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10077 opts_type = OPTS_TYPE_PT_GENERATE_LE
10078 | OPTS_TYPE_HASH_COPY;
10079 kern_type = KERN_TYPE_MYWALLET;
10080 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10081 parse_func = mywallet_parse_hash;
10082 sort_by_digest = sort_by_digest_4_5;
10083 opti_type = OPTI_TYPE_ZERO_BYTE;
10084 dgst_pos0 = 0;
10085 dgst_pos1 = 1;
10086 dgst_pos2 = 2;
10087 dgst_pos3 = 3;
10088 break;
10089
10090 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10091 salt_type = SALT_TYPE_EMBEDDED;
10092 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10093 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10094 kern_type = KERN_TYPE_MS_DRSR;
10095 dgst_size = DGST_SIZE_4_8;
10096 parse_func = ms_drsr_parse_hash;
10097 sort_by_digest = sort_by_digest_4_8;
10098 opti_type = OPTI_TYPE_ZERO_BYTE;
10099 dgst_pos0 = 0;
10100 dgst_pos1 = 1;
10101 dgst_pos2 = 2;
10102 dgst_pos3 = 3;
10103 break;
10104
10105 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10106 salt_type = SALT_TYPE_EMBEDDED;
10107 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10108 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10109 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10110 dgst_size = DGST_SIZE_4_8;
10111 parse_func = androidfde_samsung_parse_hash;
10112 sort_by_digest = sort_by_digest_4_8;
10113 opti_type = OPTI_TYPE_ZERO_BYTE;
10114 dgst_pos0 = 0;
10115 dgst_pos1 = 1;
10116 dgst_pos2 = 2;
10117 dgst_pos3 = 3;
10118 break;
10119
10120 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10121 salt_type = SALT_TYPE_EMBEDDED;
10122 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10123 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10124 kern_type = KERN_TYPE_RAR5;
10125 dgst_size = DGST_SIZE_4_4;
10126 parse_func = rar5_parse_hash;
10127 sort_by_digest = sort_by_digest_4_4;
10128 opti_type = OPTI_TYPE_ZERO_BYTE;
10129 dgst_pos0 = 0;
10130 dgst_pos1 = 1;
10131 dgst_pos2 = 2;
10132 dgst_pos3 = 3;
10133 break;
10134
10135 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10136 salt_type = SALT_TYPE_EMBEDDED;
10137 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10138 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10139 kern_type = KERN_TYPE_KRB5TGS;
10140 dgst_size = DGST_SIZE_4_4;
10141 parse_func = krb5tgs_parse_hash;
10142 sort_by_digest = sort_by_digest_4_4;
10143 opti_type = OPTI_TYPE_ZERO_BYTE
10144 | OPTI_TYPE_NOT_ITERATED;
10145 dgst_pos0 = 0;
10146 dgst_pos1 = 1;
10147 dgst_pos2 = 2;
10148 dgst_pos3 = 3;
10149 break;
10150
10151 case 13200: hash_type = HASH_TYPE_AES;
10152 salt_type = SALT_TYPE_EMBEDDED;
10153 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10154 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10155 kern_type = KERN_TYPE_AXCRYPT;
10156 dgst_size = DGST_SIZE_4_4;
10157 parse_func = axcrypt_parse_hash;
10158 sort_by_digest = sort_by_digest_4_4;
10159 opti_type = OPTI_TYPE_ZERO_BYTE;
10160 dgst_pos0 = 0;
10161 dgst_pos1 = 1;
10162 dgst_pos2 = 2;
10163 dgst_pos3 = 3;
10164 break;
10165
10166 case 13300: hash_type = HASH_TYPE_SHA1;
10167 salt_type = SALT_TYPE_NONE;
10168 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10169 opts_type = OPTS_TYPE_PT_GENERATE_BE
10170 | OPTS_TYPE_PT_ADD80
10171 | OPTS_TYPE_PT_ADDBITS15;
10172 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10173 dgst_size = DGST_SIZE_4_5;
10174 parse_func = sha1axcrypt_parse_hash;
10175 sort_by_digest = sort_by_digest_4_5;
10176 opti_type = OPTI_TYPE_ZERO_BYTE
10177 | OPTI_TYPE_PRECOMPUTE_INIT
10178 | OPTI_TYPE_EARLY_SKIP
10179 | OPTI_TYPE_NOT_ITERATED
10180 | OPTI_TYPE_NOT_SALTED;
10181 dgst_pos0 = 0;
10182 dgst_pos1 = 4;
10183 dgst_pos2 = 3;
10184 dgst_pos3 = 2;
10185 break;
10186
10187 case 13400: hash_type = HASH_TYPE_AES;
10188 salt_type = SALT_TYPE_EMBEDDED;
10189 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10190 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10191 kern_type = KERN_TYPE_KEEPASS;
10192 dgst_size = DGST_SIZE_4_4;
10193 parse_func = keepass_parse_hash;
10194 sort_by_digest = sort_by_digest_4_4;
10195 opti_type = OPTI_TYPE_ZERO_BYTE;
10196 dgst_pos0 = 0;
10197 dgst_pos1 = 1;
10198 dgst_pos2 = 2;
10199 dgst_pos3 = 3;
10200 break;
10201
10202 case 13500: hash_type = HASH_TYPE_SHA1;
10203 salt_type = SALT_TYPE_EMBEDDED;
10204 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10205 opts_type = OPTS_TYPE_PT_GENERATE_BE
10206 | OPTS_TYPE_PT_UNICODE
10207 | OPTS_TYPE_PT_ADD80;
10208 kern_type = KERN_TYPE_PSTOKEN;
10209 dgst_size = DGST_SIZE_4_5;
10210 parse_func = pstoken_parse_hash;
10211 sort_by_digest = sort_by_digest_4_5;
10212 opti_type = OPTI_TYPE_ZERO_BYTE
10213 | OPTI_TYPE_PRECOMPUTE_INIT
10214 | OPTI_TYPE_EARLY_SKIP
10215 | OPTI_TYPE_NOT_ITERATED
10216 | OPTI_TYPE_PREPENDED_SALT
10217 | OPTI_TYPE_RAW_HASH;
10218 dgst_pos0 = 3;
10219 dgst_pos1 = 4;
10220 dgst_pos2 = 2;
10221 dgst_pos3 = 1;
10222 break;
10223
10224 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10225 salt_type = SALT_TYPE_EMBEDDED;
10226 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10227 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10228 kern_type = KERN_TYPE_ZIP2;
10229 dgst_size = DGST_SIZE_4_4;
10230 parse_func = zip2_parse_hash;
10231 sort_by_digest = sort_by_digest_4_4;
10232 opti_type = OPTI_TYPE_ZERO_BYTE;
10233 dgst_pos0 = 0;
10234 dgst_pos1 = 1;
10235 dgst_pos2 = 2;
10236 dgst_pos3 = 3;
10237 break;
10238
10239 default: usage_mini_print (PROGNAME); return (-1);
10240 }
10241
10242 /**
10243 * parser
10244 */
10245
10246 data.parse_func = parse_func;
10247
10248 /**
10249 * misc stuff
10250 */
10251
10252 if (hex_salt)
10253 {
10254 if (salt_type == SALT_TYPE_INTERN)
10255 {
10256 opts_type |= OPTS_TYPE_ST_HEX;
10257 }
10258 else
10259 {
10260 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10261
10262 return (-1);
10263 }
10264 }
10265
10266 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10267 | (salt_type == SALT_TYPE_EXTERN)
10268 | (salt_type == SALT_TYPE_EMBEDDED)
10269 | (salt_type == SALT_TYPE_VIRTUAL));
10270
10271 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10272
10273 data.hash_type = hash_type;
10274 data.attack_mode = attack_mode;
10275 data.attack_kern = attack_kern;
10276 data.attack_exec = attack_exec;
10277 data.kern_type = kern_type;
10278 data.opts_type = opts_type;
10279 data.dgst_size = dgst_size;
10280 data.salt_type = salt_type;
10281 data.isSalted = isSalted;
10282 data.sort_by_digest = sort_by_digest;
10283 data.dgst_pos0 = dgst_pos0;
10284 data.dgst_pos1 = dgst_pos1;
10285 data.dgst_pos2 = dgst_pos2;
10286 data.dgst_pos3 = dgst_pos3;
10287
10288 esalt_size = 0;
10289
10290 switch (hash_mode)
10291 {
10292 case 2500: esalt_size = sizeof (wpa_t); break;
10293 case 5300: esalt_size = sizeof (ikepsk_t); break;
10294 case 5400: esalt_size = sizeof (ikepsk_t); break;
10295 case 5500: esalt_size = sizeof (netntlm_t); break;
10296 case 5600: esalt_size = sizeof (netntlm_t); break;
10297 case 6211: esalt_size = sizeof (tc_t); break;
10298 case 6212: esalt_size = sizeof (tc_t); break;
10299 case 6213: esalt_size = sizeof (tc_t); break;
10300 case 6221: esalt_size = sizeof (tc_t); break;
10301 case 6222: esalt_size = sizeof (tc_t); break;
10302 case 6223: esalt_size = sizeof (tc_t); break;
10303 case 6231: esalt_size = sizeof (tc_t); break;
10304 case 6232: esalt_size = sizeof (tc_t); break;
10305 case 6233: esalt_size = sizeof (tc_t); break;
10306 case 6241: esalt_size = sizeof (tc_t); break;
10307 case 6242: esalt_size = sizeof (tc_t); break;
10308 case 6243: esalt_size = sizeof (tc_t); break;
10309 case 6600: esalt_size = sizeof (agilekey_t); break;
10310 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10311 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10312 case 7300: esalt_size = sizeof (rakp_t); break;
10313 case 7500: esalt_size = sizeof (krb5pa_t); break;
10314 case 8200: esalt_size = sizeof (cloudkey_t); break;
10315 case 8800: esalt_size = sizeof (androidfde_t); break;
10316 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10317 case 9400: esalt_size = sizeof (office2007_t); break;
10318 case 9500: esalt_size = sizeof (office2010_t); break;
10319 case 9600: esalt_size = sizeof (office2013_t); break;
10320 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10321 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10322 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10323 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10324 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10325 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10326 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10327 case 10200: esalt_size = sizeof (cram_md5_t); break;
10328 case 10400: esalt_size = sizeof (pdf_t); break;
10329 case 10410: esalt_size = sizeof (pdf_t); break;
10330 case 10420: esalt_size = sizeof (pdf_t); break;
10331 case 10500: esalt_size = sizeof (pdf_t); break;
10332 case 10600: esalt_size = sizeof (pdf_t); break;
10333 case 10700: esalt_size = sizeof (pdf_t); break;
10334 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10335 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10336 case 11400: esalt_size = sizeof (sip_t); break;
10337 case 11600: esalt_size = sizeof (seven_zip_t); break;
10338 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10339 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10340 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10341 case 13000: esalt_size = sizeof (rar5_t); break;
10342 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10343 case 13400: esalt_size = sizeof (keepass_t); break;
10344 case 13500: esalt_size = sizeof (pstoken_t); break;
10345 case 13600: esalt_size = sizeof (zip2_t); break;
10346 }
10347
10348 data.esalt_size = esalt_size;
10349
10350 /**
10351 * choose dictionary parser
10352 */
10353
10354 if (hash_type == HASH_TYPE_LM)
10355 {
10356 get_next_word_func = get_next_word_lm;
10357 }
10358 else if (opts_type & OPTS_TYPE_PT_UPPER)
10359 {
10360 get_next_word_func = get_next_word_uc;
10361 }
10362 else
10363 {
10364 get_next_word_func = get_next_word_std;
10365 }
10366
10367 /**
10368 * dictstat
10369 */
10370
10371 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10372
10373 #ifdef _POSIX
10374 size_t dictstat_nmemb = 0;
10375 #endif
10376
10377 #ifdef _WIN
10378 uint dictstat_nmemb = 0;
10379 #endif
10380
10381 char dictstat[256] = { 0 };
10382
10383 FILE *dictstat_fp = NULL;
10384
10385 if (keyspace == 0)
10386 {
10387 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10388
10389 dictstat_fp = fopen (dictstat, "rb");
10390
10391 if (dictstat_fp)
10392 {
10393 #ifdef _POSIX
10394 struct stat tmpstat;
10395
10396 fstat (fileno (dictstat_fp), &tmpstat);
10397 #endif
10398
10399 #ifdef _WIN
10400 struct stat64 tmpstat;
10401
10402 _fstat64 (fileno (dictstat_fp), &tmpstat);
10403 #endif
10404
10405 if (tmpstat.st_mtime < COMPTIME)
10406 {
10407 /* with v0.15 the format changed so we have to ensure user is using a good version
10408 since there is no version-header in the dictstat file */
10409
10410 fclose (dictstat_fp);
10411
10412 unlink (dictstat);
10413 }
10414 else
10415 {
10416 while (!feof (dictstat_fp))
10417 {
10418 dictstat_t d;
10419
10420 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10421
10422 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10423
10424 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10425 {
10426 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10427
10428 return -1;
10429 }
10430 }
10431
10432 fclose (dictstat_fp);
10433 }
10434 }
10435 }
10436
10437 /**
10438 * potfile
10439 */
10440
10441 char potfile[256] = { 0 };
10442
10443 if (potfile_path == NULL)
10444 {
10445 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10446 }
10447 else
10448 {
10449 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10450 }
10451
10452 data.pot_fp = NULL;
10453
10454 FILE *out_fp = NULL;
10455 FILE *pot_fp = NULL;
10456
10457 if (show == 1 || left == 1)
10458 {
10459 pot_fp = fopen (potfile, "rb");
10460
10461 if (pot_fp == NULL)
10462 {
10463 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10464
10465 return (-1);
10466 }
10467
10468 if (outfile != NULL)
10469 {
10470 if ((out_fp = fopen (outfile, "ab")) == NULL)
10471 {
10472 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10473
10474 fclose (pot_fp);
10475
10476 return (-1);
10477 }
10478 }
10479 else
10480 {
10481 out_fp = stdout;
10482 }
10483 }
10484 else
10485 {
10486 if (potfile_disable == 0)
10487 {
10488 pot_fp = fopen (potfile, "ab");
10489
10490 if (pot_fp == NULL)
10491 {
10492 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10493
10494 return (-1);
10495 }
10496
10497 data.pot_fp = pot_fp;
10498 }
10499 }
10500
10501 pot_t *pot = NULL;
10502
10503 uint pot_cnt = 0;
10504 uint pot_avail = 0;
10505
10506 if (show == 1 || left == 1)
10507 {
10508 SUPPRESS_OUTPUT = 1;
10509
10510 pot_avail = count_lines (pot_fp);
10511
10512 rewind (pot_fp);
10513
10514 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10515
10516 uint pot_hashes_avail = 0;
10517
10518 uint line_num = 0;
10519
10520 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10521
10522 while (!feof (pot_fp))
10523 {
10524 line_num++;
10525
10526 int line_len = fgetl (pot_fp, line_buf);
10527
10528 if (line_len == 0) continue;
10529
10530 char *plain_buf = line_buf + line_len;
10531
10532 pot_t *pot_ptr = &pot[pot_cnt];
10533
10534 hash_t *hashes_buf = &pot_ptr->hash;
10535
10536 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10537 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10538
10539 if (pot_cnt == pot_hashes_avail)
10540 {
10541 uint pos = 0;
10542
10543 for (pos = 0; pos < INCR_POT; pos++)
10544 {
10545 if ((pot_cnt + pos) >= pot_avail) break;
10546
10547 pot_t *tmp_pot = &pot[pot_cnt + pos];
10548
10549 hash_t *tmp_hash = &tmp_pot->hash;
10550
10551 tmp_hash->digest = mymalloc (dgst_size);
10552
10553 if (isSalted)
10554 {
10555 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10556 }
10557
10558 if (esalt_size)
10559 {
10560 tmp_hash->esalt = mymalloc (esalt_size);
10561 }
10562
10563 pot_hashes_avail++;
10564 }
10565 }
10566
10567 int plain_len = 0;
10568
10569 int parser_status;
10570
10571 int iter = MAX_CUT_TRIES;
10572
10573 do
10574 {
10575 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10576 {
10577 if (line_buf[i] == ':')
10578 {
10579 line_len--;
10580
10581 break;
10582 }
10583 }
10584
10585 if (data.hash_mode != 2500)
10586 {
10587 parser_status = parse_func (line_buf, line_len, hashes_buf);
10588 }
10589 else
10590 {
10591 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10592
10593 if (line_len > max_salt_size)
10594 {
10595 parser_status = PARSER_GLOBAL_LENGTH;
10596 }
10597 else
10598 {
10599 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10600
10601 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10602
10603 hashes_buf->salt->salt_len = line_len;
10604
10605 parser_status = PARSER_OK;
10606 }
10607 }
10608
10609 // if NOT parsed without error, we add the ":" to the plain
10610
10611 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10612 {
10613 plain_len++;
10614 plain_buf--;
10615 }
10616
10617 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10618
10619 if (parser_status < PARSER_GLOBAL_ZERO)
10620 {
10621 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10622
10623 continue;
10624 }
10625
10626 if (plain_len >= 255) continue;
10627
10628 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10629
10630 pot_ptr->plain_len = plain_len;
10631
10632 pot_cnt++;
10633 }
10634
10635 myfree (line_buf);
10636
10637 fclose (pot_fp);
10638
10639 SUPPRESS_OUTPUT = 0;
10640
10641 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10642 }
10643
10644 /**
10645 * word len
10646 */
10647
10648 uint pw_min = PW_MIN;
10649 uint pw_max = PW_MAX;
10650
10651 switch (hash_mode)
10652 {
10653 case 125: if (pw_max > 32) pw_max = 32;
10654 break;
10655 case 400: if (pw_max > 40) pw_max = 40;
10656 break;
10657 case 500: if (pw_max > 16) pw_max = 16;
10658 break;
10659 case 1500: if (pw_max > 8) pw_max = 8;
10660 break;
10661 case 1600: if (pw_max > 16) pw_max = 16;
10662 break;
10663 case 1800: if (pw_max > 16) pw_max = 16;
10664 break;
10665 case 2100: if (pw_max > 16) pw_max = 16;
10666 break;
10667 case 2500: if (pw_min < 8) pw_min = 8;
10668 break;
10669 case 3000: if (pw_max > 7) pw_max = 7;
10670 break;
10671 case 5200: if (pw_max > 24) pw_max = 24;
10672 break;
10673 case 5800: if (pw_max > 16) pw_max = 16;
10674 break;
10675 case 6300: if (pw_max > 16) pw_max = 16;
10676 break;
10677 case 7400: if (pw_max > 16) pw_max = 16;
10678 break;
10679 case 7900: if (pw_max > 48) pw_max = 48;
10680 break;
10681 case 8500: if (pw_max > 8) pw_max = 8;
10682 break;
10683 case 8600: if (pw_max > 16) pw_max = 16;
10684 break;
10685 case 9710: pw_min = 5;
10686 pw_max = 5;
10687 break;
10688 case 9810: pw_min = 5;
10689 pw_max = 5;
10690 break;
10691 case 10410: pw_min = 5;
10692 pw_max = 5;
10693 break;
10694 case 10300: if (pw_max < 3) pw_min = 3;
10695 if (pw_max > 40) pw_max = 40;
10696 break;
10697 case 10500: if (pw_max < 3) pw_min = 3;
10698 if (pw_max > 40) pw_max = 40;
10699 break;
10700 case 10700: if (pw_max > 16) pw_max = 16;
10701 break;
10702 case 11300: if (pw_max > 40) pw_max = 40;
10703 break;
10704 case 11600: if (pw_max > 32) pw_max = 32;
10705 break;
10706 case 12500: if (pw_max > 20) pw_max = 20;
10707 break;
10708 case 12800: if (pw_max > 24) pw_max = 24;
10709 break;
10710 }
10711
10712 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10713 {
10714 switch (attack_kern)
10715 {
10716 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10717 break;
10718 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10719 break;
10720 }
10721 }
10722
10723 /**
10724 * charsets : keep them together for more easy maintainnce
10725 */
10726
10727 cs_t mp_sys[6] = { { { 0 }, 0 } };
10728 cs_t mp_usr[4] = { { { 0 }, 0 } };
10729
10730 mp_setup_sys (mp_sys);
10731
10732 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10733 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10734 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10735 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10736
10737 /**
10738 * load hashes, part I: find input mode, count hashes
10739 */
10740
10741 uint hashlist_mode = 0;
10742 uint hashlist_format = HLFMT_HASHCAT;
10743
10744 uint hashes_avail = 0;
10745
10746 if (benchmark == 0)
10747 {
10748 struct stat f;
10749
10750 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10751
10752 if ((hash_mode == 2500) ||
10753 (hash_mode == 5200) ||
10754 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10755 (hash_mode == 9000))
10756 {
10757 hashlist_mode = HL_MODE_ARG;
10758
10759 char *hashfile = myargv[optind];
10760
10761 data.hashfile = hashfile;
10762
10763 logfile_top_var_string ("target", hashfile);
10764 }
10765
10766 if (hashlist_mode == HL_MODE_ARG)
10767 {
10768 if (hash_mode == 2500)
10769 {
10770 struct stat st;
10771
10772 if (stat (data.hashfile, &st) == -1)
10773 {
10774 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10775
10776 return (-1);
10777 }
10778
10779 hashes_avail = st.st_size / sizeof (hccap_t);
10780 }
10781 else
10782 {
10783 hashes_avail = 1;
10784 }
10785 }
10786 else if (hashlist_mode == HL_MODE_FILE)
10787 {
10788 char *hashfile = myargv[optind];
10789
10790 data.hashfile = hashfile;
10791
10792 logfile_top_var_string ("target", hashfile);
10793
10794 FILE *fp = NULL;
10795
10796 if ((fp = fopen (hashfile, "rb")) == NULL)
10797 {
10798 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10799
10800 return (-1);
10801 }
10802
10803 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10804
10805 hashes_avail = count_lines (fp);
10806
10807 rewind (fp);
10808
10809 if (hashes_avail == 0)
10810 {
10811 log_error ("ERROR: hashfile is empty or corrupt");
10812
10813 fclose (fp);
10814
10815 return (-1);
10816 }
10817
10818 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10819
10820 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10821 {
10822 log_error ("ERROR: remove not supported in native hashfile-format mode");
10823
10824 fclose (fp);
10825
10826 return (-1);
10827 }
10828
10829 fclose (fp);
10830 }
10831 }
10832 else
10833 {
10834 hashlist_mode = HL_MODE_ARG;
10835
10836 hashes_avail = 1;
10837 }
10838
10839 if (hash_mode == 3000) hashes_avail *= 2;
10840
10841 data.hashlist_mode = hashlist_mode;
10842 data.hashlist_format = hashlist_format;
10843
10844 logfile_top_uint (hashlist_mode);
10845 logfile_top_uint (hashlist_format);
10846
10847 /**
10848 * load hashes, part II: allocate required memory, set pointers
10849 */
10850
10851 hash_t *hashes_buf = NULL;
10852 void *digests_buf = NULL;
10853 salt_t *salts_buf = NULL;
10854 void *esalts_buf = NULL;
10855
10856 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10857
10858 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10859
10860 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10861 {
10862 u32 hash_pos;
10863
10864 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10865 {
10866 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10867
10868 hashes_buf[hash_pos].hash_info = hash_info;
10869
10870 if (username && (remove || show || left))
10871 {
10872 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10873 }
10874
10875 if (benchmark)
10876 {
10877 hash_info->orighash = (char *) mymalloc (256);
10878 }
10879 }
10880 }
10881
10882 if (isSalted)
10883 {
10884 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10885
10886 if (esalt_size)
10887 {
10888 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10889 }
10890 }
10891 else
10892 {
10893 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10894 }
10895
10896 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10897 {
10898 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10899
10900 if (isSalted)
10901 {
10902 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10903
10904 if (esalt_size)
10905 {
10906 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10907 }
10908 }
10909 else
10910 {
10911 hashes_buf[hash_pos].salt = &salts_buf[0];
10912 }
10913 }
10914
10915 /**
10916 * load hashes, part III: parse hashes or generate them if benchmark
10917 */
10918
10919 uint hashes_cnt = 0;
10920
10921 if (benchmark == 0)
10922 {
10923 if (keyspace == 1)
10924 {
10925 // useless to read hash file for keyspace, cheat a little bit w/ optind
10926 }
10927 else if (hashes_avail == 0)
10928 {
10929 }
10930 else if (hashlist_mode == HL_MODE_ARG)
10931 {
10932 char *input_buf = myargv[optind];
10933
10934 uint input_len = strlen (input_buf);
10935
10936 logfile_top_var_string ("target", input_buf);
10937
10938 char *hash_buf = NULL;
10939 int hash_len = 0;
10940
10941 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10942
10943 bool hash_fmt_error = 0;
10944
10945 if (hash_len < 1) hash_fmt_error = 1;
10946 if (hash_buf == NULL) hash_fmt_error = 1;
10947
10948 if (hash_fmt_error)
10949 {
10950 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
10951 }
10952 else
10953 {
10954 if (opts_type & OPTS_TYPE_HASH_COPY)
10955 {
10956 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10957
10958 hash_info_tmp->orighash = mystrdup (hash_buf);
10959 }
10960
10961 if (isSalted)
10962 {
10963 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10964 }
10965
10966 int parser_status = PARSER_OK;
10967
10968 if (hash_mode == 2500)
10969 {
10970 if (hash_len == 0)
10971 {
10972 log_error ("ERROR: hccap file not specified");
10973
10974 return (-1);
10975 }
10976
10977 hashlist_mode = HL_MODE_FILE;
10978
10979 data.hashlist_mode = hashlist_mode;
10980
10981 FILE *fp = fopen (hash_buf, "rb");
10982
10983 if (fp == NULL)
10984 {
10985 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10986
10987 return (-1);
10988 }
10989
10990 if (hashes_avail < 1)
10991 {
10992 log_error ("ERROR: hccap file is empty or corrupt");
10993
10994 fclose (fp);
10995
10996 return (-1);
10997 }
10998
10999 uint hccap_size = sizeof (hccap_t);
11000
11001 char *in = (char *) mymalloc (hccap_size);
11002
11003 while (!feof (fp))
11004 {
11005 int n = fread (in, hccap_size, 1, fp);
11006
11007 if (n != 1)
11008 {
11009 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11010
11011 break;
11012 }
11013
11014 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11015
11016 if (parser_status != PARSER_OK)
11017 {
11018 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11019
11020 continue;
11021 }
11022
11023 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11024
11025 if ((show == 1) || (left == 1))
11026 {
11027 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11028
11029 char *salt_ptr = (char *) tmp_salt->salt_buf;
11030
11031 int cur_pos = tmp_salt->salt_len;
11032 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11033
11034 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11035
11036 // do the appending task
11037
11038 snprintf (salt_ptr + cur_pos,
11039 rem_len,
11040 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11041 wpa->orig_mac1[0],
11042 wpa->orig_mac1[1],
11043 wpa->orig_mac1[2],
11044 wpa->orig_mac1[3],
11045 wpa->orig_mac1[4],
11046 wpa->orig_mac1[5],
11047 wpa->orig_mac2[0],
11048 wpa->orig_mac2[1],
11049 wpa->orig_mac2[2],
11050 wpa->orig_mac2[3],
11051 wpa->orig_mac2[4],
11052 wpa->orig_mac2[5]);
11053
11054 // memset () the remaining part of the salt
11055
11056 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11057 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11058
11059 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11060
11061 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11062 }
11063
11064 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);
11065 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);
11066
11067 hashes_cnt++;
11068 }
11069
11070 fclose (fp);
11071
11072 myfree (in);
11073 }
11074 else if (hash_mode == 3000)
11075 {
11076 if (hash_len == 32)
11077 {
11078 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11079
11080 hash_t *lm_hash_left = NULL;
11081
11082 if (parser_status == PARSER_OK)
11083 {
11084 lm_hash_left = &hashes_buf[hashes_cnt];
11085
11086 hashes_cnt++;
11087 }
11088 else
11089 {
11090 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11091 }
11092
11093 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11094
11095 hash_t *lm_hash_right = NULL;
11096
11097 if (parser_status == PARSER_OK)
11098 {
11099 lm_hash_right = &hashes_buf[hashes_cnt];
11100
11101 hashes_cnt++;
11102 }
11103 else
11104 {
11105 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11106 }
11107
11108 // show / left
11109
11110 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11111 {
11112 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);
11113 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);
11114 }
11115 }
11116 else
11117 {
11118 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11119
11120 if (parser_status == PARSER_OK)
11121 {
11122 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11123 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11124 }
11125
11126 if (parser_status == PARSER_OK)
11127 {
11128 hashes_cnt++;
11129 }
11130 else
11131 {
11132 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11133 }
11134 }
11135 }
11136 else
11137 {
11138 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11139
11140 if (parser_status == PARSER_OK)
11141 {
11142 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11143 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11144 }
11145
11146 if (parser_status == PARSER_OK)
11147 {
11148 hashes_cnt++;
11149 }
11150 else
11151 {
11152 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11153 }
11154 }
11155 }
11156 }
11157 else if (hashlist_mode == HL_MODE_FILE)
11158 {
11159 char *hashfile = data.hashfile;
11160
11161 FILE *fp;
11162
11163 if ((fp = fopen (hashfile, "rb")) == NULL)
11164 {
11165 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11166
11167 return (-1);
11168 }
11169
11170 uint line_num = 0;
11171
11172 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11173
11174 while (!feof (fp))
11175 {
11176 line_num++;
11177
11178 int line_len = fgetl (fp, line_buf);
11179
11180 if (line_len == 0) continue;
11181
11182 char *hash_buf = NULL;
11183 int hash_len = 0;
11184
11185 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11186
11187 bool hash_fmt_error = 0;
11188
11189 if (hash_len < 1) hash_fmt_error = 1;
11190 if (hash_buf == NULL) hash_fmt_error = 1;
11191
11192 if (hash_fmt_error)
11193 {
11194 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11195
11196 continue;
11197 }
11198
11199 if (username)
11200 {
11201 char *user_buf = NULL;
11202 int user_len = 0;
11203
11204 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11205
11206 if (remove || show)
11207 {
11208 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11209
11210 *user = (user_t *) mymalloc (sizeof (user_t));
11211
11212 user_t *user_ptr = *user;
11213
11214 if (user_buf != NULL)
11215 {
11216 user_ptr->user_name = mystrdup (user_buf);
11217 }
11218 else
11219 {
11220 user_ptr->user_name = mystrdup ("");
11221 }
11222
11223 user_ptr->user_len = user_len;
11224 }
11225 }
11226
11227 if (opts_type & OPTS_TYPE_HASH_COPY)
11228 {
11229 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11230
11231 hash_info_tmp->orighash = mystrdup (hash_buf);
11232 }
11233
11234 if (isSalted)
11235 {
11236 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11237 }
11238
11239 if (hash_mode == 3000)
11240 {
11241 if (hash_len == 32)
11242 {
11243 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11244
11245 if (parser_status < PARSER_GLOBAL_ZERO)
11246 {
11247 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11248
11249 continue;
11250 }
11251
11252 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11253
11254 hashes_cnt++;
11255
11256 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11257
11258 if (parser_status < PARSER_GLOBAL_ZERO)
11259 {
11260 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11261
11262 continue;
11263 }
11264
11265 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11266
11267 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);
11268
11269 hashes_cnt++;
11270
11271 // show / left
11272
11273 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);
11274 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);
11275 }
11276 else
11277 {
11278 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11279
11280 if (parser_status < PARSER_GLOBAL_ZERO)
11281 {
11282 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11283
11284 continue;
11285 }
11286
11287 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);
11288
11289 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11290 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11291
11292 hashes_cnt++;
11293 }
11294 }
11295 else
11296 {
11297 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11298
11299 if (parser_status < PARSER_GLOBAL_ZERO)
11300 {
11301 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11302
11303 continue;
11304 }
11305
11306 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);
11307
11308 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11309 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11310
11311 hashes_cnt++;
11312 }
11313 }
11314
11315 myfree (line_buf);
11316
11317 fclose (fp);
11318
11319 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11320
11321 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11322 }
11323 }
11324 else
11325 {
11326 if (isSalted)
11327 {
11328 hashes_buf[0].salt->salt_len = 8;
11329
11330 // special salt handling
11331
11332 switch (hash_mode)
11333 {
11334 case 1500: hashes_buf[0].salt->salt_len = 2;
11335 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11336 break;
11337 case 1731: hashes_buf[0].salt->salt_len = 4;
11338 break;
11339 case 2410: hashes_buf[0].salt->salt_len = 4;
11340 break;
11341 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11342 break;
11343 case 3100: hashes_buf[0].salt->salt_len = 1;
11344 break;
11345 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11346 break;
11347 case 5800: hashes_buf[0].salt->salt_len = 16;
11348 break;
11349 case 6800: hashes_buf[0].salt->salt_len = 32;
11350 break;
11351 case 8400: hashes_buf[0].salt->salt_len = 40;
11352 break;
11353 case 8800: hashes_buf[0].salt->salt_len = 16;
11354 break;
11355 case 8900: hashes_buf[0].salt->salt_len = 16;
11356 hashes_buf[0].salt->scrypt_N = 1024;
11357 hashes_buf[0].salt->scrypt_r = 1;
11358 hashes_buf[0].salt->scrypt_p = 1;
11359 break;
11360 case 9100: hashes_buf[0].salt->salt_len = 16;
11361 break;
11362 case 9300: hashes_buf[0].salt->salt_len = 14;
11363 hashes_buf[0].salt->scrypt_N = 16384;
11364 hashes_buf[0].salt->scrypt_r = 1;
11365 hashes_buf[0].salt->scrypt_p = 1;
11366 break;
11367 case 9400: hashes_buf[0].salt->salt_len = 16;
11368 break;
11369 case 9500: hashes_buf[0].salt->salt_len = 16;
11370 break;
11371 case 9600: hashes_buf[0].salt->salt_len = 16;
11372 break;
11373 case 9700: hashes_buf[0].salt->salt_len = 16;
11374 break;
11375 case 9710: hashes_buf[0].salt->salt_len = 16;
11376 break;
11377 case 9720: hashes_buf[0].salt->salt_len = 16;
11378 break;
11379 case 9800: hashes_buf[0].salt->salt_len = 16;
11380 break;
11381 case 9810: hashes_buf[0].salt->salt_len = 16;
11382 break;
11383 case 9820: hashes_buf[0].salt->salt_len = 16;
11384 break;
11385 case 10300: hashes_buf[0].salt->salt_len = 12;
11386 break;
11387 case 11500: hashes_buf[0].salt->salt_len = 4;
11388 break;
11389 case 11600: hashes_buf[0].salt->salt_len = 4;
11390 break;
11391 case 12400: hashes_buf[0].salt->salt_len = 4;
11392 break;
11393 case 12500: hashes_buf[0].salt->salt_len = 8;
11394 break;
11395 case 12600: hashes_buf[0].salt->salt_len = 64;
11396 break;
11397 }
11398
11399 // special esalt handling
11400
11401 switch (hash_mode)
11402 {
11403 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11404 break;
11405 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11406 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11407 break;
11408 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11409 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11410 break;
11411 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11412 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11413 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11414 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11415 break;
11416 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11417 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11418 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11419 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11420 break;
11421 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11422 break;
11423 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11424 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11425 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11426 break;
11427 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11428 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11429 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11430 break;
11431 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11432 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11433 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11434 break;
11435 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11436 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11437 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11438 break;
11439 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11440 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11441 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11442 break;
11443 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11444 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11445 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11446 break;
11447 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11448 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11449 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11450 break;
11451 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11452 break;
11453 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
11454 break;
11455 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
11456 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
11457 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
11458 break;
11459 }
11460 }
11461
11462 // set hashfile
11463
11464 switch (hash_mode)
11465 {
11466 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11467 break;
11468 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11469 break;
11470 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11471 break;
11472 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11473 break;
11474 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11475 break;
11476 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11477 break;
11478 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11479 break;
11480 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11481 break;
11482 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11483 break;
11484 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11485 break;
11486 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11487 break;
11488 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11489 break;
11490 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11491 break;
11492 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11493 break;
11494 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11495 break;
11496 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11497 break;
11498 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11499 break;
11500 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11501 break;
11502 }
11503
11504 // set default iterations
11505
11506 switch (hash_mode)
11507 {
11508 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11509 break;
11510 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11511 break;
11512 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11513 break;
11514 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11515 break;
11516 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11517 break;
11518 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11519 break;
11520 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11521 break;
11522 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11523 break;
11524 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11525 break;
11526 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11527 break;
11528 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11529 break;
11530 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11531 break;
11532 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11533 break;
11534 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11535 break;
11536 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11537 break;
11538 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11539 break;
11540 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11541 break;
11542 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11543 break;
11544 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11545 break;
11546 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11547 break;
11548 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11549 break;
11550 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11551 break;
11552 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11553 break;
11554 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11555 break;
11556 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11557 break;
11558 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11559 break;
11560 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11561 break;
11562 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11563 break;
11564 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11565 break;
11566 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11567 break;
11568 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11569 break;
11570 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11571 break;
11572 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11573 break;
11574 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11575 break;
11576 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11577 break;
11578 case 8900: hashes_buf[0].salt->salt_iter = 1;
11579 break;
11580 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11581 break;
11582 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11583 break;
11584 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11585 break;
11586 case 9300: hashes_buf[0].salt->salt_iter = 1;
11587 break;
11588 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11589 break;
11590 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11591 break;
11592 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11593 break;
11594 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11595 break;
11596 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11597 break;
11598 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11599 break;
11600 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11601 break;
11602 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11603 break;
11604 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11605 break;
11606 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11607 break;
11608 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11609 break;
11610 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11611 break;
11612 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11613 break;
11614 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11615 break;
11616 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11617 break;
11618 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11619 break;
11620 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11621 break;
11622 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11623 break;
11624 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11625 break;
11626 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11627 break;
11628 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11629 break;
11630 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
11631 break;
11632 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
11633 break;
11634 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
11635 break;
11636 }
11637
11638 hashes_cnt = 1;
11639 }
11640
11641 if (show == 1 || left == 1)
11642 {
11643 for (uint i = 0; i < pot_cnt; i++)
11644 {
11645 pot_t *pot_ptr = &pot[i];
11646
11647 hash_t *hashes_buf = &pot_ptr->hash;
11648
11649 local_free (hashes_buf->digest);
11650
11651 if (isSalted)
11652 {
11653 local_free (hashes_buf->salt);
11654 }
11655 }
11656
11657 local_free (pot);
11658
11659 if (data.quiet == 0) log_info_nn ("");
11660
11661 return (0);
11662 }
11663
11664 if (keyspace == 0)
11665 {
11666 if (hashes_cnt == 0)
11667 {
11668 log_error ("ERROR: No hashes loaded");
11669
11670 return (-1);
11671 }
11672 }
11673
11674 /**
11675 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11676 */
11677
11678 if (data.outfile != NULL)
11679 {
11680 if (data.hashfile != NULL)
11681 {
11682 #ifdef _POSIX
11683 struct stat tmpstat_outfile;
11684 struct stat tmpstat_hashfile;
11685 #endif
11686
11687 #ifdef _WIN
11688 struct stat64 tmpstat_outfile;
11689 struct stat64 tmpstat_hashfile;
11690 #endif
11691
11692 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11693
11694 if (tmp_outfile_fp)
11695 {
11696 #ifdef _POSIX
11697 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11698 #endif
11699
11700 #ifdef _WIN
11701 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11702 #endif
11703
11704 fclose (tmp_outfile_fp);
11705 }
11706
11707 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11708
11709 if (tmp_hashfile_fp)
11710 {
11711 #ifdef _POSIX
11712 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11713 #endif
11714
11715 #ifdef _WIN
11716 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11717 #endif
11718
11719 fclose (tmp_hashfile_fp);
11720 }
11721
11722 if (tmp_outfile_fp && tmp_outfile_fp)
11723 {
11724 tmpstat_outfile.st_mode = 0;
11725 tmpstat_outfile.st_nlink = 0;
11726 tmpstat_outfile.st_uid = 0;
11727 tmpstat_outfile.st_gid = 0;
11728 tmpstat_outfile.st_rdev = 0;
11729 tmpstat_outfile.st_atime = 0;
11730
11731 tmpstat_hashfile.st_mode = 0;
11732 tmpstat_hashfile.st_nlink = 0;
11733 tmpstat_hashfile.st_uid = 0;
11734 tmpstat_hashfile.st_gid = 0;
11735 tmpstat_hashfile.st_rdev = 0;
11736 tmpstat_hashfile.st_atime = 0;
11737
11738 #ifdef _POSIX
11739 tmpstat_outfile.st_blksize = 0;
11740 tmpstat_outfile.st_blocks = 0;
11741
11742 tmpstat_hashfile.st_blksize = 0;
11743 tmpstat_hashfile.st_blocks = 0;
11744 #endif
11745
11746 #ifdef _POSIX
11747 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11748 {
11749 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11750
11751 return (-1);
11752 }
11753 #endif
11754
11755 #ifdef _WIN
11756 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11757 {
11758 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11759
11760 return (-1);
11761 }
11762 #endif
11763 }
11764 }
11765 }
11766
11767 /**
11768 * Remove duplicates
11769 */
11770
11771 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11772
11773 if (isSalted)
11774 {
11775 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11776 }
11777 else
11778 {
11779 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11780 }
11781
11782 uint hashes_cnt_orig = hashes_cnt;
11783
11784 hashes_cnt = 1;
11785
11786 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11787 {
11788 if (isSalted)
11789 {
11790 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11791 {
11792 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11793 }
11794 }
11795 else
11796 {
11797 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11798 }
11799
11800 if (hashes_pos > hashes_cnt)
11801 {
11802 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11803 }
11804
11805 hashes_cnt++;
11806 }
11807
11808 /**
11809 * Potfile removes
11810 */
11811
11812 uint potfile_remove_cracks = 0;
11813
11814 if (potfile_disable == 0)
11815 {
11816 hash_t hash_buf;
11817
11818 hash_buf.digest = mymalloc (dgst_size);
11819 hash_buf.salt = NULL;
11820 hash_buf.esalt = NULL;
11821 hash_buf.hash_info = NULL;
11822 hash_buf.cracked = 0;
11823
11824 if (isSalted)
11825 {
11826 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11827 }
11828
11829 if (esalt_size)
11830 {
11831 hash_buf.esalt = mymalloc (esalt_size);
11832 }
11833
11834 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11835
11836 // no solution for these special hash types (for instane because they use hashfile in output etc)
11837 if ((hash_mode != 5200) &&
11838 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11839 (hash_mode != 9000))
11840 {
11841 FILE *fp = fopen (potfile, "rb");
11842
11843 if (fp != NULL)
11844 {
11845 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11846
11847 // to be safe work with a copy (because of line_len loop, i etc)
11848 // moved up here because it's easier to handle continue case
11849 // it's just 64kb
11850
11851 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
11852
11853 while (!feof (fp))
11854 {
11855 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
11856
11857 if (ptr == NULL) break;
11858
11859 int line_len = strlen (line_buf);
11860
11861 if (line_len == 0) continue;
11862
11863 int iter = MAX_CUT_TRIES;
11864
11865 for (int i = line_len - 1; i && iter; i--, line_len--)
11866 {
11867 if (line_buf[i] != ':') continue;
11868
11869 if (isSalted)
11870 {
11871 memset (hash_buf.salt, 0, sizeof (salt_t));
11872 }
11873
11874 hash_t *found = NULL;
11875
11876 if (hash_mode == 6800)
11877 {
11878 if (i < 64) // 64 = 16 * uint in salt_buf[]
11879 {
11880 // manipulate salt_buf
11881 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11882
11883 hash_buf.salt->salt_len = i;
11884
11885 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11886 }
11887 }
11888 else if (hash_mode == 2500)
11889 {
11890 if (i < 64) // 64 = 16 * uint in salt_buf[]
11891 {
11892 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11893 // manipulate salt_buf
11894
11895 memcpy (line_buf_cpy, line_buf, i);
11896
11897 char *mac2_pos = strrchr (line_buf_cpy, ':');
11898
11899 if (mac2_pos == NULL) continue;
11900
11901 mac2_pos[0] = 0;
11902 mac2_pos++;
11903
11904 if (strlen (mac2_pos) != 12) continue;
11905
11906 char *mac1_pos = strrchr (line_buf_cpy, ':');
11907
11908 if (mac1_pos == NULL) continue;
11909
11910 mac1_pos[0] = 0;
11911 mac1_pos++;
11912
11913 if (strlen (mac1_pos) != 12) continue;
11914
11915 uint essid_length = mac1_pos - line_buf_cpy - 1;
11916
11917 // here we need the ESSID
11918 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11919
11920 hash_buf.salt->salt_len = essid_length;
11921
11922 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11923
11924 if (found)
11925 {
11926 wpa_t *wpa = (wpa_t *) found->esalt;
11927
11928 // compare hex string(s) vs binary MAC address(es)
11929
11930 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11931 {
11932 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11933 {
11934 found = NULL;
11935
11936 break;
11937 }
11938 }
11939
11940 // early skip ;)
11941 if (!found) continue;
11942
11943 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11944 {
11945 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11946 {
11947 found = NULL;
11948
11949 break;
11950 }
11951 }
11952 }
11953 }
11954 }
11955 else
11956 {
11957 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11958
11959 if (parser_status == PARSER_OK)
11960 {
11961 if (isSalted)
11962 {
11963 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11964 }
11965 else
11966 {
11967 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11968 }
11969 }
11970 }
11971
11972 if (found == NULL) continue;
11973
11974 if (!found->cracked) potfile_remove_cracks++;
11975
11976 found->cracked = 1;
11977
11978 if (found) break;
11979
11980 iter--;
11981 }
11982 }
11983
11984 myfree (line_buf_cpy);
11985
11986 myfree (line_buf);
11987
11988 fclose (fp);
11989 }
11990 }
11991
11992 if (esalt_size)
11993 {
11994 local_free (hash_buf.esalt);
11995 }
11996
11997 if (isSalted)
11998 {
11999 local_free (hash_buf.salt);
12000 }
12001
12002 local_free (hash_buf.digest);
12003 }
12004
12005 /**
12006 * Now generate all the buffers required for later
12007 */
12008
12009 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12010
12011 salt_t *salts_buf_new = NULL;
12012 void *esalts_buf_new = NULL;
12013
12014 if (isSalted)
12015 {
12016 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12017
12018 if (esalt_size)
12019 {
12020 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12021 }
12022 }
12023 else
12024 {
12025 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12026 }
12027
12028 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12029
12030 uint digests_cnt = hashes_cnt;
12031 uint digests_done = 0;
12032
12033 size_t size_digests = digests_cnt * dgst_size;
12034 size_t size_shown = digests_cnt * sizeof (uint);
12035
12036 uint *digests_shown = (uint *) mymalloc (size_shown);
12037 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12038
12039 uint salts_cnt = 0;
12040 uint salts_done = 0;
12041
12042 hashinfo_t **hash_info = NULL;
12043
12044 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12045 {
12046 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12047
12048 if (username && (remove || show))
12049 {
12050 uint user_pos;
12051
12052 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12053 {
12054 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12055
12056 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12057 }
12058 }
12059 }
12060
12061 uint *salts_shown = (uint *) mymalloc (size_shown);
12062
12063 salt_t *salt_buf;
12064
12065 {
12066 // copied from inner loop
12067
12068 salt_buf = &salts_buf_new[salts_cnt];
12069
12070 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12071
12072 if (esalt_size)
12073 {
12074 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12075 }
12076
12077 salt_buf->digests_cnt = 0;
12078 salt_buf->digests_done = 0;
12079 salt_buf->digests_offset = 0;
12080
12081 salts_cnt++;
12082 }
12083
12084 if (hashes_buf[0].cracked == 1)
12085 {
12086 digests_shown[0] = 1;
12087
12088 digests_done++;
12089
12090 salt_buf->digests_done++;
12091 }
12092
12093 salt_buf->digests_cnt++;
12094
12095 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12096
12097 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12098 {
12099 hash_info[0] = hashes_buf[0].hash_info;
12100 }
12101
12102 // copy from inner loop
12103
12104 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12105 {
12106 if (isSalted)
12107 {
12108 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12109 {
12110 salt_buf = &salts_buf_new[salts_cnt];
12111
12112 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12113
12114 if (esalt_size)
12115 {
12116 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12117 }
12118
12119 salt_buf->digests_cnt = 0;
12120 salt_buf->digests_done = 0;
12121 salt_buf->digests_offset = hashes_pos;
12122
12123 salts_cnt++;
12124 }
12125 }
12126
12127 if (hashes_buf[hashes_pos].cracked == 1)
12128 {
12129 digests_shown[hashes_pos] = 1;
12130
12131 digests_done++;
12132
12133 salt_buf->digests_done++;
12134 }
12135
12136 salt_buf->digests_cnt++;
12137
12138 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12139
12140 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12141 {
12142 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12143 }
12144 }
12145
12146 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12147 {
12148 salt_t *salt_buf = &salts_buf_new[salt_pos];
12149
12150 if (salt_buf->digests_done == salt_buf->digests_cnt)
12151 {
12152 salts_shown[salt_pos] = 1;
12153
12154 salts_done++;
12155 }
12156
12157 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12158 }
12159
12160 local_free (digests_buf);
12161 local_free (salts_buf);
12162 local_free (esalts_buf);
12163
12164 digests_buf = digests_buf_new;
12165 salts_buf = salts_buf_new;
12166 esalts_buf = esalts_buf_new;
12167
12168 local_free (hashes_buf);
12169
12170 /**
12171 * special modification not set from parser
12172 */
12173
12174 switch (hash_mode)
12175 {
12176 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12177 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12178 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12179 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12180 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12181 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12182 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12183 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12184 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12185 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12186 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12187 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12188 }
12189
12190 if (truecrypt_keyfiles)
12191 {
12192 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12193
12194 char *keyfiles = strdup (truecrypt_keyfiles);
12195
12196 char *keyfile = strtok (keyfiles, ",");
12197
12198 do
12199 {
12200 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12201
12202 } while ((keyfile = strtok (NULL, ",")) != NULL);
12203
12204 free (keyfiles);
12205 }
12206
12207 data.digests_cnt = digests_cnt;
12208 data.digests_done = digests_done;
12209 data.digests_buf = digests_buf;
12210 data.digests_shown = digests_shown;
12211 data.digests_shown_tmp = digests_shown_tmp;
12212
12213 data.salts_cnt = salts_cnt;
12214 data.salts_done = salts_done;
12215 data.salts_buf = salts_buf;
12216 data.salts_shown = salts_shown;
12217
12218 data.esalts_buf = esalts_buf;
12219 data.hash_info = hash_info;
12220
12221 /**
12222 * Automatic Optimizers
12223 */
12224
12225 if (salts_cnt == 1)
12226 opti_type |= OPTI_TYPE_SINGLE_SALT;
12227
12228 if (digests_cnt == 1)
12229 opti_type |= OPTI_TYPE_SINGLE_HASH;
12230
12231 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12232 opti_type |= OPTI_TYPE_NOT_ITERATED;
12233
12234 if (attack_mode == ATTACK_MODE_BF)
12235 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12236
12237 data.opti_type = opti_type;
12238
12239 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12240 {
12241 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12242 {
12243 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12244 {
12245 if (opts_type & OPTS_TYPE_ST_ADD80)
12246 {
12247 opts_type &= ~OPTS_TYPE_ST_ADD80;
12248 opts_type |= OPTS_TYPE_PT_ADD80;
12249 }
12250
12251 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12252 {
12253 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12254 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12255 }
12256
12257 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12258 {
12259 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12260 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12261 }
12262 }
12263 }
12264 }
12265
12266 /**
12267 * Some algorithm, like descrypt, can benefit from JIT compilation
12268 */
12269
12270 int force_jit_compilation = -1;
12271
12272 if (hash_mode == 8900)
12273 {
12274 force_jit_compilation = 8900;
12275 }
12276 else if (hash_mode == 9300)
12277 {
12278 force_jit_compilation = 8900;
12279 }
12280 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12281 {
12282 force_jit_compilation = 1500;
12283 }
12284
12285 /**
12286 * generate bitmap tables
12287 */
12288
12289 const uint bitmap_shift1 = 5;
12290 const uint bitmap_shift2 = 13;
12291
12292 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12293
12294 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12295 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12296 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12297 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12298 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12299 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12300 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12301 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12302
12303 uint bitmap_bits;
12304 uint bitmap_nums;
12305 uint bitmap_mask;
12306 uint bitmap_size;
12307
12308 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12309 {
12310 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12311
12312 bitmap_nums = 1 << bitmap_bits;
12313
12314 bitmap_mask = bitmap_nums - 1;
12315
12316 bitmap_size = bitmap_nums * sizeof (uint);
12317
12318 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12319
12320 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;
12321 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;
12322
12323 break;
12324 }
12325
12326 bitmap_nums = 1 << bitmap_bits;
12327
12328 bitmap_mask = bitmap_nums - 1;
12329
12330 bitmap_size = bitmap_nums * sizeof (uint);
12331
12332 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);
12333 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);
12334
12335 /**
12336 * prepare quick rule
12337 */
12338
12339 data.rule_buf_l = rule_buf_l;
12340 data.rule_buf_r = rule_buf_r;
12341
12342 int rule_len_l = (int) strlen (rule_buf_l);
12343 int rule_len_r = (int) strlen (rule_buf_r);
12344
12345 data.rule_len_l = rule_len_l;
12346 data.rule_len_r = rule_len_r;
12347
12348 /**
12349 * load rules
12350 */
12351
12352 uint *all_kernel_rules_cnt = NULL;
12353
12354 kernel_rule_t **all_kernel_rules_buf = NULL;
12355
12356 if (rp_files_cnt)
12357 {
12358 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12359
12360 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12361 }
12362
12363 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12364
12365 int rule_len = 0;
12366
12367 for (uint i = 0; i < rp_files_cnt; i++)
12368 {
12369 uint kernel_rules_avail = 0;
12370
12371 uint kernel_rules_cnt = 0;
12372
12373 kernel_rule_t *kernel_rules_buf = NULL;
12374
12375 char *rp_file = rp_files[i];
12376
12377 char in[BLOCK_SIZE] = { 0 };
12378 char out[BLOCK_SIZE] = { 0 };
12379
12380 FILE *fp = NULL;
12381
12382 uint rule_line = 0;
12383
12384 if ((fp = fopen (rp_file, "rb")) == NULL)
12385 {
12386 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12387
12388 return (-1);
12389 }
12390
12391 while (!feof (fp))
12392 {
12393 memset (rule_buf, 0, HCBUFSIZ);
12394
12395 rule_len = fgetl (fp, rule_buf);
12396
12397 rule_line++;
12398
12399 if (rule_len == 0) continue;
12400
12401 if (rule_buf[0] == '#') continue;
12402
12403 if (kernel_rules_avail == kernel_rules_cnt)
12404 {
12405 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12406
12407 kernel_rules_avail += INCR_RULES;
12408 }
12409
12410 memset (in, 0, BLOCK_SIZE);
12411 memset (out, 0, BLOCK_SIZE);
12412
12413 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12414
12415 if (result == -1)
12416 {
12417 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12418
12419 continue;
12420 }
12421
12422 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12423 {
12424 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12425
12426 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12427
12428 continue;
12429 }
12430
12431 /* its so slow
12432 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12433 {
12434 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12435
12436 continue;
12437 }
12438 */
12439
12440 kernel_rules_cnt++;
12441 }
12442
12443 fclose (fp);
12444
12445 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12446
12447 all_kernel_rules_buf[i] = kernel_rules_buf;
12448 }
12449
12450 /**
12451 * merge rules or automatic rule generator
12452 */
12453
12454 uint kernel_rules_cnt = 0;
12455
12456 kernel_rule_t *kernel_rules_buf = NULL;
12457
12458 if (attack_mode == ATTACK_MODE_STRAIGHT)
12459 {
12460 if (rp_files_cnt)
12461 {
12462 kernel_rules_cnt = 1;
12463
12464 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12465
12466 repeats[0] = kernel_rules_cnt;
12467
12468 for (uint i = 0; i < rp_files_cnt; i++)
12469 {
12470 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12471
12472 repeats[i + 1] = kernel_rules_cnt;
12473 }
12474
12475 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12476
12477 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12478
12479 for (uint i = 0; i < kernel_rules_cnt; i++)
12480 {
12481 uint out_pos = 0;
12482
12483 kernel_rule_t *out = &kernel_rules_buf[i];
12484
12485 for (uint j = 0; j < rp_files_cnt; j++)
12486 {
12487 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12488 uint in_pos;
12489
12490 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12491
12492 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12493 {
12494 if (out_pos == RULES_MAX - 1)
12495 {
12496 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12497
12498 break;
12499 }
12500
12501 out->cmds[out_pos] = in->cmds[in_pos];
12502 }
12503 }
12504 }
12505
12506 local_free (repeats);
12507 }
12508 else if (rp_gen)
12509 {
12510 uint kernel_rules_avail = 0;
12511
12512 while (kernel_rules_cnt < rp_gen)
12513 {
12514 if (kernel_rules_avail == kernel_rules_cnt)
12515 {
12516 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12517
12518 kernel_rules_avail += INCR_RULES;
12519 }
12520
12521 memset (rule_buf, 0, HCBUFSIZ);
12522
12523 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12524
12525 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12526
12527 kernel_rules_cnt++;
12528 }
12529 }
12530 }
12531
12532 myfree (rule_buf);
12533
12534 /**
12535 * generate NOP rules
12536 */
12537
12538 if (kernel_rules_cnt == 0)
12539 {
12540 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12541
12542 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12543
12544 kernel_rules_cnt++;
12545 }
12546
12547 data.kernel_rules_cnt = kernel_rules_cnt;
12548 data.kernel_rules_buf = kernel_rules_buf;
12549
12550 /**
12551 * OpenCL platforms: detect
12552 */
12553
12554 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12555 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12556
12557 cl_uint platforms_cnt = 0;
12558 cl_uint platform_devices_cnt = 0;
12559
12560 if (keyspace == 0)
12561 {
12562 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12563
12564 if (platforms_cnt == 0)
12565 {
12566 log_info ("");
12567 log_info ("ATTENTION! No OpenCL compatible platform found");
12568 log_info ("");
12569 log_info ("You're probably missing the OpenCL runtime installation");
12570 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
12571 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
12572 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
12573 log_info ("");
12574
12575 return (-1);
12576 }
12577
12578 if (opencl_platforms_filter != (uint) -1)
12579 {
12580 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
12581
12582 if (opencl_platforms_filter > platform_cnt_mask)
12583 {
12584 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
12585
12586 return (-1);
12587 }
12588 }
12589 }
12590
12591 /**
12592 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12593 */
12594
12595 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12596 {
12597 cl_platform_id platform = platforms[platform_id];
12598
12599 char platform_vendor[INFOSZ] = { 0 };
12600
12601 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12602
12603 #ifdef HAVE_HWMON
12604 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12605 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12606 {
12607 // make sure that we do not directly control the fan for NVidia
12608
12609 gpu_temp_retain = 0;
12610
12611 data.gpu_temp_retain = gpu_temp_retain;
12612 }
12613 #endif // HAVE_NVML || HAVE_NVAPI
12614 #endif
12615 }
12616
12617 /**
12618 * OpenCL device types:
12619 * 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.
12620 * In such a case, automatically enable CPU device type support, since it's disabled by default.
12621 */
12622
12623 if (opencl_device_types == NULL)
12624 {
12625 cl_device_type device_types_all = 0;
12626
12627 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12628 {
12629 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12630
12631 cl_platform_id platform = platforms[platform_id];
12632
12633 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12634
12635 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12636 {
12637 cl_device_id device = platform_devices[platform_devices_id];
12638
12639 cl_device_type device_type;
12640
12641 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12642
12643 device_types_all |= device_type;
12644 }
12645 }
12646
12647 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
12648 {
12649 device_types_filter |= CL_DEVICE_TYPE_CPU;
12650 }
12651 }
12652
12653 /**
12654 * OpenCL devices: simply push all devices from all platforms into the same device array
12655 */
12656
12657 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12658
12659 data.devices_param = devices_param;
12660
12661 uint devices_cnt = 0;
12662
12663 uint devices_active = 0;
12664
12665 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12666 {
12667 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12668
12669 cl_platform_id platform = platforms[platform_id];
12670
12671 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12672
12673 char platform_vendor[INFOSZ] = { 0 };
12674
12675 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12676
12677 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
12678 // this causes trouble with vendor id based macros
12679 // we'll assign generic to those without special optimization available
12680
12681 cl_uint vendor_id = 0;
12682
12683 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
12684 {
12685 vendor_id = VENDOR_ID_AMD;
12686 }
12687 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
12688 {
12689 vendor_id = VENDOR_ID_APPLE;
12690 }
12691 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
12692 {
12693 vendor_id = VENDOR_ID_INTEL_BEIGNET;
12694 }
12695 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
12696 {
12697 vendor_id = VENDOR_ID_INTEL_SDK;
12698 }
12699 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
12700 {
12701 vendor_id = VENDOR_ID_MESA;
12702 }
12703 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12704 {
12705 vendor_id = VENDOR_ID_NV;
12706 }
12707 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
12708 {
12709 vendor_id = VENDOR_ID_POCL;
12710 }
12711 else
12712 {
12713 vendor_id = VENDOR_ID_GENERIC;
12714 }
12715
12716 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12717 {
12718 size_t param_value_size = 0;
12719
12720 const uint device_id = devices_cnt;
12721
12722 hc_device_param_t *device_param = &data.devices_param[device_id];
12723
12724 device_param->vendor_id = vendor_id;
12725
12726 device_param->device = platform_devices[platform_devices_id];
12727
12728 device_param->device_id = device_id;
12729
12730 device_param->platform_devices_id = platform_devices_id;
12731
12732 // device_type
12733
12734 cl_device_type device_type;
12735
12736 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12737
12738 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12739
12740 device_param->device_type = device_type;
12741
12742 // device_name
12743
12744 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12745
12746 char *device_name = (char *) mymalloc (param_value_size);
12747
12748 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12749
12750 device_param->device_name = device_name;
12751
12752 // tuning db
12753
12754 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12755
12756 // device_version
12757
12758 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12759
12760 char *device_version = (char *) mymalloc (param_value_size);
12761
12762 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12763
12764 device_param->device_version = device_version;
12765
12766 // device_opencl_version
12767
12768 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12769
12770 char *device_opencl_version = (char *) mymalloc (param_value_size);
12771
12772 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12773
12774 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12775
12776 myfree (device_opencl_version);
12777
12778 // vector_width
12779
12780 cl_uint vector_width;
12781
12782 if (opencl_vector_width_chgd == 0)
12783 {
12784 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12785 {
12786 if (opti_type & OPTI_TYPE_USES_BITS_64)
12787 {
12788 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12789 }
12790 else
12791 {
12792 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12793 }
12794 }
12795 else
12796 {
12797 vector_width = (cl_uint) tuningdb_entry->vector_width;
12798 }
12799 }
12800 else
12801 {
12802 vector_width = opencl_vector_width;
12803 }
12804
12805 if (vector_width > 16) vector_width = 16;
12806
12807 device_param->vector_width = vector_width;
12808
12809 // max_compute_units
12810
12811 cl_uint device_processors;
12812
12813 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12814
12815 device_param->device_processors = device_processors;
12816
12817 // device_maxmem_alloc
12818 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
12819
12820 cl_ulong device_maxmem_alloc;
12821
12822 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12823
12824 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
12825
12826 // device_global_mem
12827
12828 cl_ulong device_global_mem;
12829
12830 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12831
12832 device_param->device_global_mem = device_global_mem;
12833
12834 // max_work_group_size
12835
12836 size_t device_maxworkgroup_size;
12837
12838 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
12839
12840 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
12841
12842 // max_clock_frequency
12843
12844 cl_uint device_maxclock_frequency;
12845
12846 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12847
12848 device_param->device_maxclock_frequency = device_maxclock_frequency;
12849
12850 // device_endian_little
12851
12852 cl_bool device_endian_little;
12853
12854 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
12855
12856 if (device_endian_little == CL_FALSE)
12857 {
12858 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
12859
12860 device_param->skipped = 1;
12861 }
12862
12863 // device_available
12864
12865 cl_bool device_available;
12866
12867 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
12868
12869 if (device_available == CL_FALSE)
12870 {
12871 log_info ("Device #%u: WARNING: device not available", device_id + 1);
12872
12873 device_param->skipped = 1;
12874 }
12875
12876 // device_compiler_available
12877
12878 cl_bool device_compiler_available;
12879
12880 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
12881
12882 if (device_compiler_available == CL_FALSE)
12883 {
12884 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
12885
12886 device_param->skipped = 1;
12887 }
12888
12889 // device_execution_capabilities
12890
12891 cl_device_exec_capabilities device_execution_capabilities;
12892
12893 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
12894
12895 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
12896 {
12897 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
12898
12899 device_param->skipped = 1;
12900 }
12901
12902 // device_extensions
12903
12904 size_t device_extensions_size;
12905
12906 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
12907
12908 char *device_extensions = mymalloc (device_extensions_size + 1);
12909
12910 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
12911
12912 if (strstr (device_extensions, "base_atomics") == 0)
12913 {
12914 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
12915
12916 device_param->skipped = 1;
12917 }
12918
12919 if (strstr (device_extensions, "byte_addressable_store") == 0)
12920 {
12921 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
12922
12923 device_param->skipped = 1;
12924 }
12925
12926 myfree (device_extensions);
12927
12928 // device_local_mem_size
12929
12930 cl_ulong device_local_mem_size;
12931
12932 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
12933
12934 if (device_local_mem_size < 32768)
12935 {
12936 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
12937
12938 device_param->skipped = 1;
12939 }
12940
12941
12942 // skipped
12943
12944 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
12945 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
12946
12947 // driver_version
12948
12949 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12950
12951 char *driver_version = (char *) mymalloc (param_value_size);
12952
12953 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12954
12955 device_param->driver_version = driver_version;
12956
12957 // device_name_chksum
12958
12959 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12960
12961 #if __x86_64__
12962 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);
12963 #else
12964 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);
12965 #endif
12966
12967 uint device_name_digest[4] = { 0 };
12968
12969 md5_64 ((uint *) device_name_chksum, device_name_digest);
12970
12971 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12972
12973 device_param->device_name_chksum = device_name_chksum;
12974
12975 // device_processor_cores
12976
12977 if (device_type & CL_DEVICE_TYPE_CPU)
12978 {
12979 cl_uint device_processor_cores = 1;
12980
12981 device_param->device_processor_cores = device_processor_cores;
12982 }
12983
12984 if (device_type & CL_DEVICE_TYPE_GPU)
12985 {
12986 if (vendor_id == VENDOR_ID_AMD)
12987 {
12988 cl_uint device_processor_cores = 0;
12989
12990 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12991
12992 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12993
12994 device_param->device_processor_cores = device_processor_cores;
12995 }
12996 else if (vendor_id == VENDOR_ID_NV)
12997 {
12998 cl_uint kernel_exec_timeout = 0;
12999
13000 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13001
13002 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13003
13004 device_param->kernel_exec_timeout = kernel_exec_timeout;
13005
13006 cl_uint device_processor_cores = 0;
13007
13008 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13009
13010 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13011
13012 device_param->device_processor_cores = device_processor_cores;
13013
13014 cl_uint sm_minor = 0;
13015 cl_uint sm_major = 0;
13016
13017 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13018 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13019
13020 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13021 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13022
13023 device_param->sm_minor = sm_minor;
13024 device_param->sm_major = sm_major;
13025 }
13026 else
13027 {
13028 cl_uint device_processor_cores = 1;
13029
13030 device_param->device_processor_cores = device_processor_cores;
13031 }
13032 }
13033
13034 // display results
13035
13036 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13037 {
13038 if (device_param->skipped == 0)
13039 {
13040 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
13041 device_id + 1,
13042 device_name,
13043 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13044 (unsigned int) (device_global_mem / 1024 / 1024),
13045 (unsigned int) (device_maxclock_frequency),
13046 (unsigned int) device_processors);
13047 }
13048 else
13049 {
13050 log_info ("Device #%u: %s, skipped",
13051 device_id + 1,
13052 device_name);
13053 }
13054 }
13055
13056 // common driver check
13057
13058 if (device_param->skipped == 0)
13059 {
13060 if (device_type & CL_DEVICE_TYPE_GPU)
13061 {
13062 if (vendor_id == VENDOR_ID_AMD)
13063 {
13064 int catalyst_check = (force == 1) ? 0 : 1;
13065
13066 int catalyst_warn = 0;
13067
13068 int catalyst_broken = 0;
13069
13070 if (catalyst_check == 1)
13071 {
13072 catalyst_warn = 1;
13073
13074 // v14.9 and higher
13075 if (atoi (device_param->driver_version) >= 1573)
13076 {
13077 catalyst_warn = 0;
13078 }
13079
13080 catalyst_check = 0;
13081 }
13082
13083 if (catalyst_broken == 1)
13084 {
13085 log_info ("");
13086 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13087 log_info ("It will pass over cracked hashes and does not report them as cracked");
13088 log_info ("You are STRONGLY encouraged not to use it");
13089 log_info ("You can use --force to override this but do not post error reports if you do so");
13090 log_info ("");
13091
13092 return (-1);
13093 }
13094
13095 if (catalyst_warn == 1)
13096 {
13097 log_info ("");
13098 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13099 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13100 log_info ("See hashcat's homepage for official supported catalyst drivers");
13101 #ifdef _WIN
13102 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13103 #endif
13104 log_info ("You can use --force to override this but do not post error reports if you do so");
13105 log_info ("");
13106
13107 return (-1);
13108 }
13109 }
13110 else if (vendor_id == VENDOR_ID_NV)
13111 {
13112 if (device_param->kernel_exec_timeout != 0)
13113 {
13114 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);
13115 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13116 }
13117 }
13118 }
13119
13120 if (device_type & CL_DEVICE_TYPE_CPU)
13121 {
13122 if (vendor_id == VENDOR_ID_AMD)
13123 {
13124 if (force == 0)
13125 {
13126 log_info ("");
13127 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13128 log_info ("You are STRONGLY encouraged not to use it");
13129 log_info ("You can use --force to override this but do not post error reports if you do so");
13130 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13131 log_info ("");
13132
13133 return (-1);
13134 }
13135 }
13136 }
13137
13138 /**
13139 * kernel accel and loops tuning db adjustment
13140 */
13141
13142 device_param->kernel_accel_min = 1;
13143 device_param->kernel_accel_max = 1024;
13144
13145 device_param->kernel_loops_min = 1;
13146 device_param->kernel_loops_max = 1024;
13147
13148 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13149
13150 if (tuningdb_entry)
13151 {
13152 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13153 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13154
13155 if (_kernel_accel)
13156 {
13157 device_param->kernel_accel_min = _kernel_accel;
13158 device_param->kernel_accel_max = _kernel_accel;
13159 }
13160
13161 if (_kernel_loops)
13162 {
13163 if (workload_profile == 1)
13164 {
13165 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13166 }
13167 else if (workload_profile == 2)
13168 {
13169 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13170 }
13171
13172 device_param->kernel_loops_min = _kernel_loops;
13173 device_param->kernel_loops_max = _kernel_loops;
13174 }
13175 }
13176
13177 // commandline parameters overwrite tuningdb entries
13178
13179 if (kernel_accel)
13180 {
13181 device_param->kernel_accel_min = kernel_accel;
13182 device_param->kernel_accel_max = kernel_accel;
13183 }
13184
13185 if (kernel_loops)
13186 {
13187 device_param->kernel_loops_min = kernel_loops;
13188 device_param->kernel_loops_max = kernel_loops;
13189 }
13190
13191 /**
13192 * activate device
13193 */
13194
13195 devices_active++;
13196 }
13197
13198 // next please
13199
13200 devices_cnt++;
13201 }
13202 }
13203
13204 if (keyspace == 0 && devices_active == 0)
13205 {
13206 log_error ("ERROR: No devices found/left");
13207
13208 return (-1);
13209 }
13210
13211 // 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)
13212
13213 if (devices_filter != (uint) -1)
13214 {
13215 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13216
13217 if (devices_filter > devices_cnt_mask)
13218 {
13219 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13220
13221 return (-1);
13222 }
13223 }
13224
13225 data.devices_cnt = devices_cnt;
13226
13227 data.devices_active = devices_active;
13228
13229 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13230 {
13231 log_info ("");
13232 }
13233
13234 /**
13235 * HM devices: init
13236 */
13237
13238 #ifdef HAVE_HWMON
13239 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13240 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13241 #endif
13242
13243 #ifdef HAVE_ADL
13244 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13245 #endif
13246
13247 if (gpu_temp_disable == 0)
13248 {
13249 #if defined(WIN) && defined(HAVE_NVAPI)
13250 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13251
13252 if (nvapi_init (nvapi) == 0)
13253 data.hm_nv = nvapi;
13254
13255 if (data.hm_nv)
13256 {
13257 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13258 {
13259 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13260
13261 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13262
13263 int tmp_out = 0;
13264
13265 for (int i = 0; i < tmp_in; i++)
13266 {
13267 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13268 }
13269
13270 for (int i = 0; i < tmp_out; i++)
13271 {
13272 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13273
13274 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13275
13276 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;
13277 }
13278 }
13279 }
13280 #endif // WIN && HAVE_NVAPI
13281
13282 #if defined(LINUX) && defined(HAVE_NVML)
13283 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13284
13285 if (nvml_init (nvml) == 0)
13286 data.hm_nv = nvml;
13287
13288 if (data.hm_nv)
13289 {
13290 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13291 {
13292 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13293
13294 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13295
13296 int tmp_out = 0;
13297
13298 for (int i = 0; i < tmp_in; i++)
13299 {
13300 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13301 }
13302
13303 for (int i = 0; i < tmp_out; i++)
13304 {
13305 unsigned int speed;
13306
13307 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;
13308 }
13309 }
13310 }
13311 #endif // LINUX && HAVE_NVML
13312
13313 data.hm_amd = NULL;
13314
13315 #ifdef HAVE_ADL
13316 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13317
13318 if (adl_init (adl) == 0)
13319 data.hm_amd = adl;
13320
13321 if (data.hm_amd)
13322 {
13323 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13324 {
13325 // total number of adapters
13326
13327 int hm_adapters_num;
13328
13329 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13330
13331 // adapter info
13332
13333 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13334
13335 if (lpAdapterInfo == NULL) return (-1);
13336
13337 // get a list (of ids of) valid/usable adapters
13338
13339 int num_adl_adapters = 0;
13340
13341 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13342
13343 if (num_adl_adapters > 0)
13344 {
13345 hc_thread_mutex_lock (mux_adl);
13346
13347 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13348
13349 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13350
13351 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13352 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13353
13354 hc_thread_mutex_unlock (mux_adl);
13355 }
13356
13357 myfree (valid_adl_device_list);
13358 myfree (lpAdapterInfo);
13359 }
13360 }
13361 #endif // HAVE_ADL
13362
13363 if (data.hm_amd == NULL && data.hm_nv == NULL)
13364 {
13365 gpu_temp_disable = 1;
13366 }
13367 }
13368
13369 /**
13370 * OpenCL devices: allocate buffer for device specific information
13371 */
13372
13373 #ifdef HAVE_HWMON
13374 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13375
13376 #ifdef HAVE_ADL
13377 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13378
13379 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13380 #endif // ADL
13381 #endif
13382
13383 /**
13384 * enable custom signal handler(s)
13385 */
13386
13387 if (benchmark == 0)
13388 {
13389 hc_signal (sigHandler_default);
13390 }
13391 else
13392 {
13393 hc_signal (sigHandler_benchmark);
13394 }
13395
13396 /**
13397 * User-defined GPU temp handling
13398 */
13399
13400 #ifdef HAVE_HWMON
13401 if (gpu_temp_disable == 1)
13402 {
13403 gpu_temp_abort = 0;
13404 gpu_temp_retain = 0;
13405 }
13406
13407 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13408 {
13409 if (gpu_temp_abort < gpu_temp_retain)
13410 {
13411 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13412
13413 return (-1);
13414 }
13415 }
13416
13417 data.gpu_temp_disable = gpu_temp_disable;
13418 data.gpu_temp_abort = gpu_temp_abort;
13419 data.gpu_temp_retain = gpu_temp_retain;
13420 #endif
13421
13422 /**
13423 * inform the user
13424 */
13425
13426 if (data.quiet == 0)
13427 {
13428 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13429
13430 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);
13431
13432 if (attack_mode == ATTACK_MODE_STRAIGHT)
13433 {
13434 log_info ("Rules: %u", kernel_rules_cnt);
13435 }
13436
13437 if (opti_type)
13438 {
13439 log_info ("Applicable Optimizers:");
13440
13441 for (uint i = 0; i < 32; i++)
13442 {
13443 const uint opti_bit = 1u << i;
13444
13445 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13446 }
13447 }
13448
13449 /**
13450 * Watchdog and Temperature balance
13451 */
13452
13453 #ifdef HAVE_HWMON
13454 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13455 {
13456 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13457 }
13458
13459 if (gpu_temp_abort == 0)
13460 {
13461 log_info ("Watchdog: Temperature abort trigger disabled");
13462 }
13463 else
13464 {
13465 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13466 }
13467
13468 if (gpu_temp_retain == 0)
13469 {
13470 log_info ("Watchdog: Temperature retain trigger disabled");
13471 }
13472 else
13473 {
13474 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13475 }
13476
13477 if (data.quiet == 0) log_info ("");
13478 #endif
13479 }
13480
13481 /**
13482 * HM devices: copy
13483 */
13484
13485 if (gpu_temp_disable == 0)
13486 {
13487 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13488 {
13489 hc_device_param_t *device_param = &data.devices_param[device_id];
13490
13491 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13492
13493 if (device_param->skipped) continue;
13494
13495 const uint platform_devices_id = device_param->platform_devices_id;
13496
13497 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13498 if (device_param->vendor_id == VENDOR_ID_NV)
13499 {
13500 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13501 }
13502 #endif
13503
13504 #ifdef HAVE_ADL
13505 if (device_param->vendor_id == VENDOR_ID_AMD)
13506 {
13507 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13508 }
13509 #endif
13510 }
13511 }
13512
13513 /*
13514 * Temporary fix:
13515 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13516 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13517 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13518 * Driver / ADL bug?
13519 */
13520
13521 #ifdef HAVE_ADL
13522 if (powertune_enable == 1)
13523 {
13524 hc_thread_mutex_lock (mux_adl);
13525
13526 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13527 {
13528 hc_device_param_t *device_param = &data.devices_param[device_id];
13529
13530 if (device_param->skipped) continue;
13531
13532 if (data.hm_device[device_id].od_version == 6)
13533 {
13534 // set powertune value only
13535
13536 int powertune_supported = 0;
13537
13538 int ADL_rc = 0;
13539
13540 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13541 {
13542 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13543
13544 return (-1);
13545 }
13546
13547 if (powertune_supported != 0)
13548 {
13549 // powertune set
13550 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13551
13552 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13553 {
13554 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13555
13556 return (-1);
13557 }
13558
13559 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13560 {
13561 log_error ("ERROR: Failed to set new ADL PowerControl values");
13562
13563 return (-1);
13564 }
13565 }
13566 }
13567 }
13568
13569 hc_thread_mutex_unlock (mux_adl);
13570 }
13571 #endif // HAVE_ADK
13572 #endif // HAVE_HWMON
13573
13574 #ifdef DEBUG
13575 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13576 #endif
13577
13578 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
13579
13580 uint kernel_power_all = 0;
13581
13582 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13583 {
13584 /**
13585 * host buffer
13586 */
13587
13588 hc_device_param_t *device_param = &data.devices_param[device_id];
13589
13590 if (device_param->skipped) continue;
13591
13592 /**
13593 * device properties
13594 */
13595
13596 const char *device_name_chksum = device_param->device_name_chksum;
13597 const u32 device_processors = device_param->device_processors;
13598 const u32 device_processor_cores = device_param->device_processor_cores;
13599
13600 /**
13601 * create context for each device
13602 */
13603
13604 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13605
13606 /**
13607 * create command-queue
13608 */
13609
13610 // not supported with NV
13611 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13612
13613 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13614
13615 /**
13616 * kernel threads: some algorithms need a fixed kernel-threads count
13617 * because of shared memory usage or bitslice
13618 * there needs to be some upper limit, otherwise there's too much overhead
13619 */
13620
13621 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
13622
13623 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
13624 {
13625 kernel_threads = KERNEL_THREADS_MAX_CPU;
13626 }
13627
13628 if (hash_mode == 1500) kernel_threads = 64; // DES
13629 if (hash_mode == 3000) kernel_threads = 64; // DES
13630 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
13631 if (hash_mode == 7500) kernel_threads = 64; // RC4
13632 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
13633 if (hash_mode == 9700) kernel_threads = 64; // RC4
13634 if (hash_mode == 9710) kernel_threads = 64; // RC4
13635 if (hash_mode == 9800) kernel_threads = 64; // RC4
13636 if (hash_mode == 9810) kernel_threads = 64; // RC4
13637 if (hash_mode == 10400) kernel_threads = 64; // RC4
13638 if (hash_mode == 10410) kernel_threads = 64; // RC4
13639 if (hash_mode == 10500) kernel_threads = 64; // RC4
13640 if (hash_mode == 13100) kernel_threads = 64; // RC4
13641
13642 /**
13643 * create input buffers on device : calculate size of fixed memory buffers
13644 */
13645
13646 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
13647 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13648
13649 device_param->size_root_css = size_root_css;
13650 device_param->size_markov_css = size_markov_css;
13651
13652 size_t size_results = kernel_threads * sizeof (uint);
13653
13654 device_param->size_results = size_results;
13655
13656 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13657 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13658
13659 size_t size_plains = digests_cnt * sizeof (plain_t);
13660 size_t size_salts = salts_cnt * sizeof (salt_t);
13661 size_t size_esalts = salts_cnt * esalt_size;
13662
13663 device_param->size_plains = size_plains;
13664 device_param->size_digests = size_digests;
13665 device_param->size_shown = size_shown;
13666 device_param->size_salts = size_salts;
13667
13668 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
13669 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
13670 size_t size_tm = 32 * sizeof (bs_word_t);
13671
13672 // scryptV stuff
13673
13674 size_t size_scryptV = 1;
13675
13676 if ((hash_mode == 8900) || (hash_mode == 9300))
13677 {
13678 uint tmto_start = 0;
13679 uint tmto_stop = 10;
13680
13681 if (scrypt_tmto)
13682 {
13683 tmto_start = scrypt_tmto;
13684 }
13685 else
13686 {
13687 // in case the user did not specify the tmto manually
13688 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13689 // but set the lower end only in case the user has a device with too less memory
13690
13691 if (hash_mode == 8900)
13692 {
13693 if (device_param->vendor_id == VENDOR_ID_AMD)
13694 {
13695 tmto_start = 1;
13696 }
13697 else if (device_param->vendor_id == VENDOR_ID_NV)
13698 {
13699 tmto_start = 2;
13700 }
13701 }
13702 else if (hash_mode == 9300)
13703 {
13704 if (device_param->vendor_id == VENDOR_ID_AMD)
13705 {
13706 tmto_start = 2;
13707 }
13708 else if (device_param->vendor_id == VENDOR_ID_NV)
13709 {
13710 tmto_start = 2;
13711 }
13712 }
13713 }
13714
13715 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13716 {
13717 // TODO: in theory the following calculation needs to be done per salt, not global
13718 // we assume all hashes have the same scrypt settings
13719
13720 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13721
13722 size_scryptV /= 1 << tmto;
13723
13724 size_scryptV *= device_processors * device_processor_cores;
13725
13726 if (size_scryptV > device_param->device_maxmem_alloc)
13727 {
13728 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13729
13730 continue;
13731 }
13732
13733 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13734 {
13735 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13736 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
13737 }
13738
13739 break;
13740 }
13741
13742 if (data.salts_buf[0].scrypt_phy == 0)
13743 {
13744 log_error ("ERROR: can't allocate enough device memory");
13745
13746 return -1;
13747 }
13748
13749 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13750 }
13751
13752 /**
13753 * some algorithms need a fixed kernel-loops count
13754 */
13755
13756 if (hash_mode == 1500)
13757 {
13758 const u32 kernel_loops_fixed = 1024;
13759
13760 device_param->kernel_loops_min = kernel_loops_fixed;
13761 device_param->kernel_loops_max = kernel_loops_fixed;
13762 }
13763
13764 if (hash_mode == 3000)
13765 {
13766 const u32 kernel_loops_fixed = 1024;
13767
13768 device_param->kernel_loops_min = kernel_loops_fixed;
13769 device_param->kernel_loops_max = kernel_loops_fixed;
13770 }
13771
13772 if (hash_mode == 8900)
13773 {
13774 const u32 kernel_loops_fixed = 1;
13775
13776 device_param->kernel_loops_min = kernel_loops_fixed;
13777 device_param->kernel_loops_max = kernel_loops_fixed;
13778 }
13779
13780 if (hash_mode == 9300)
13781 {
13782 const u32 kernel_loops_fixed = 1;
13783
13784 device_param->kernel_loops_min = kernel_loops_fixed;
13785 device_param->kernel_loops_max = kernel_loops_fixed;
13786 }
13787
13788 if (hash_mode == 12500)
13789 {
13790 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13791
13792 device_param->kernel_loops_min = kernel_loops_fixed;
13793 device_param->kernel_loops_max = kernel_loops_fixed;
13794 }
13795
13796 /**
13797 * some algorithms have a maximum kernel-loops count
13798 */
13799
13800 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13801 {
13802 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13803 {
13804 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13805 }
13806 }
13807
13808 /**
13809 * some algorithms need a special kernel-accel
13810 */
13811
13812 if (hash_mode == 8900)
13813 {
13814 device_param->kernel_accel_min = 1;
13815 device_param->kernel_accel_max = 64;
13816 }
13817
13818 if (hash_mode == 9300)
13819 {
13820 device_param->kernel_accel_min = 1;
13821 device_param->kernel_accel_max = 64;
13822 }
13823
13824 u32 kernel_accel_min = device_param->kernel_accel_min;
13825 u32 kernel_accel_max = device_param->kernel_accel_max;
13826
13827 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13828
13829 size_t size_pws = 4;
13830 size_t size_tmps = 4;
13831 size_t size_hooks = 4;
13832
13833 while (kernel_accel_max >= kernel_accel_min)
13834 {
13835 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13836
13837 // size_pws
13838
13839 size_pws = kernel_power_max * sizeof (pw_t);
13840
13841 // size_tmps
13842
13843 switch (hash_mode)
13844 {
13845 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13846 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13847 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13848 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13849 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13850 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13851 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13852 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13853 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13854 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13855 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13856 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13857 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13858 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13859 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13860 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13861 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13862 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13863 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13864 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13865 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13866 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13867 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13868 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13869 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13870 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13871 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13872 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13873 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13874 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13875 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13876 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13877 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13878 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13879 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13880 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13881 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13882 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13883 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13884 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13885 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13886 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13887 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13888 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13889 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13890 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13891 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13892 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13893 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13894 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13895 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13896 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13897 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13898 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13899 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13900 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13901 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13902 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13903 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13904 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13905 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13906 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
13907 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
13908 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13909 };
13910
13911 // size_hooks
13912
13913 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13914 {
13915 // none yet
13916 }
13917
13918 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13919 // if not, decrease amplifier and try again
13920
13921 int skip = 0;
13922
13923 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13924 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13925 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13926
13927 if (( bitmap_size
13928 + bitmap_size
13929 + bitmap_size
13930 + bitmap_size
13931 + bitmap_size
13932 + bitmap_size
13933 + bitmap_size
13934 + bitmap_size
13935 + size_bfs
13936 + size_combs
13937 + size_digests
13938 + size_esalts
13939 + size_hooks
13940 + size_markov_css
13941 + size_plains
13942 + size_pws
13943 + size_pws // not a bug
13944 + size_results
13945 + size_root_css
13946 + size_rules
13947 + size_rules_c
13948 + size_salts
13949 + size_scryptV
13950 + size_shown
13951 + size_tm
13952 + size_tmps) > device_param->device_global_mem) skip = 1;
13953
13954 if (skip == 1)
13955 {
13956 kernel_accel_max--;
13957
13958 continue;
13959 }
13960
13961 break;
13962 }
13963
13964 /*
13965 if (kernel_accel_max == 0)
13966 {
13967 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13968
13969 return -1;
13970 }
13971 */
13972
13973 device_param->kernel_accel_min = kernel_accel_min;
13974 device_param->kernel_accel_max = kernel_accel_max;
13975
13976 /*
13977 if (kernel_accel_max < kernel_accel)
13978 {
13979 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13980
13981 device_param->kernel_accel = kernel_accel_max;
13982 }
13983 */
13984
13985 device_param->size_bfs = size_bfs;
13986 device_param->size_combs = size_combs;
13987 device_param->size_rules = size_rules;
13988 device_param->size_rules_c = size_rules_c;
13989 device_param->size_pws = size_pws;
13990 device_param->size_tmps = size_tmps;
13991 device_param->size_hooks = size_hooks;
13992
13993 // do not confuse kernel_accel_max with kernel_accel here
13994
13995 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13996
13997 device_param->kernel_threads = kernel_threads;
13998 device_param->kernel_power_user = kernel_power;
13999
14000 kernel_power_all += kernel_power;
14001
14002 /**
14003 * default building options
14004 */
14005
14006 char build_opts[1024] = { 0 };
14007
14008 // we don't have sm_* on vendors not NV but it doesn't matter
14009
14010 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);
14011
14012 if (device_param->vendor_id == VENDOR_ID_INTEL_SDK)
14013 {
14014 // we do vectorizing much better than the auto-vectorizer
14015
14016 char build_opts_new[1024] = { 0 };
14017
14018 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14019
14020 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14021 }
14022
14023 #ifdef DEBUG
14024 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14025 #endif
14026
14027 /**
14028 * main kernel
14029 */
14030
14031 {
14032 /**
14033 * kernel source filename
14034 */
14035
14036 char source_file[256] = { 0 };
14037
14038 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14039
14040 struct stat sst;
14041
14042 if (stat (source_file, &sst) == -1)
14043 {
14044 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14045
14046 return -1;
14047 }
14048
14049 /**
14050 * kernel cached filename
14051 */
14052
14053 char cached_file[256] = { 0 };
14054
14055 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14056
14057 int cached = 1;
14058
14059 struct stat cst;
14060
14061 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14062 {
14063 cached = 0;
14064 }
14065
14066 /**
14067 * kernel compile or load
14068 */
14069
14070 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14071
14072 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14073
14074 if (force_jit_compilation == -1)
14075 {
14076 if (cached == 0)
14077 {
14078 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14079
14080 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14081
14082 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14083
14084 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14085
14086 #ifdef DEBUG
14087 size_t build_log_size = 0;
14088
14089 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14090
14091 if (build_log_size > 1)
14092 {
14093 char *build_log = (char *) malloc (build_log_size + 1);
14094
14095 memset (build_log, 0, build_log_size + 1);
14096
14097 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14098
14099 puts (build_log);
14100
14101 free (build_log);
14102 }
14103 #endif
14104
14105 if (rc != 0)
14106 {
14107 device_param->skipped = true;
14108
14109 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14110
14111 continue;
14112 }
14113
14114 size_t binary_size;
14115
14116 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14117
14118 u8 *binary = (u8 *) mymalloc (binary_size);
14119
14120 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14121
14122 writeProgramBin (cached_file, binary, binary_size);
14123
14124 local_free (binary);
14125 }
14126 else
14127 {
14128 #ifdef DEBUG
14129 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14130 #endif
14131
14132 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14133
14134 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14135
14136 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14137 }
14138 }
14139 else
14140 {
14141 #ifdef DEBUG
14142 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14143 #endif
14144
14145 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14146
14147 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14148
14149 char build_opts_update[1024] = { 0 };
14150
14151 if (force_jit_compilation == 1500)
14152 {
14153 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14154 }
14155 else if (force_jit_compilation == 8900)
14156 {
14157 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);
14158 }
14159 else
14160 {
14161 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14162 }
14163
14164 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14165
14166 #ifdef DEBUG
14167 size_t build_log_size = 0;
14168
14169 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14170
14171 if (build_log_size > 1)
14172 {
14173 char *build_log = (char *) malloc (build_log_size + 1);
14174
14175 memset (build_log, 0, build_log_size + 1);
14176
14177 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14178
14179 puts (build_log);
14180
14181 free (build_log);
14182 }
14183 #endif
14184
14185 if (rc != 0)
14186 {
14187 device_param->skipped = true;
14188
14189 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14190 }
14191 }
14192
14193 local_free (kernel_lengths);
14194 local_free (kernel_sources[0]);
14195 local_free (kernel_sources);
14196 }
14197
14198 /**
14199 * word generator kernel
14200 */
14201
14202 if (attack_mode != ATTACK_MODE_STRAIGHT)
14203 {
14204 /**
14205 * kernel mp source filename
14206 */
14207
14208 char source_file[256] = { 0 };
14209
14210 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14211
14212 struct stat sst;
14213
14214 if (stat (source_file, &sst) == -1)
14215 {
14216 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14217
14218 return -1;
14219 }
14220
14221 /**
14222 * kernel mp cached filename
14223 */
14224
14225 char cached_file[256] = { 0 };
14226
14227 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14228
14229 int cached = 1;
14230
14231 struct stat cst;
14232
14233 if (stat (cached_file, &cst) == -1)
14234 {
14235 cached = 0;
14236 }
14237
14238 /**
14239 * kernel compile or load
14240 */
14241
14242 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14243
14244 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14245
14246 if (cached == 0)
14247 {
14248 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14249 if (quiet == 0) log_info ("");
14250
14251 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14252
14253 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14254
14255 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14256
14257 if (rc != 0)
14258 {
14259 device_param->skipped = true;
14260
14261 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14262
14263 continue;
14264 }
14265
14266 size_t binary_size;
14267
14268 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14269
14270 u8 *binary = (u8 *) mymalloc (binary_size);
14271
14272 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14273
14274 writeProgramBin (cached_file, binary, binary_size);
14275
14276 local_free (binary);
14277 }
14278 else
14279 {
14280 #ifdef DEBUG
14281 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14282 #endif
14283
14284 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14285
14286 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14287
14288 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14289 }
14290
14291 local_free (kernel_lengths);
14292 local_free (kernel_sources[0]);
14293 local_free (kernel_sources);
14294 }
14295
14296 /**
14297 * amplifier kernel
14298 */
14299
14300 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14301 {
14302
14303 }
14304 else
14305 {
14306 /**
14307 * kernel amp source filename
14308 */
14309
14310 char source_file[256] = { 0 };
14311
14312 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14313
14314 struct stat sst;
14315
14316 if (stat (source_file, &sst) == -1)
14317 {
14318 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14319
14320 return -1;
14321 }
14322
14323 /**
14324 * kernel amp cached filename
14325 */
14326
14327 char cached_file[256] = { 0 };
14328
14329 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14330
14331 int cached = 1;
14332
14333 struct stat cst;
14334
14335 if (stat (cached_file, &cst) == -1)
14336 {
14337 cached = 0;
14338 }
14339
14340 /**
14341 * kernel compile or load
14342 */
14343
14344 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14345
14346 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14347
14348 if (cached == 0)
14349 {
14350 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14351 if (quiet == 0) log_info ("");
14352
14353 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14354
14355 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14356
14357 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14358
14359 if (rc != 0)
14360 {
14361 device_param->skipped = true;
14362
14363 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14364
14365 continue;
14366 }
14367
14368 size_t binary_size;
14369
14370 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14371
14372 u8 *binary = (u8 *) mymalloc (binary_size);
14373
14374 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14375
14376 writeProgramBin (cached_file, binary, binary_size);
14377
14378 local_free (binary);
14379 }
14380 else
14381 {
14382 #ifdef DEBUG
14383 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14384 #endif
14385
14386 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14387
14388 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14389
14390 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14391 }
14392
14393 local_free (kernel_lengths);
14394 local_free (kernel_sources[0]);
14395 local_free (kernel_sources);
14396 }
14397
14398 // some algorithm collide too fast, make that impossible
14399
14400 if (benchmark == 1)
14401 {
14402 ((uint *) digests_buf)[0] = -1;
14403 ((uint *) digests_buf)[1] = -1;
14404 ((uint *) digests_buf)[2] = -1;
14405 ((uint *) digests_buf)[3] = -1;
14406 }
14407
14408 /**
14409 * global buffers
14410 */
14411
14412 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14413 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14414 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14415 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14416 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14417 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14418 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14419 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14420 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14421 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14422 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14423 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14424 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14425 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14426 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14427 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14428 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14429 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14430
14431 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);
14432 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);
14433 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);
14434 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);
14435 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);
14436 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);
14437 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);
14438 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);
14439 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14440 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14441 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14442
14443 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14444 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14445 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14446 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14447 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14448 run_kernel_bzero (device_param, device_param->d_result, size_results);
14449
14450 /**
14451 * special buffers
14452 */
14453
14454 if (attack_kern == ATTACK_KERN_STRAIGHT)
14455 {
14456 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14457 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14458
14459 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14460
14461 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14462 }
14463 else if (attack_kern == ATTACK_KERN_COMBI)
14464 {
14465 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14466 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14467 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14468 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14469
14470 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14471 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14472 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14473 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14474 }
14475 else if (attack_kern == ATTACK_KERN_BF)
14476 {
14477 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14478 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14479 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14480 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14481 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14482
14483 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14484 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14485 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14486 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14487 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14488 }
14489
14490 if (size_esalts)
14491 {
14492 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14493
14494 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14495 }
14496
14497 /**
14498 * main host data
14499 */
14500
14501 uint *result = (uint *) mymalloc (size_results);
14502
14503 device_param->result = result;
14504
14505 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14506
14507 device_param->pws_buf = pws_buf;
14508
14509 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14510
14511 device_param->combs_buf = combs_buf;
14512
14513 void *hooks_buf = mymalloc (size_hooks);
14514
14515 device_param->hooks_buf = hooks_buf;
14516
14517 /**
14518 * kernel args
14519 */
14520
14521 device_param->kernel_params_buf32[21] = bitmap_mask;
14522 device_param->kernel_params_buf32[22] = bitmap_shift1;
14523 device_param->kernel_params_buf32[23] = bitmap_shift2;
14524 device_param->kernel_params_buf32[24] = 0; // salt_pos
14525 device_param->kernel_params_buf32[25] = 0; // loop_pos
14526 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14527 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14528 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14529 device_param->kernel_params_buf32[29] = 0; // digests_offset
14530 device_param->kernel_params_buf32[30] = 0; // combs_mode
14531 device_param->kernel_params_buf32[31] = 0; // gid_max
14532
14533 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14534 ? &device_param->d_pws_buf
14535 : &device_param->d_pws_amp_buf;
14536 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14537 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14538 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14539 device_param->kernel_params[ 4] = &device_param->d_tmps;
14540 device_param->kernel_params[ 5] = &device_param->d_hooks;
14541 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14542 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14543 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14544 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14545 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14546 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14547 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14548 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14549 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14550 device_param->kernel_params[15] = &device_param->d_digests_buf;
14551 device_param->kernel_params[16] = &device_param->d_digests_shown;
14552 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14553 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14554 device_param->kernel_params[19] = &device_param->d_result;
14555 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14556 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14557 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14558 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14559 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14560 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14561 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14562 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14563 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14564 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14565 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14566 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14567
14568 device_param->kernel_params_mp_buf64[3] = 0;
14569 device_param->kernel_params_mp_buf32[4] = 0;
14570 device_param->kernel_params_mp_buf32[5] = 0;
14571 device_param->kernel_params_mp_buf32[6] = 0;
14572 device_param->kernel_params_mp_buf32[7] = 0;
14573 device_param->kernel_params_mp_buf32[8] = 0;
14574
14575 device_param->kernel_params_mp[0] = NULL;
14576 device_param->kernel_params_mp[1] = NULL;
14577 device_param->kernel_params_mp[2] = NULL;
14578 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14579 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14580 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14581 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14582 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14583 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14584
14585 device_param->kernel_params_mp_l_buf64[3] = 0;
14586 device_param->kernel_params_mp_l_buf32[4] = 0;
14587 device_param->kernel_params_mp_l_buf32[5] = 0;
14588 device_param->kernel_params_mp_l_buf32[6] = 0;
14589 device_param->kernel_params_mp_l_buf32[7] = 0;
14590 device_param->kernel_params_mp_l_buf32[8] = 0;
14591 device_param->kernel_params_mp_l_buf32[9] = 0;
14592
14593 device_param->kernel_params_mp_l[0] = NULL;
14594 device_param->kernel_params_mp_l[1] = NULL;
14595 device_param->kernel_params_mp_l[2] = NULL;
14596 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14597 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14598 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14599 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14600 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14601 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14602 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14603
14604 device_param->kernel_params_mp_r_buf64[3] = 0;
14605 device_param->kernel_params_mp_r_buf32[4] = 0;
14606 device_param->kernel_params_mp_r_buf32[5] = 0;
14607 device_param->kernel_params_mp_r_buf32[6] = 0;
14608 device_param->kernel_params_mp_r_buf32[7] = 0;
14609 device_param->kernel_params_mp_r_buf32[8] = 0;
14610
14611 device_param->kernel_params_mp_r[0] = NULL;
14612 device_param->kernel_params_mp_r[1] = NULL;
14613 device_param->kernel_params_mp_r[2] = NULL;
14614 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14615 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14616 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14617 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14618 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14619 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14620
14621 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14622 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14623
14624 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14625 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14626 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14627 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14628 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14629 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14630 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14631
14632 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14633 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14634
14635 /**
14636 * kernel name
14637 */
14638
14639 char kernel_name[64] = { 0 };
14640
14641 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14642 {
14643 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14644 {
14645 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14646
14647 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14648
14649 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14650
14651 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14652
14653 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14654
14655 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14656 }
14657 else
14658 {
14659 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14660
14661 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14662
14663 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14664
14665 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14666
14667 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14668
14669 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14670 }
14671
14672 if (data.attack_mode == ATTACK_MODE_BF)
14673 {
14674 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14675 {
14676 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14677
14678 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14679 }
14680 }
14681 }
14682 else
14683 {
14684 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14685
14686 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14687
14688 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14689
14690 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14691
14692 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14693
14694 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14695
14696 if (opts_type & OPTS_TYPE_HOOK12)
14697 {
14698 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14699
14700 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14701 }
14702
14703 if (opts_type & OPTS_TYPE_HOOK23)
14704 {
14705 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14706
14707 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14708 }
14709 }
14710
14711 for (uint i = 0; i <= 20; i++)
14712 {
14713 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14714 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14715 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14716
14717 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14718 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14719 }
14720
14721 for (uint i = 21; i <= 31; i++)
14722 {
14723 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14724 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14725 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14726
14727 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14728 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14729 }
14730
14731 if (attack_mode == ATTACK_MODE_BF)
14732 {
14733 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14734 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14735
14736 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14737 {
14738 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14739 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14740 }
14741 }
14742 else if (attack_mode == ATTACK_MODE_HYBRID1)
14743 {
14744 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14745 }
14746 else if (attack_mode == ATTACK_MODE_HYBRID2)
14747 {
14748 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14749 }
14750
14751 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14752 {
14753 // nothing to do
14754 }
14755 else
14756 {
14757 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14758 }
14759
14760 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14761 {
14762 // nothing to do
14763 }
14764 else
14765 {
14766 for (uint i = 0; i < 5; i++)
14767 {
14768 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14769 }
14770
14771 for (uint i = 5; i < 7; i++)
14772 {
14773 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14774 }
14775 }
14776
14777 /**
14778 * Store initial fanspeed if gpu_temp_retain is enabled
14779 */
14780
14781 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14782 int gpu_temp_retain_set = 0;
14783
14784 if (gpu_temp_disable == 0)
14785 {
14786 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14787 {
14788 hc_thread_mutex_lock (mux_adl);
14789
14790 if (data.hm_device[device_id].fan_supported == 1)
14791 {
14792 if (gpu_temp_retain_chgd == 0)
14793 {
14794 uint cur_temp = 0;
14795 uint default_temp = 0;
14796
14797 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);
14798
14799 if (ADL_rc == ADL_OK)
14800 {
14801 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14802
14803 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14804
14805 // special case with multi gpu setups: always use minimum retain
14806
14807 if (gpu_temp_retain_set == 0)
14808 {
14809 gpu_temp_retain = gpu_temp_retain_target;
14810 gpu_temp_retain_set = 1;
14811 }
14812 else
14813 {
14814 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14815 }
14816
14817 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14818 }
14819 }
14820
14821 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14822
14823 temp_retain_fanspeed_value[device_id] = fan_speed;
14824
14825 if (fan_speed == -1)
14826 {
14827 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14828
14829 temp_retain_fanspeed_value[device_id] = 0;
14830 }
14831 }
14832
14833 hc_thread_mutex_unlock (mux_adl);
14834 }
14835 }
14836
14837 /**
14838 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14839 */
14840
14841 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14842 {
14843 hc_thread_mutex_lock (mux_adl);
14844
14845 if (data.hm_device[device_id].od_version == 6)
14846 {
14847 int ADL_rc;
14848
14849 // check powertune capabilities first, if not available then skip device
14850
14851 int powertune_supported = 0;
14852
14853 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14854 {
14855 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14856
14857 return (-1);
14858 }
14859
14860 if (powertune_supported != 0)
14861 {
14862 // powercontrol settings
14863
14864 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14865
14866 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14867 {
14868 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14869 }
14870
14871 if (ADL_rc != ADL_OK)
14872 {
14873 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14874
14875 return (-1);
14876 }
14877
14878 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14879 {
14880 log_error ("ERROR: Failed to set new ADL PowerControl values");
14881
14882 return (-1);
14883 }
14884
14885 // clocks
14886
14887 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14888
14889 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14890
14891 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)
14892 {
14893 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14894
14895 return (-1);
14896 }
14897
14898 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14899
14900 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14901
14902 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14903 {
14904 log_error ("ERROR: Failed to get ADL device capabilities");
14905
14906 return (-1);
14907 }
14908
14909 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14910 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14911
14912 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14913 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14914
14915 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14916 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14917
14918 // warning if profile has too low max values
14919
14920 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14921 {
14922 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14923 }
14924
14925 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14926 {
14927 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14928 }
14929
14930 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14931
14932 performance_state->iNumberOfPerformanceLevels = 2;
14933
14934 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14935 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14936 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14937 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14938
14939 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)
14940 {
14941 log_info ("ERROR: Failed to set ADL performance state");
14942
14943 return (-1);
14944 }
14945
14946 local_free (performance_state);
14947 }
14948 }
14949
14950 hc_thread_mutex_unlock (mux_adl);
14951 }
14952 #endif // HAVE_HWMON && HAVE_ADL
14953 }
14954
14955 data.kernel_power_all = kernel_power_all;
14956
14957 if (data.quiet == 0) log_info_nn ("");
14958
14959 /**
14960 * In benchmark-mode, inform user which algorithm is checked
14961 */
14962
14963 if (benchmark == 1)
14964 {
14965 quiet = 0;
14966
14967 data.quiet = quiet;
14968
14969 char *hash_type = strhashtype (data.hash_mode); // not a bug
14970
14971 log_info ("Hashtype: %s", hash_type);
14972 log_info ("");
14973 }
14974
14975 /**
14976 * keep track of the progress
14977 */
14978
14979 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14980 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14981 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14982
14983 /**
14984 * open filehandles
14985 */
14986
14987 #if _WIN
14988 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14989 {
14990 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14991
14992 return (-1);
14993 }
14994
14995 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14996 {
14997 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14998
14999 return (-1);
15000 }
15001
15002 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15003 {
15004 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15005
15006 return (-1);
15007 }
15008 #endif
15009
15010 /**
15011 * dictionary pad
15012 */
15013
15014 segment_size *= (1024 * 1024);
15015
15016 data.segment_size = segment_size;
15017
15018 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15019
15020 wl_data->buf = (char *) mymalloc (segment_size);
15021 wl_data->avail = segment_size;
15022 wl_data->incr = segment_size;
15023 wl_data->cnt = 0;
15024 wl_data->pos = 0;
15025
15026 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15027
15028 data.wordlist_mode = wordlist_mode;
15029
15030 cs_t *css_buf = NULL;
15031 uint css_cnt = 0;
15032 uint dictcnt = 0;
15033 uint maskcnt = 1;
15034 char **masks = NULL;
15035 char **dictfiles = NULL;
15036
15037 uint mask_from_file = 0;
15038
15039 if (attack_mode == ATTACK_MODE_STRAIGHT)
15040 {
15041 if (wordlist_mode == WL_MODE_FILE)
15042 {
15043 int wls_left = myargc - (optind + 1);
15044
15045 for (int i = 0; i < wls_left; i++)
15046 {
15047 char *l0_filename = myargv[optind + 1 + i];
15048
15049 struct stat l0_stat;
15050
15051 if (stat (l0_filename, &l0_stat) == -1)
15052 {
15053 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15054
15055 return (-1);
15056 }
15057
15058 uint is_dir = S_ISDIR (l0_stat.st_mode);
15059
15060 if (is_dir == 0)
15061 {
15062 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15063
15064 dictcnt++;
15065
15066 dictfiles[dictcnt - 1] = l0_filename;
15067 }
15068 else
15069 {
15070 // do not allow --keyspace w/ a directory
15071
15072 if (keyspace == 1)
15073 {
15074 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15075
15076 return (-1);
15077 }
15078
15079 char **dictionary_files = NULL;
15080
15081 dictionary_files = scan_directory (l0_filename);
15082
15083 if (dictionary_files != NULL)
15084 {
15085 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15086
15087 for (int d = 0; dictionary_files[d] != NULL; d++)
15088 {
15089 char *l1_filename = dictionary_files[d];
15090
15091 struct stat l1_stat;
15092
15093 if (stat (l1_filename, &l1_stat) == -1)
15094 {
15095 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15096
15097 return (-1);
15098 }
15099
15100 if (S_ISREG (l1_stat.st_mode))
15101 {
15102 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15103
15104 dictcnt++;
15105
15106 dictfiles[dictcnt - 1] = strdup (l1_filename);
15107 }
15108 }
15109 }
15110
15111 local_free (dictionary_files);
15112 }
15113 }
15114
15115 if (dictcnt < 1)
15116 {
15117 log_error ("ERROR: No usable dictionary file found.");
15118
15119 return (-1);
15120 }
15121 }
15122 else if (wordlist_mode == WL_MODE_STDIN)
15123 {
15124 dictcnt = 1;
15125 }
15126 }
15127 else if (attack_mode == ATTACK_MODE_COMBI)
15128 {
15129 // display
15130
15131 char *dictfile1 = myargv[optind + 1 + 0];
15132 char *dictfile2 = myargv[optind + 1 + 1];
15133
15134 // find the bigger dictionary and use as base
15135
15136 FILE *fp1 = NULL;
15137 FILE *fp2 = NULL;
15138
15139 struct stat tmp_stat;
15140
15141 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15142 {
15143 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15144
15145 return (-1);
15146 }
15147
15148 if (stat (dictfile1, &tmp_stat) == -1)
15149 {
15150 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15151
15152 fclose (fp1);
15153
15154 return (-1);
15155 }
15156
15157 if (S_ISDIR (tmp_stat.st_mode))
15158 {
15159 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15160
15161 fclose (fp1);
15162
15163 return (-1);
15164 }
15165
15166 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15167 {
15168 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15169
15170 fclose (fp1);
15171
15172 return (-1);
15173 }
15174
15175 if (stat (dictfile2, &tmp_stat) == -1)
15176 {
15177 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15178
15179 fclose (fp1);
15180 fclose (fp2);
15181
15182 return (-1);
15183 }
15184
15185 if (S_ISDIR (tmp_stat.st_mode))
15186 {
15187 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15188
15189 fclose (fp1);
15190 fclose (fp2);
15191
15192 return (-1);
15193 }
15194
15195 data.combs_cnt = 1;
15196
15197 data.quiet = 1;
15198
15199 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15200
15201 data.quiet = quiet;
15202
15203 if (words1_cnt == 0)
15204 {
15205 log_error ("ERROR: %s: empty file", dictfile1);
15206
15207 fclose (fp1);
15208 fclose (fp2);
15209
15210 return (-1);
15211 }
15212
15213 data.combs_cnt = 1;
15214
15215 data.quiet = 1;
15216
15217 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15218
15219 data.quiet = quiet;
15220
15221 if (words2_cnt == 0)
15222 {
15223 log_error ("ERROR: %s: empty file", dictfile2);
15224
15225 fclose (fp1);
15226 fclose (fp2);
15227
15228 return (-1);
15229 }
15230
15231 fclose (fp1);
15232 fclose (fp2);
15233
15234 data.dictfile = dictfile1;
15235 data.dictfile2 = dictfile2;
15236
15237 if (words1_cnt >= words2_cnt)
15238 {
15239 data.combs_cnt = words2_cnt;
15240 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15241
15242 dictfiles = &data.dictfile;
15243
15244 dictcnt = 1;
15245 }
15246 else
15247 {
15248 data.combs_cnt = words1_cnt;
15249 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15250
15251 dictfiles = &data.dictfile2;
15252
15253 dictcnt = 1;
15254
15255 // we also have to switch wordlist related rules!
15256
15257 char *tmpc = data.rule_buf_l;
15258
15259 data.rule_buf_l = data.rule_buf_r;
15260 data.rule_buf_r = tmpc;
15261
15262 int tmpi = data.rule_len_l;
15263
15264 data.rule_len_l = data.rule_len_r;
15265 data.rule_len_r = tmpi;
15266 }
15267 }
15268 else if (attack_mode == ATTACK_MODE_BF)
15269 {
15270 char *mask = NULL;
15271
15272 maskcnt = 0;
15273
15274 if (benchmark == 0)
15275 {
15276 mask = myargv[optind + 1];
15277
15278 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15279
15280 if ((optind + 2) <= myargc)
15281 {
15282 struct stat file_stat;
15283
15284 if (stat (mask, &file_stat) == -1)
15285 {
15286 maskcnt = 1;
15287
15288 masks[maskcnt - 1] = mystrdup (mask);
15289 }
15290 else
15291 {
15292 int wls_left = myargc - (optind + 1);
15293
15294 uint masks_avail = INCR_MASKS;
15295
15296 for (int i = 0; i < wls_left; i++)
15297 {
15298 if (i != 0)
15299 {
15300 mask = myargv[optind + 1 + i];
15301
15302 if (stat (mask, &file_stat) == -1)
15303 {
15304 log_error ("ERROR: %s: %s", mask, strerror (errno));
15305
15306 return (-1);
15307 }
15308 }
15309
15310 uint is_file = S_ISREG (file_stat.st_mode);
15311
15312 if (is_file == 1)
15313 {
15314 FILE *mask_fp;
15315
15316 if ((mask_fp = fopen (mask, "r")) == NULL)
15317 {
15318 log_error ("ERROR: %s: %s", mask, strerror (errno));
15319
15320 return (-1);
15321 }
15322
15323 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15324
15325 while (!feof (mask_fp))
15326 {
15327 memset (line_buf, 0, HCBUFSIZ);
15328
15329 int line_len = fgetl (mask_fp, line_buf);
15330
15331 if (line_len == 0) continue;
15332
15333 if (line_buf[0] == '#') continue;
15334
15335 if (masks_avail == maskcnt)
15336 {
15337 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15338
15339 masks_avail += INCR_MASKS;
15340 }
15341
15342 masks[maskcnt] = mystrdup (line_buf);
15343
15344 maskcnt++;
15345 }
15346
15347 myfree (line_buf);
15348
15349 fclose (mask_fp);
15350 }
15351 else
15352 {
15353 log_error ("ERROR: %s: unsupported file-type", mask);
15354
15355 return (-1);
15356 }
15357 }
15358
15359 mask_from_file = 1;
15360 }
15361 }
15362 else
15363 {
15364 custom_charset_1 = (char *) "?l?d?u";
15365 custom_charset_2 = (char *) "?l?d";
15366 custom_charset_3 = (char *) "?l?d*!$@_";
15367
15368 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15369 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15370 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15371
15372 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15373
15374 wordlist_mode = WL_MODE_MASK;
15375
15376 data.wordlist_mode = wordlist_mode;
15377
15378 increment = 1;
15379
15380 maskcnt = 1;
15381 }
15382 }
15383 else
15384 {
15385 /**
15386 * generate full masks and charsets
15387 */
15388
15389 masks = (char **) mymalloc (sizeof (char *));
15390
15391 switch (hash_mode)
15392 {
15393 case 1731: pw_min = 5;
15394 pw_max = 5;
15395 mask = mystrdup ("?b?b?b?b?b");
15396 break;
15397 case 12500: pw_min = 5;
15398 pw_max = 5;
15399 mask = mystrdup ("?b?b?b?b?b");
15400 break;
15401 default: pw_min = 7;
15402 pw_max = 7;
15403 mask = mystrdup ("?b?b?b?b?b?b?b");
15404 break;
15405 }
15406
15407 maskcnt = 1;
15408
15409 masks[maskcnt - 1] = mystrdup (mask);
15410
15411 wordlist_mode = WL_MODE_MASK;
15412
15413 data.wordlist_mode = wordlist_mode;
15414
15415 increment = 1;
15416 }
15417
15418 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15419
15420 if (increment)
15421 {
15422 if (increment_min > pw_min) pw_min = increment_min;
15423
15424 if (increment_max < pw_max) pw_max = increment_max;
15425 }
15426 }
15427 else if (attack_mode == ATTACK_MODE_HYBRID1)
15428 {
15429 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15430
15431 // display
15432
15433 char *mask = myargv[myargc - 1];
15434
15435 maskcnt = 0;
15436
15437 masks = (char **) mymalloc (1 * sizeof (char *));
15438
15439 // mod
15440
15441 struct stat file_stat;
15442
15443 if (stat (mask, &file_stat) == -1)
15444 {
15445 maskcnt = 1;
15446
15447 masks[maskcnt - 1] = mystrdup (mask);
15448 }
15449 else
15450 {
15451 uint is_file = S_ISREG (file_stat.st_mode);
15452
15453 if (is_file == 1)
15454 {
15455 FILE *mask_fp;
15456
15457 if ((mask_fp = fopen (mask, "r")) == NULL)
15458 {
15459 log_error ("ERROR: %s: %s", mask, strerror (errno));
15460
15461 return (-1);
15462 }
15463
15464 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15465
15466 uint masks_avail = 1;
15467
15468 while (!feof (mask_fp))
15469 {
15470 memset (line_buf, 0, HCBUFSIZ);
15471
15472 int line_len = fgetl (mask_fp, line_buf);
15473
15474 if (line_len == 0) continue;
15475
15476 if (line_buf[0] == '#') continue;
15477
15478 if (masks_avail == maskcnt)
15479 {
15480 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15481
15482 masks_avail += INCR_MASKS;
15483 }
15484
15485 masks[maskcnt] = mystrdup (line_buf);
15486
15487 maskcnt++;
15488 }
15489
15490 myfree (line_buf);
15491
15492 fclose (mask_fp);
15493
15494 mask_from_file = 1;
15495 }
15496 else
15497 {
15498 maskcnt = 1;
15499
15500 masks[maskcnt - 1] = mystrdup (mask);
15501 }
15502 }
15503
15504 // base
15505
15506 int wls_left = myargc - (optind + 2);
15507
15508 for (int i = 0; i < wls_left; i++)
15509 {
15510 char *filename = myargv[optind + 1 + i];
15511
15512 struct stat file_stat;
15513
15514 if (stat (filename, &file_stat) == -1)
15515 {
15516 log_error ("ERROR: %s: %s", filename, strerror (errno));
15517
15518 return (-1);
15519 }
15520
15521 uint is_dir = S_ISDIR (file_stat.st_mode);
15522
15523 if (is_dir == 0)
15524 {
15525 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15526
15527 dictcnt++;
15528
15529 dictfiles[dictcnt - 1] = filename;
15530 }
15531 else
15532 {
15533 // do not allow --keyspace w/ a directory
15534
15535 if (keyspace == 1)
15536 {
15537 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15538
15539 return (-1);
15540 }
15541
15542 char **dictionary_files = NULL;
15543
15544 dictionary_files = scan_directory (filename);
15545
15546 if (dictionary_files != NULL)
15547 {
15548 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15549
15550 for (int d = 0; dictionary_files[d] != NULL; d++)
15551 {
15552 char *l1_filename = dictionary_files[d];
15553
15554 struct stat l1_stat;
15555
15556 if (stat (l1_filename, &l1_stat) == -1)
15557 {
15558 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15559
15560 return (-1);
15561 }
15562
15563 if (S_ISREG (l1_stat.st_mode))
15564 {
15565 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15566
15567 dictcnt++;
15568
15569 dictfiles[dictcnt - 1] = strdup (l1_filename);
15570 }
15571 }
15572 }
15573
15574 local_free (dictionary_files);
15575 }
15576 }
15577
15578 if (dictcnt < 1)
15579 {
15580 log_error ("ERROR: No usable dictionary file found.");
15581
15582 return (-1);
15583 }
15584
15585 if (increment)
15586 {
15587 maskcnt = 0;
15588
15589 uint mask_min = increment_min; // we can't reject smaller masks here
15590 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15591
15592 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15593 {
15594 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15595
15596 if (cur_mask == NULL) break;
15597
15598 masks[maskcnt] = cur_mask;
15599
15600 maskcnt++;
15601
15602 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15603 }
15604 }
15605 }
15606 else if (attack_mode == ATTACK_MODE_HYBRID2)
15607 {
15608 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15609
15610 // display
15611
15612 char *mask = myargv[optind + 1 + 0];
15613
15614 maskcnt = 0;
15615
15616 masks = (char **) mymalloc (1 * sizeof (char *));
15617
15618 // mod
15619
15620 struct stat file_stat;
15621
15622 if (stat (mask, &file_stat) == -1)
15623 {
15624 maskcnt = 1;
15625
15626 masks[maskcnt - 1] = mystrdup (mask);
15627 }
15628 else
15629 {
15630 uint is_file = S_ISREG (file_stat.st_mode);
15631
15632 if (is_file == 1)
15633 {
15634 FILE *mask_fp;
15635
15636 if ((mask_fp = fopen (mask, "r")) == NULL)
15637 {
15638 log_error ("ERROR: %s: %s", mask, strerror (errno));
15639
15640 return (-1);
15641 }
15642
15643 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15644
15645 uint masks_avail = 1;
15646
15647 while (!feof (mask_fp))
15648 {
15649 memset (line_buf, 0, HCBUFSIZ);
15650
15651 int line_len = fgetl (mask_fp, line_buf);
15652
15653 if (line_len == 0) continue;
15654
15655 if (line_buf[0] == '#') continue;
15656
15657 if (masks_avail == maskcnt)
15658 {
15659 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15660
15661 masks_avail += INCR_MASKS;
15662 }
15663
15664 masks[maskcnt] = mystrdup (line_buf);
15665
15666 maskcnt++;
15667 }
15668
15669 myfree (line_buf);
15670
15671 fclose (mask_fp);
15672
15673 mask_from_file = 1;
15674 }
15675 else
15676 {
15677 maskcnt = 1;
15678
15679 masks[maskcnt - 1] = mystrdup (mask);
15680 }
15681 }
15682
15683 // base
15684
15685 int wls_left = myargc - (optind + 2);
15686
15687 for (int i = 0; i < wls_left; i++)
15688 {
15689 char *filename = myargv[optind + 2 + i];
15690
15691 struct stat file_stat;
15692
15693 if (stat (filename, &file_stat) == -1)
15694 {
15695 log_error ("ERROR: %s: %s", filename, strerror (errno));
15696
15697 return (-1);
15698 }
15699
15700 uint is_dir = S_ISDIR (file_stat.st_mode);
15701
15702 if (is_dir == 0)
15703 {
15704 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15705
15706 dictcnt++;
15707
15708 dictfiles[dictcnt - 1] = filename;
15709 }
15710 else
15711 {
15712 // do not allow --keyspace w/ a directory
15713
15714 if (keyspace == 1)
15715 {
15716 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15717
15718 return (-1);
15719 }
15720
15721 char **dictionary_files = NULL;
15722
15723 dictionary_files = scan_directory (filename);
15724
15725 if (dictionary_files != NULL)
15726 {
15727 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15728
15729 for (int d = 0; dictionary_files[d] != NULL; d++)
15730 {
15731 char *l1_filename = dictionary_files[d];
15732
15733 struct stat l1_stat;
15734
15735 if (stat (l1_filename, &l1_stat) == -1)
15736 {
15737 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15738
15739 return (-1);
15740 }
15741
15742 if (S_ISREG (l1_stat.st_mode))
15743 {
15744 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15745
15746 dictcnt++;
15747
15748 dictfiles[dictcnt - 1] = strdup (l1_filename);
15749 }
15750 }
15751 }
15752
15753 local_free (dictionary_files);
15754 }
15755 }
15756
15757 if (dictcnt < 1)
15758 {
15759 log_error ("ERROR: No usable dictionary file found.");
15760
15761 return (-1);
15762 }
15763
15764 if (increment)
15765 {
15766 maskcnt = 0;
15767
15768 uint mask_min = increment_min; // we can't reject smaller masks here
15769 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15770
15771 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15772 {
15773 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15774
15775 if (cur_mask == NULL) break;
15776
15777 masks[maskcnt] = cur_mask;
15778
15779 maskcnt++;
15780
15781 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15782 }
15783 }
15784 }
15785
15786 data.pw_min = pw_min;
15787 data.pw_max = pw_max;
15788
15789 /**
15790 * weak hash check
15791 */
15792
15793 if (weak_hash_threshold >= salts_cnt)
15794 {
15795 hc_device_param_t *device_param = NULL;
15796
15797 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15798 {
15799 device_param = &data.devices_param[device_id];
15800
15801 if (device_param->skipped) continue;
15802
15803 break;
15804 }
15805
15806 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15807
15808 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15809 {
15810 weak_hash_check (device_param, salt_pos);
15811 }
15812
15813 // Display hack, guarantee that there is at least one \r before real start
15814
15815 //if (data.quiet == 0) log_info ("");
15816 }
15817
15818 /**
15819 * status and monitor threads
15820 */
15821
15822 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15823
15824 hc_thread_t i_thread = 0;
15825
15826 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15827 {
15828 hc_thread_create (i_thread, thread_keypress, &benchmark);
15829 }
15830
15831 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15832
15833 uint ni_threads_cnt = 0;
15834
15835 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15836
15837 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15838
15839 ni_threads_cnt++;
15840
15841 /**
15842 * Outfile remove
15843 */
15844
15845 if (keyspace == 0)
15846 {
15847 if (outfile_check_timer != 0)
15848 {
15849 if (data.outfile_check_directory != NULL)
15850 {
15851 if ((hash_mode != 5200) &&
15852 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15853 (hash_mode != 9000))
15854 {
15855 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15856
15857 ni_threads_cnt++;
15858 }
15859 else
15860 {
15861 outfile_check_timer = 0;
15862 }
15863 }
15864 else
15865 {
15866 outfile_check_timer = 0;
15867 }
15868 }
15869 }
15870
15871 /**
15872 * Inform the user if we got some hashes remove because of the pot file remove feature
15873 */
15874
15875 if (data.quiet == 0)
15876 {
15877 if (potfile_remove_cracks > 0)
15878 {
15879 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15880 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15881 }
15882 }
15883
15884 data.outfile_check_timer = outfile_check_timer;
15885
15886 /**
15887 * main loop
15888 */
15889
15890 char **induction_dictionaries = NULL;
15891
15892 int induction_dictionaries_cnt = 0;
15893
15894 hcstat_table_t *root_table_buf = NULL;
15895 hcstat_table_t *markov_table_buf = NULL;
15896
15897 uint initial_restore_done = 0;
15898
15899 data.maskcnt = maskcnt;
15900
15901 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15902 {
15903 if (data.devices_status == STATUS_CRACKED) break;
15904
15905 data.devices_status = STATUS_INIT;
15906
15907 if (maskpos > rd->maskpos)
15908 {
15909 rd->dictpos = 0;
15910 }
15911
15912 rd->maskpos = maskpos;
15913 data.maskpos = maskpos;
15914
15915 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15916 {
15917 char *mask = masks[maskpos];
15918
15919 if (mask_from_file == 1)
15920 {
15921 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15922
15923 char *str_ptr;
15924 uint str_pos;
15925
15926 uint mask_offset = 0;
15927
15928 uint separator_cnt;
15929
15930 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15931 {
15932 str_ptr = strstr (mask + mask_offset, ",");
15933
15934 if (str_ptr == NULL) break;
15935
15936 str_pos = str_ptr - mask;
15937
15938 // escaped separator, i.e. "\,"
15939
15940 if (str_pos > 0)
15941 {
15942 if (mask[str_pos - 1] == '\\')
15943 {
15944 separator_cnt --;
15945
15946 mask_offset = str_pos + 1;
15947
15948 continue;
15949 }
15950 }
15951
15952 // reset the offset
15953
15954 mask_offset = 0;
15955
15956 mask[str_pos] = '\0';
15957
15958 switch (separator_cnt)
15959 {
15960 case 0:
15961 mp_reset_usr (mp_usr, 0);
15962
15963 custom_charset_1 = mask;
15964 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15965 break;
15966
15967 case 1:
15968 mp_reset_usr (mp_usr, 1);
15969
15970 custom_charset_2 = mask;
15971 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15972 break;
15973
15974 case 2:
15975 mp_reset_usr (mp_usr, 2);
15976
15977 custom_charset_3 = mask;
15978 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15979 break;
15980
15981 case 3:
15982 mp_reset_usr (mp_usr, 3);
15983
15984 custom_charset_4 = mask;
15985 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15986 break;
15987 }
15988
15989 mask = mask + str_pos + 1;
15990 }
15991 }
15992
15993 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15994 {
15995 if (maskpos > 0)
15996 {
15997 local_free (css_buf);
15998 local_free (data.root_css_buf);
15999 local_free (data.markov_css_buf);
16000
16001 local_free (masks[maskpos - 1]);
16002 }
16003
16004 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16005
16006 data.mask = mask;
16007 data.css_cnt = css_cnt;
16008 data.css_buf = css_buf;
16009
16010 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16011
16012 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16013
16014 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16015 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16016
16017 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16018
16019 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16020
16021 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16022 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16023
16024 data.root_css_buf = root_css_buf;
16025 data.markov_css_buf = markov_css_buf;
16026
16027 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16028
16029 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16030
16031 local_free (root_table_buf);
16032 local_free (markov_table_buf);
16033
16034 // args
16035
16036 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16037 {
16038 hc_device_param_t *device_param = &data.devices_param[device_id];
16039
16040 if (device_param->skipped) continue;
16041
16042 device_param->kernel_params_mp[0] = &device_param->d_combs;
16043 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16044 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16045
16046 device_param->kernel_params_mp_buf64[3] = 0;
16047 device_param->kernel_params_mp_buf32[4] = css_cnt;
16048 device_param->kernel_params_mp_buf32[5] = 0;
16049 device_param->kernel_params_mp_buf32[6] = 0;
16050 device_param->kernel_params_mp_buf32[7] = 0;
16051
16052 if (attack_mode == ATTACK_MODE_HYBRID1)
16053 {
16054 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16055 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16056 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16057 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16058 }
16059 else if (attack_mode == ATTACK_MODE_HYBRID2)
16060 {
16061 device_param->kernel_params_mp_buf32[5] = 0;
16062 device_param->kernel_params_mp_buf32[6] = 0;
16063 device_param->kernel_params_mp_buf32[7] = 0;
16064 }
16065
16066 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]);
16067 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]);
16068 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]);
16069
16070 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);
16071 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);
16072 }
16073 }
16074 else if (attack_mode == ATTACK_MODE_BF)
16075 {
16076 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16077
16078 if (increment)
16079 {
16080 for (uint i = 0; i < dictcnt; i++)
16081 {
16082 local_free (dictfiles[i]);
16083 }
16084
16085 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16086 {
16087 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16088
16089 if (l1_filename == NULL) break;
16090
16091 dictcnt++;
16092
16093 dictfiles[dictcnt - 1] = l1_filename;
16094 }
16095 }
16096 else
16097 {
16098 dictcnt++;
16099
16100 dictfiles[dictcnt - 1] = mask;
16101 }
16102
16103 if (dictcnt == 0)
16104 {
16105 log_error ("ERROR: Mask is too small");
16106
16107 return (-1);
16108 }
16109 }
16110 }
16111
16112 free (induction_dictionaries);
16113
16114 // induction_dictionaries_cnt = 0; // implied
16115
16116 if (attack_mode != ATTACK_MODE_BF)
16117 {
16118 if (keyspace == 0)
16119 {
16120 induction_dictionaries = scan_directory (induction_directory);
16121
16122 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16123 }
16124 }
16125
16126 if (induction_dictionaries_cnt)
16127 {
16128 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16129 }
16130
16131 /**
16132 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16133 */
16134 if (keyspace == 1)
16135 {
16136 if ((maskcnt > 1) || (dictcnt > 1))
16137 {
16138 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16139
16140 return (-1);
16141 }
16142 }
16143
16144 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16145 {
16146 char *subid = logfile_generate_subid ();
16147
16148 data.subid = subid;
16149
16150 logfile_sub_msg ("START");
16151
16152 data.devices_status = STATUS_INIT;
16153
16154 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16155 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16156 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16157
16158 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16159
16160 data.cpt_pos = 0;
16161
16162 data.cpt_start = time (NULL);
16163
16164 data.cpt_total = 0;
16165
16166 if (data.restore == 0)
16167 {
16168 rd->words_cur = skip;
16169
16170 skip = 0;
16171
16172 data.skip = 0;
16173 }
16174
16175 data.ms_paused = 0;
16176
16177 data.words_cur = rd->words_cur;
16178
16179 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16180 {
16181 hc_device_param_t *device_param = &data.devices_param[device_id];
16182
16183 if (device_param->skipped) continue;
16184
16185 device_param->speed_pos = 0;
16186
16187 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16188 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16189
16190 device_param->exec_pos = 0;
16191
16192 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16193
16194 device_param->kernel_power = device_param->kernel_power_user;
16195
16196 device_param->outerloop_pos = 0;
16197 device_param->outerloop_left = 0;
16198 device_param->innerloop_pos = 0;
16199 device_param->innerloop_left = 0;
16200
16201 // some more resets:
16202
16203 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16204
16205 device_param->pws_cnt = 0;
16206
16207 device_param->words_off = 0;
16208 device_param->words_done = 0;
16209 }
16210
16211 data.kernel_power_div = 0;
16212
16213 // figure out some workload
16214
16215 if (attack_mode == ATTACK_MODE_STRAIGHT)
16216 {
16217 if (data.wordlist_mode == WL_MODE_FILE)
16218 {
16219 char *dictfile = NULL;
16220
16221 if (induction_dictionaries_cnt)
16222 {
16223 dictfile = induction_dictionaries[0];
16224 }
16225 else
16226 {
16227 dictfile = dictfiles[dictpos];
16228 }
16229
16230 data.dictfile = dictfile;
16231
16232 logfile_sub_string (dictfile);
16233
16234 for (uint i = 0; i < rp_files_cnt; i++)
16235 {
16236 logfile_sub_var_string ("rulefile", rp_files[i]);
16237 }
16238
16239 FILE *fd2 = fopen (dictfile, "rb");
16240
16241 if (fd2 == NULL)
16242 {
16243 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16244
16245 return (-1);
16246 }
16247
16248 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16249
16250 fclose (fd2);
16251
16252 if (data.words_cnt == 0)
16253 {
16254 if (data.devices_status == STATUS_CRACKED) break;
16255 if (data.devices_status == STATUS_ABORTED) break;
16256
16257 dictpos++;
16258
16259 continue;
16260 }
16261 }
16262 }
16263 else if (attack_mode == ATTACK_MODE_COMBI)
16264 {
16265 char *dictfile = data.dictfile;
16266 char *dictfile2 = data.dictfile2;
16267
16268 logfile_sub_string (dictfile);
16269 logfile_sub_string (dictfile2);
16270
16271 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16272 {
16273 FILE *fd2 = fopen (dictfile, "rb");
16274
16275 if (fd2 == NULL)
16276 {
16277 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16278
16279 return (-1);
16280 }
16281
16282 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16283
16284 fclose (fd2);
16285 }
16286 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16287 {
16288 FILE *fd2 = fopen (dictfile2, "rb");
16289
16290 if (fd2 == NULL)
16291 {
16292 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16293
16294 return (-1);
16295 }
16296
16297 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16298
16299 fclose (fd2);
16300 }
16301
16302 if (data.words_cnt == 0)
16303 {
16304 if (data.devices_status == STATUS_CRACKED) break;
16305 if (data.devices_status == STATUS_ABORTED) break;
16306
16307 dictpos++;
16308
16309 continue;
16310 }
16311 }
16312 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16313 {
16314 char *dictfile = NULL;
16315
16316 if (induction_dictionaries_cnt)
16317 {
16318 dictfile = induction_dictionaries[0];
16319 }
16320 else
16321 {
16322 dictfile = dictfiles[dictpos];
16323 }
16324
16325 data.dictfile = dictfile;
16326
16327 char *mask = data.mask;
16328
16329 logfile_sub_string (dictfile);
16330 logfile_sub_string (mask);
16331
16332 FILE *fd2 = fopen (dictfile, "rb");
16333
16334 if (fd2 == NULL)
16335 {
16336 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16337
16338 return (-1);
16339 }
16340
16341 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16342
16343 fclose (fd2);
16344
16345 if (data.words_cnt == 0)
16346 {
16347 if (data.devices_status == STATUS_CRACKED) break;
16348 if (data.devices_status == STATUS_ABORTED) break;
16349
16350 dictpos++;
16351
16352 continue;
16353 }
16354 }
16355 else if (attack_mode == ATTACK_MODE_BF)
16356 {
16357 local_free (css_buf);
16358 local_free (data.root_css_buf);
16359 local_free (data.markov_css_buf);
16360
16361 char *mask = dictfiles[dictpos];
16362
16363 logfile_sub_string (mask);
16364
16365 // base
16366
16367 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16368
16369 if (opts_type & OPTS_TYPE_PT_UNICODE)
16370 {
16371 uint css_cnt_unicode = css_cnt * 2;
16372
16373 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16374
16375 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16376 {
16377 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16378
16379 css_buf_unicode[j + 1].cs_buf[0] = 0;
16380 css_buf_unicode[j + 1].cs_len = 1;
16381 }
16382
16383 free (css_buf);
16384
16385 css_buf = css_buf_unicode;
16386 css_cnt = css_cnt_unicode;
16387 }
16388
16389 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16390
16391 uint mask_min = pw_min;
16392 uint mask_max = pw_max;
16393
16394 if (opts_type & OPTS_TYPE_PT_UNICODE)
16395 {
16396 mask_min *= 2;
16397 mask_max *= 2;
16398 }
16399
16400 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16401 {
16402 if (css_cnt < mask_min)
16403 {
16404 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16405 }
16406
16407 if (css_cnt > mask_max)
16408 {
16409 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16410 }
16411
16412 // skip to next mask
16413
16414 dictpos++;
16415
16416 rd->dictpos = dictpos;
16417
16418 logfile_sub_msg ("STOP");
16419
16420 continue;
16421 }
16422
16423 uint save_css_cnt = css_cnt;
16424
16425 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16426 {
16427 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16428 {
16429 uint salt_len = (uint) data.salts_buf[0].salt_len;
16430 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16431
16432 uint css_cnt_salt = css_cnt + salt_len;
16433
16434 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16435
16436 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16437
16438 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16439 {
16440 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16441 css_buf_salt[j].cs_len = 1;
16442 }
16443
16444 free (css_buf);
16445
16446 css_buf = css_buf_salt;
16447 css_cnt = css_cnt_salt;
16448 }
16449 }
16450
16451 data.mask = mask;
16452 data.css_cnt = css_cnt;
16453 data.css_buf = css_buf;
16454
16455 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16456
16457 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16458
16459 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16460
16461 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16462 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16463
16464 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16465
16466 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16467
16468 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16469 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16470
16471 data.root_css_buf = root_css_buf;
16472 data.markov_css_buf = markov_css_buf;
16473
16474 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16475
16476 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16477
16478 local_free (root_table_buf);
16479 local_free (markov_table_buf);
16480
16481 // copy + args
16482
16483 uint css_cnt_l = css_cnt;
16484 uint css_cnt_r;
16485
16486 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16487 {
16488 if (save_css_cnt < 6)
16489 {
16490 css_cnt_r = 1;
16491 }
16492 else if (save_css_cnt == 6)
16493 {
16494 css_cnt_r = 2;
16495 }
16496 else
16497 {
16498 if (opts_type & OPTS_TYPE_PT_UNICODE)
16499 {
16500 if (save_css_cnt == 8 || save_css_cnt == 10)
16501 {
16502 css_cnt_r = 2;
16503 }
16504 else
16505 {
16506 css_cnt_r = 4;
16507 }
16508 }
16509 else
16510 {
16511 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16512 {
16513 css_cnt_r = 3;
16514 }
16515 else
16516 {
16517 css_cnt_r = 4;
16518 }
16519 }
16520 }
16521 }
16522 else
16523 {
16524 css_cnt_r = 1;
16525
16526 /* unfinished code?
16527 int sum = css_buf[css_cnt_r - 1].cs_len;
16528
16529 for (uint i = 1; i < 4 && i < css_cnt; i++)
16530 {
16531 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16532
16533 css_cnt_r++;
16534
16535 sum *= css_buf[css_cnt_r - 1].cs_len;
16536 }
16537 */
16538 }
16539
16540 css_cnt_l -= css_cnt_r;
16541
16542 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16543
16544 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16545 {
16546 hc_device_param_t *device_param = &data.devices_param[device_id];
16547
16548 if (device_param->skipped) continue;
16549
16550 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16551 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16552 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16553
16554 device_param->kernel_params_mp_l_buf64[3] = 0;
16555 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16556 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16557 device_param->kernel_params_mp_l_buf32[6] = 0;
16558 device_param->kernel_params_mp_l_buf32[7] = 0;
16559 device_param->kernel_params_mp_l_buf32[8] = 0;
16560
16561 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16562 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16563 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16564 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16565
16566 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16567 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16568 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16569
16570 device_param->kernel_params_mp_r_buf64[3] = 0;
16571 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16572 device_param->kernel_params_mp_r_buf32[5] = 0;
16573 device_param->kernel_params_mp_r_buf32[6] = 0;
16574 device_param->kernel_params_mp_r_buf32[7] = 0;
16575
16576 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]);
16577 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]);
16578 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]);
16579
16580 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]);
16581 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]);
16582 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]);
16583
16584 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);
16585 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);
16586 }
16587 }
16588
16589 u64 words_base = data.words_cnt;
16590
16591 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16592 {
16593 if (data.kernel_rules_cnt)
16594 {
16595 words_base /= data.kernel_rules_cnt;
16596 }
16597 }
16598 else if (data.attack_kern == ATTACK_KERN_COMBI)
16599 {
16600 if (data.combs_cnt)
16601 {
16602 words_base /= data.combs_cnt;
16603 }
16604 }
16605 else if (data.attack_kern == ATTACK_KERN_BF)
16606 {
16607 if (data.bfs_cnt)
16608 {
16609 words_base /= data.bfs_cnt;
16610 }
16611 }
16612
16613 data.words_base = words_base;
16614
16615 if (keyspace == 1)
16616 {
16617 log_info ("%llu", (unsigned long long int) words_base);
16618
16619 return (0);
16620 }
16621
16622 if (data.words_cur > data.words_base)
16623 {
16624 log_error ("ERROR: restore value greater keyspace");
16625
16626 return (-1);
16627 }
16628
16629 if (data.words_cur)
16630 {
16631 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16632 {
16633 for (uint i = 0; i < data.salts_cnt; i++)
16634 {
16635 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16636 }
16637 }
16638 else if (data.attack_kern == ATTACK_KERN_COMBI)
16639 {
16640 for (uint i = 0; i < data.salts_cnt; i++)
16641 {
16642 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16643 }
16644 }
16645 else if (data.attack_kern == ATTACK_KERN_BF)
16646 {
16647 for (uint i = 0; i < data.salts_cnt; i++)
16648 {
16649 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16650 }
16651 }
16652 }
16653
16654 /*
16655 * Inform user about possible slow speeds
16656 */
16657
16658 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16659 {
16660 if (data.words_base < kernel_power_all)
16661 {
16662 if (quiet == 0)
16663 {
16664 log_info ("ATTENTION!");
16665 log_info (" The wordlist or mask you are using is too small.");
16666 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
16667 log_info (" The cracking speed will drop.");
16668 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16669 log_info ("");
16670 }
16671 }
16672 }
16673
16674 /*
16675 * Update loopback file
16676 */
16677
16678 if (loopback == 1)
16679 {
16680 time_t now;
16681
16682 time (&now);
16683
16684 uint random_num = get_random_num (0, 9999);
16685
16686 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16687
16688 data.loopback_file = loopback_file;
16689 }
16690
16691 /*
16692 * Update dictionary statistic
16693 */
16694
16695 if (keyspace == 0)
16696 {
16697 dictstat_fp = fopen (dictstat, "wb");
16698
16699 if (dictstat_fp)
16700 {
16701 lock_file (dictstat_fp);
16702
16703 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16704
16705 fclose (dictstat_fp);
16706 }
16707 }
16708
16709 data.devices_status = STATUS_RUNNING;
16710
16711 if (initial_restore_done == 0)
16712 {
16713 if (data.restore_disable == 0) cycle_restore ();
16714
16715 initial_restore_done = 1;
16716 }
16717
16718 hc_timer_set (&data.timer_running);
16719
16720 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16721 {
16722 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16723 {
16724 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16725 if (quiet == 0) fflush (stdout);
16726 }
16727 }
16728 else if (wordlist_mode == WL_MODE_STDIN)
16729 {
16730 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16731 if (data.quiet == 0) log_info ("");
16732 }
16733
16734 time_t runtime_start;
16735
16736 time (&runtime_start);
16737
16738 data.runtime_start = runtime_start;
16739
16740 /**
16741 * create cracker threads
16742 */
16743
16744 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16745
16746 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16747 {
16748 hc_device_param_t *device_param = &devices_param[device_id];
16749
16750 if (wordlist_mode == WL_MODE_STDIN)
16751 {
16752 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16753 }
16754 else
16755 {
16756 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16757 }
16758 }
16759
16760 // wait for crack threads to exit
16761
16762 hc_thread_wait (data.devices_cnt, c_threads);
16763
16764 local_free (c_threads);
16765
16766 data.restore = 0;
16767
16768 // finalize task
16769
16770 logfile_sub_var_uint ("status-after-work", data.devices_status);
16771
16772 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16773
16774 if (data.devices_status == STATUS_CRACKED) break;
16775 if (data.devices_status == STATUS_ABORTED) break;
16776
16777 if (data.devices_status == STATUS_BYPASS)
16778 {
16779 data.devices_status = STATUS_RUNNING;
16780 }
16781
16782 if (induction_dictionaries_cnt)
16783 {
16784 unlink (induction_dictionaries[0]);
16785 }
16786
16787 free (induction_dictionaries);
16788
16789 if (attack_mode != ATTACK_MODE_BF)
16790 {
16791 induction_dictionaries = scan_directory (induction_directory);
16792
16793 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16794 }
16795
16796 if (benchmark == 0)
16797 {
16798 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16799 {
16800 if (quiet == 0) clear_prompt ();
16801
16802 if (quiet == 0) log_info ("");
16803
16804 if (status == 1)
16805 {
16806 status_display ();
16807 }
16808 else
16809 {
16810 if (quiet == 0) status_display ();
16811 }
16812
16813 if (quiet == 0) log_info ("");
16814 }
16815 }
16816
16817 if (attack_mode == ATTACK_MODE_BF)
16818 {
16819 dictpos++;
16820
16821 rd->dictpos = dictpos;
16822 }
16823 else
16824 {
16825 if (induction_dictionaries_cnt)
16826 {
16827 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16828 }
16829 else
16830 {
16831 dictpos++;
16832
16833 rd->dictpos = dictpos;
16834 }
16835 }
16836
16837 time_t runtime_stop;
16838
16839 time (&runtime_stop);
16840
16841 data.runtime_stop = runtime_stop;
16842
16843 logfile_sub_uint (runtime_start);
16844 logfile_sub_uint (runtime_stop);
16845
16846 logfile_sub_msg ("STOP");
16847
16848 global_free (subid);
16849 }
16850
16851 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16852
16853 if (data.devices_status == STATUS_CRACKED) break;
16854 if (data.devices_status == STATUS_ABORTED) break;
16855 if (data.devices_status == STATUS_QUIT) break;
16856
16857 if (data.devices_status == STATUS_BYPASS)
16858 {
16859 data.devices_status = STATUS_RUNNING;
16860 }
16861 }
16862
16863 // 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
16864
16865 if (attack_mode == ATTACK_MODE_STRAIGHT)
16866 {
16867 if (data.wordlist_mode == WL_MODE_FILE)
16868 {
16869 if (data.dictfile == NULL)
16870 {
16871 if (dictfiles != NULL)
16872 {
16873 data.dictfile = dictfiles[0];
16874
16875 hc_timer_set (&data.timer_running);
16876 }
16877 }
16878 }
16879 }
16880 // NOTE: combi is okay because it is already set beforehand
16881 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16882 {
16883 if (data.dictfile == NULL)
16884 {
16885 if (dictfiles != NULL)
16886 {
16887 hc_timer_set (&data.timer_running);
16888
16889 data.dictfile = dictfiles[0];
16890 }
16891 }
16892 }
16893 else if (attack_mode == ATTACK_MODE_BF)
16894 {
16895 if (data.mask == NULL)
16896 {
16897 hc_timer_set (&data.timer_running);
16898
16899 data.mask = masks[0];
16900 }
16901 }
16902
16903 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16904 {
16905 data.devices_status = STATUS_EXHAUSTED;
16906 }
16907
16908 // if cracked / aborted remove last induction dictionary
16909
16910 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16911 {
16912 struct stat induct_stat;
16913
16914 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16915 {
16916 unlink (induction_dictionaries[file_pos]);
16917 }
16918 }
16919
16920 // wait for non-interactive threads
16921
16922 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16923 {
16924 hc_thread_wait (1, &ni_threads[thread_idx]);
16925 }
16926
16927 local_free (ni_threads);
16928
16929 // wait for interactive threads
16930
16931 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16932 {
16933 hc_thread_wait (1, &i_thread);
16934 }
16935
16936 // we dont need restore file anymore
16937 if (data.restore_disable == 0)
16938 {
16939 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16940 {
16941 unlink (eff_restore_file);
16942 unlink (new_restore_file);
16943 }
16944 else
16945 {
16946 cycle_restore ();
16947 }
16948 }
16949
16950 // finally save left hashes
16951
16952 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16953 {
16954 save_hash ();
16955 }
16956
16957 /**
16958 * Clean up
16959 */
16960
16961 if (benchmark == 1)
16962 {
16963 status_benchmark ();
16964
16965 log_info ("");
16966 }
16967 else
16968 {
16969 if (quiet == 0) clear_prompt ();
16970
16971 if (quiet == 0) log_info ("");
16972
16973 if (status == 1)
16974 {
16975 status_display ();
16976 }
16977 else
16978 {
16979 if (quiet == 0) status_display ();
16980 }
16981
16982 if (quiet == 0) log_info ("");
16983 }
16984
16985 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16986 {
16987 hc_device_param_t *device_param = &data.devices_param[device_id];
16988
16989 if (device_param->skipped) continue;
16990
16991 local_free (device_param->result);
16992
16993 local_free (device_param->combs_buf);
16994
16995 local_free (device_param->hooks_buf);
16996
16997 local_free (device_param->device_name);
16998
16999 local_free (device_param->device_name_chksum);
17000
17001 local_free (device_param->device_version);
17002
17003 local_free (device_param->driver_version);
17004
17005 if (device_param->pws_buf) myfree (device_param->pws_buf);
17006 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17007 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17008 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17009 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17010 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17011 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17012 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17013 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17014 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17015 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17016 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17017 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17018 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17019 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17020 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17021 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17022 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17023 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17024 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17025 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17026 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17027 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17028 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17029 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17030 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17031 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17032 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17033 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17034
17035 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17036 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17037 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17038 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17039 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17040 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17041 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17042 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17043 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17044 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17045
17046 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17047 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17048 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17049
17050 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17051 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17052 }
17053
17054 // reset default fan speed
17055
17056 #ifdef HAVE_HWMON
17057 if (gpu_temp_disable == 0)
17058 {
17059 #ifdef HAVE_ADL
17060 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17061 {
17062 hc_thread_mutex_lock (mux_adl);
17063
17064 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17065 {
17066 hc_device_param_t *device_param = &data.devices_param[device_id];
17067
17068 if (device_param->skipped) continue;
17069
17070 if (data.hm_device[device_id].fan_supported == 1)
17071 {
17072 int fanspeed = temp_retain_fanspeed_value[device_id];
17073
17074 if (fanspeed == -1) continue;
17075
17076 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
17077
17078 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
17079 }
17080 }
17081
17082 hc_thread_mutex_unlock (mux_adl);
17083 }
17084 #endif // HAVE_ADL
17085 }
17086
17087 #ifdef HAVE_ADL
17088 // reset power tuning
17089
17090 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17091 {
17092 hc_thread_mutex_lock (mux_adl);
17093
17094 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17095 {
17096 hc_device_param_t *device_param = &data.devices_param[device_id];
17097
17098 if (device_param->skipped) continue;
17099
17100 if (data.hm_device[device_id].od_version == 6)
17101 {
17102 // check powertune capabilities first, if not available then skip device
17103
17104 int powertune_supported = 0;
17105
17106 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17107 {
17108 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17109
17110 return (-1);
17111 }
17112
17113 if (powertune_supported != 0)
17114 {
17115 // powercontrol settings
17116
17117 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)
17118 {
17119 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17120
17121 return (-1);
17122 }
17123
17124 // clocks
17125
17126 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17127
17128 performance_state->iNumberOfPerformanceLevels = 2;
17129
17130 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17131 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17132 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17133 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17134
17135 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)
17136 {
17137 log_info ("ERROR: Failed to restore ADL performance state");
17138
17139 return (-1);
17140 }
17141
17142 local_free (performance_state);
17143 }
17144 }
17145 }
17146
17147 hc_thread_mutex_unlock (mux_adl);
17148 }
17149 #endif // HAVE_ADL
17150
17151 if (gpu_temp_disable == 0)
17152 {
17153 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17154 if (data.hm_nv)
17155 {
17156 #if defined(LINUX) && defined(HAVE_NVML)
17157
17158 hm_NVML_nvmlShutdown (data.hm_nv);
17159
17160 nvml_close (data.hm_nv);
17161
17162 #elif defined(WIN) && (HAVE_NVAPI)
17163
17164 hm_NvAPI_Unload (data.hm_nv);
17165
17166 nvapi_close (data.hm_nv);
17167
17168 #endif
17169
17170 data.hm_nv = NULL;
17171 }
17172 #endif
17173
17174 #ifdef HAVE_ADL
17175 if (data.hm_amd)
17176 {
17177 hm_ADL_Main_Control_Destroy (data.hm_amd);
17178
17179 adl_close (data.hm_amd);
17180 data.hm_amd = NULL;
17181 }
17182 #endif
17183 }
17184 #endif // HAVE_HWMON
17185
17186 // free memory
17187
17188 local_free (masks);
17189
17190 local_free (dictstat_base);
17191
17192 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17193 {
17194 pot_t *pot_ptr = &pot[pot_pos];
17195
17196 hash_t *hash = &pot_ptr->hash;
17197
17198 local_free (hash->digest);
17199
17200 if (isSalted)
17201 {
17202 local_free (hash->salt);
17203 }
17204 }
17205
17206 local_free (pot);
17207
17208 local_free (all_kernel_rules_cnt);
17209 local_free (all_kernel_rules_buf);
17210
17211 local_free (wl_data->buf);
17212 local_free (wl_data);
17213
17214 local_free (bitmap_s1_a);
17215 local_free (bitmap_s1_b);
17216 local_free (bitmap_s1_c);
17217 local_free (bitmap_s1_d);
17218 local_free (bitmap_s2_a);
17219 local_free (bitmap_s2_b);
17220 local_free (bitmap_s2_c);
17221 local_free (bitmap_s2_d);
17222
17223 #ifdef HAVE_HWMON
17224 local_free (temp_retain_fanspeed_value);
17225 #ifdef HAVE_ADL
17226 local_free (od_clock_mem_status);
17227 local_free (od_power_control_status);
17228 #endif // ADL
17229 #endif
17230
17231 global_free (devices_param);
17232
17233 global_free (kernel_rules_buf);
17234
17235 global_free (root_css_buf);
17236 global_free (markov_css_buf);
17237
17238 global_free (digests_buf);
17239 global_free (digests_shown);
17240 global_free (digests_shown_tmp);
17241
17242 global_free (salts_buf);
17243 global_free (salts_shown);
17244
17245 global_free (esalts_buf);
17246
17247 global_free (words_progress_done);
17248 global_free (words_progress_rejected);
17249 global_free (words_progress_restored);
17250
17251 if (pot_fp) fclose (pot_fp);
17252
17253 if (data.devices_status == STATUS_QUIT) break;
17254 }
17255
17256 // destroy others mutex
17257
17258 hc_thread_mutex_delete (mux_dispatcher);
17259 hc_thread_mutex_delete (mux_counter);
17260 hc_thread_mutex_delete (mux_display);
17261 hc_thread_mutex_delete (mux_adl);
17262
17263 // free memory
17264
17265 local_free (eff_restore_file);
17266 local_free (new_restore_file);
17267
17268 local_free (rd);
17269
17270 // tuning db
17271
17272 tuning_db_destroy (tuning_db);
17273
17274 // loopback
17275
17276 local_free (loopback_file);
17277
17278 if (loopback == 1) unlink (loopback_file);
17279
17280 // induction directory
17281
17282 if (induction_dir == NULL)
17283 {
17284 if (attack_mode != ATTACK_MODE_BF)
17285 {
17286 if (rmdir (induction_directory) == -1)
17287 {
17288 if (errno == ENOENT)
17289 {
17290 // good, we can ignore
17291 }
17292 else if (errno == ENOTEMPTY)
17293 {
17294 // good, we can ignore
17295 }
17296 else
17297 {
17298 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17299
17300 return (-1);
17301 }
17302 }
17303
17304 local_free (induction_directory);
17305 }
17306 }
17307
17308 // outfile-check directory
17309
17310 if (outfile_check_dir == NULL)
17311 {
17312 if (rmdir (outfile_check_directory) == -1)
17313 {
17314 if (errno == ENOENT)
17315 {
17316 // good, we can ignore
17317 }
17318 else if (errno == ENOTEMPTY)
17319 {
17320 // good, we can ignore
17321 }
17322 else
17323 {
17324 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17325
17326 return (-1);
17327 }
17328 }
17329
17330 local_free (outfile_check_directory);
17331 }
17332
17333 time_t proc_stop;
17334
17335 time (&proc_stop);
17336
17337 logfile_top_uint (proc_start);
17338 logfile_top_uint (proc_stop);
17339
17340 logfile_top_msg ("STOP");
17341
17342 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17343 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17344
17345 if (data.ocl) ocl_close (data.ocl);
17346
17347 if (data.devices_status == STATUS_ABORTED) return 2;
17348 if (data.devices_status == STATUS_QUIT) return 2;
17349 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17350 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17351 if (data.devices_status == STATUS_CRACKED) return 0;
17352
17353 return -1;
17354 }
Hashcat additions to support pwdhash