projects / hashcat.git / blob
? search:


ff33c72776262bfb8f669c205f126d407ba95e85
[hashcat.git] / src / hashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "hashcat";
19 const uint VERSION_BIN = 300;
20 const uint RESTORE_MIN = 300;
21
22 double TARGET_MS_PROFILE[3] = { 8, 16, 96 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define RESTORE 0
37 #define RESTORE_TIMER 60
38 #define RESTORE_DISABLE 0
39 #define STATUS 0
40 #define STATUS_TIMER 10
41 #define STATUS_AUTOMAT 0
42 #define LOOPBACK 0
43 #define WEAK_HASH_THRESHOLD 100
44 #define SHOW 0
45 #define LEFT 0
46 #define USERNAME 0
47 #define REMOVE 0
48 #define REMOVE_TIMER 60
49 #define SKIP 0
50 #define LIMIT 0
51 #define KEYSPACE 0
52 #define POTFILE_DISABLE 0
53 #define DEBUG_MODE 0
54 #define RP_GEN 0
55 #define RP_GEN_FUNC_MIN 1
56 #define RP_GEN_FUNC_MAX 4
57 #define RP_GEN_SEED 0
58 #define RULE_BUF_L ":"
59 #define RULE_BUF_R ":"
60 #define FORCE 0
61 #define RUNTIME 0
62 #define HEX_CHARSET 0
63 #define HEX_SALT 0
64 #define HEX_WORDLIST 0
65 #define OUTFILE_FORMAT 3
66 #define OUTFILE_AUTOHEX 1
67 #define OUTFILE_CHECK_TIMER 5
68 #define ATTACK_MODE 0
69 #define HASH_MODE 0
70 #define SEGMENT_SIZE 32
71 #define INCREMENT 0
72 #define INCREMENT_MIN 1
73 #define INCREMENT_MAX PW_MAX
74 #define SEPARATOR ':'
75 #define BITMAP_MIN 16
76 #define BITMAP_MAX 24
77 #define GPU_TEMP_DISABLE 0
78 #define GPU_TEMP_ABORT 90
79 #define GPU_TEMP_RETAIN 80
80 #define WORKLOAD_PROFILE 2
81 #define KERNEL_ACCEL 0
82 #define KERNEL_LOOPS 0
83 #define KERNEL_RULES 1024
84 #define KERNEL_COMBS 1024
85 #define KERNEL_BFS 1024
86 #define KERNEL_THREADS_MAX 256
87 #define KERNEL_THREADS_MAX_CPU 16
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 137
152
153 #define global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
168 {
169 900,
170 0,
171 5100,
172 100,
173 1400,
174 10800,
175 1700,
176 5000,
177 10100,
178 6000,
179 6100,
180 6900,
181 11700,
182 11800,
183 400,
184 8900,
185 11900,
186 12000,
187 10900,
188 12100,
189 23,
190 2500,
191 5300,
192 5400,
193 5500,
194 5600,
195 7300,
196 7500,
197 13100,
198 8300,
199 11100,
200 11200,
201 11400,
202 121,
203 2611,
204 2711,
205 2811,
206 8400,
207 11,
208 2612,
209 7900,
210 21,
211 11000,
212 124,
213 10000,
214 3711,
215 7600,
216 12,
217 131,
218 132,
219 1731,
220 200,
221 300,
222 3100,
223 112,
224 12300,
225 8000,
226 141,
227 1441,
228 1600,
229 12600,
230 1421,
231 101,
232 111,
233 1711,
234 3000,
235 1000,
236 1100,
237 2100,
238 12800,
239 1500,
240 12400,
241 500,
242 3200,
243 7400,
244 1800,
245 122,
246 1722,
247 7100,
248 6300,
249 6700,
250 6400,
251 6500,
252 2400,
253 2410,
254 5700,
255 9200,
256 9300,
257 22,
258 501,
259 5800,
260 8100,
261 8500,
262 7200,
263 9900,
264 7700,
265 7800,
266 10300,
267 8600,
268 8700,
269 9100,
270 133,
271 13500,
272 11600,
273 13600,
274 12500,
275 13000,
276 13200,
277 13300,
278 6211,
279 6221,
280 6231,
281 6241,
282 8800,
283 12900,
284 12200,
285 9700,
286 9710,
287 9800,
288 9810,
289 9400,
290 9500,
291 9600,
292 10400,
293 10410,
294 10500,
295 10600,
296 10700,
297 9000,
298 5200,
299 6800,
300 6600,
301 8200,
302 11300,
303 12700,
304 13400,
305 125
306 };
307
308 /**
309 * types
310 */
311
312 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
313
314 /**
315 * globals
316 */
317
318 static unsigned int full01 = 0x01010101;
319 static unsigned int full80 = 0x80808080;
320
321 int SUPPRESS_OUTPUT = 0;
322
323 hc_thread_mutex_t mux_adl;
324 hc_thread_mutex_t mux_counter;
325 hc_thread_mutex_t mux_dispatcher;
326 hc_thread_mutex_t mux_display;
327
328 hc_global_data_t data;
329
330 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
331
332 const char *USAGE_MINI[] =
333 {
334 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
335 "",
336 "Try --help for more help.",
337 NULL
338 };
339
340 const char *USAGE_BIG[] =
341 {
342 "%s, advanced password recovery",
343 "",
344 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
345 "",
346 "=======",
347 "Options",
348 "=======",
349 "",
350 "* General:",
351 "",
352 " -m, --hash-type=NUM Hash-type, see references below",
353 " -a, --attack-mode=NUM Attack-mode, see references below",
354 " -V, --version Print version",
355 " -h, --help Print help",
356 " --quiet Suppress output",
357 "",
358 "* Misc:",
359 "",
360 " --hex-charset Assume charset is given in hex",
361 " --hex-salt Assume salt is given in hex",
362 " --hex-wordlist Assume words in wordlist is given in hex",
363 " --force Ignore warnings",
364 " --status Enable automatic update of the status-screen",
365 " --status-timer=NUM Seconds between status-screen update",
366 " --status-automat Display the status view in a machine readable format",
367 " --loopback Add new plains to induct directory",
368 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
369 "",
370 "* Markov:",
371 "",
372 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
373 " --markov-disable Disables markov-chains, emulates classic brute-force",
374 " --markov-classic Enables classic markov-chains, no per-position enhancement",
375 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
376 "",
377 "* Session:",
378 "",
379 " --runtime=NUM Abort session after NUM seconds of runtime",
380 " --session=STR Define specific session name",
381 " --restore Restore session from --session",
382 " --restore-disable Do not write restore file",
383 "",
384 "* Files:",
385 "",
386 " -o, --outfile=FILE Define outfile for recovered hash",
387 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
388 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
389 " --outfile-check-timer=NUM Seconds between outfile checks",
390 " -p, --separator=CHAR Separator char for hashlists and outfile",
391 " --show Show cracked passwords only",
392 " --left Show un-cracked passwords only",
393 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
394 " --remove Enable remove of hash once it is cracked",
395 " --remove-timer=NUM Update input hash file each NUM seconds",
396 " --potfile-disable Do not write potfile",
397 " --potfile-path Specific path to potfile",
398 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
399 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
400 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
401 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
402 " --logfile-disable Disable the logfile",
403 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
404 "",
405 "* Resources:",
406 "",
407 " -b, --benchmark Run benchmark",
408 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
409 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
410 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
411 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
412 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
413 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
414 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
415 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
416 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
417 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
418 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
419 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
420 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
421 #ifdef HAVE_HWMON
422 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
423 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
424 #ifdef HAVE_ADL
425 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
426 #endif
427 #endif
428 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
429 "",
430 "* Distributed:",
431 "",
432 " -s, --skip=NUM Skip number of words",
433 " -l, --limit=NUM Limit number of words",
434 " --keyspace Show keyspace base:mod values and quit",
435 "",
436 "* Rules:",
437 "",
438 " -j, --rule-left=RULE Single rule applied to each word from left dict",
439 " -k, --rule-right=RULE Single rule applied to each word from right dict",
440 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
441 " -g, --generate-rules=NUM Generate NUM random rules",
442 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
443 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
444 " --generate-rules-seed=NUM Force RNG seed to NUM",
445 "",
446 "* Custom charsets:",
447 "",
448 " -1, --custom-charset1=CS User-defined charsets",
449 " -2, --custom-charset2=CS Example:",
450 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
451 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
452 "",
453 "* Increment:",
454 "",
455 " -i, --increment Enable increment mode",
456 " --increment-min=NUM Start incrementing at NUM",
457 " --increment-max=NUM Stop incrementing at NUM",
458 "",
459 "==========",
460 "References",
461 "==========",
462 "",
463 "* Workload Profile:",
464 "",
465 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
466 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
467 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
468 "",
469 "* OpenCL device-types:",
470 "",
471 " 1 = CPU devices",
472 " 2 = GPU devices",
473 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
474 "",
475 "* Outfile Formats:",
476 "",
477 " 1 = hash[:salt]",
478 " 2 = plain",
479 " 3 = hash[:salt]:plain",
480 " 4 = hex_plain",
481 " 5 = hash[:salt]:hex_plain",
482 " 6 = plain:hex_plain",
483 " 7 = hash[:salt]:plain:hex_plain",
484 " 8 = crackpos",
485 " 9 = hash[:salt]:crackpos",
486 " 10 = plain:crackpos",
487 " 11 = hash[:salt]:plain:crackpos",
488 " 12 = hex_plain:crackpos",
489 " 13 = hash[:salt]:hex_plain:crackpos",
490 " 14 = plain:hex_plain:crackpos",
491 " 15 = hash[:salt]:plain:hex_plain:crackpos",
492 "",
493 "* Debug mode output formats (for hybrid mode only, by using rules):",
494 "",
495 " 1 = save finding rule",
496 " 2 = save original word",
497 " 3 = save original word and finding rule",
498 " 4 = save original word, finding rule and modified plain",
499 "",
500 "* Built-in charsets:",
501 "",
502 " ?l = abcdefghijklmnopqrstuvwxyz",
503 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
504 " ?d = 0123456789",
505 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
506 " ?a = ?l?u?d?s",
507 " ?b = 0x00 - 0xff",
508 "",
509 "* Attack modes:",
510 "",
511 " 0 = Straight",
512 " 1 = Combination",
513 " 3 = Brute-force",
514 " 6 = Hybrid dict + mask",
515 " 7 = Hybrid mask + dict",
516 "",
517 "* Hash types:",
518 "",
519 "[[ Roll-your-own: Raw Hashes ]]",
520 "",
521 " 900 = MD4",
522 " 0 = MD5",
523 " 5100 = Half MD5",
524 " 100 = SHA1",
525 " 10800 = SHA-384",
526 " 1400 = SHA-256",
527 " 1700 = SHA-512",
528 " 5000 = SHA-3(Keccak)",
529 " 10100 = SipHash",
530 " 6000 = RipeMD160",
531 " 6100 = Whirlpool",
532 " 6900 = GOST R 34.11-94",
533 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
534 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
535 "",
536 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
537 "",
538 " 10 = md5($pass.$salt)",
539 " 20 = md5($salt.$pass)",
540 " 30 = md5(unicode($pass).$salt)",
541 " 40 = md5($salt.unicode($pass))",
542 " 3800 = md5($salt.$pass.$salt)",
543 " 3710 = md5($salt.md5($pass))",
544 " 2600 = md5(md5($pass)",
545 " 4300 = md5(strtoupper(md5($pass)))",
546 " 4400 = md5(sha1($pass))",
547 " 110 = sha1($pass.$salt)",
548 " 120 = sha1($salt.$pass)",
549 " 130 = sha1(unicode($pass).$salt)",
550 " 140 = sha1($salt.unicode($pass))",
551 " 4500 = sha1(sha1($pass)",
552 " 4700 = sha1(md5($pass))",
553 " 4900 = sha1($salt.$pass.$salt)",
554 " 1410 = sha256($pass.$salt)",
555 " 1420 = sha256($salt.$pass)",
556 " 1430 = sha256(unicode($pass).$salt)",
557 " 1440 = sha256($salt.unicode($pass))",
558 " 1710 = sha512($pass.$salt)",
559 " 1720 = sha512($salt.$pass)",
560 " 1730 = sha512(unicode($pass).$salt)",
561 " 1740 = sha512($salt.unicode($pass))",
562 "",
563 "[[ Roll-your-own: Authenticated Hashes ]]",
564 "",
565 " 50 = HMAC-MD5 (key = $pass)",
566 " 60 = HMAC-MD5 (key = $salt)",
567 " 150 = HMAC-SHA1 (key = $pass)",
568 " 160 = HMAC-SHA1 (key = $salt)",
569 " 1450 = HMAC-SHA256 (key = $pass)",
570 " 1460 = HMAC-SHA256 (key = $salt)",
571 " 1750 = HMAC-SHA512 (key = $pass)",
572 " 1760 = HMAC-SHA512 (key = $salt)",
573 "",
574 "[[ Generic KDF ]]",
575 "",
576 " 400 = phpass",
577 " 8900 = scrypt",
578 " 11900 = PBKDF2-HMAC-MD5",
579 " 12000 = PBKDF2-HMAC-SHA1",
580 " 10900 = PBKDF2-HMAC-SHA256",
581 " 12100 = PBKDF2-HMAC-SHA512",
582 "",
583 "[[ Network protocols, Challenge-Response ]]",
584 "",
585 " 23 = Skype",
586 " 2500 = WPA/WPA2",
587 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
588 " 5300 = IKE-PSK MD5",
589 " 5400 = IKE-PSK SHA1",
590 " 5500 = NetNTLMv1",
591 " 5500 = NetNTLMv1 + ESS",
592 " 5600 = NetNTLMv2",
593 " 7300 = IPMI2 RAKP HMAC-SHA1",
594 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
595 " 8300 = DNSSEC (NSEC3)",
596 " 10200 = Cram MD5",
597 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
598 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
599 " 11400 = SIP digest authentication (MD5)",
600 " 13100 = Kerberos 5 TGS-REP etype 23",
601 "",
602 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
603 "",
604 " 121 = SMF (Simple Machines Forum)",
605 " 400 = phpBB3",
606 " 2611 = vBulletin < v3.8.5",
607 " 2711 = vBulletin > v3.8.5",
608 " 2811 = MyBB",
609 " 2811 = IPB (Invison Power Board)",
610 " 8400 = WBB3 (Woltlab Burning Board)",
611 " 11 = Joomla < 2.5.18",
612 " 400 = Joomla > 2.5.18",
613 " 400 = Wordpress",
614 " 2612 = PHPS",
615 " 7900 = Drupal7",
616 " 21 = osCommerce",
617 " 21 = xt:Commerce",
618 " 11000 = PrestaShop",
619 " 124 = Django (SHA-1)",
620 " 10000 = Django (PBKDF2-SHA256)",
621 " 3711 = Mediawiki B type",
622 " 7600 = Redmine",
623 "",
624 "[[ Database Server ]]",
625 "",
626 " 12 = PostgreSQL",
627 " 131 = MSSQL(2000)",
628 " 132 = MSSQL(2005)",
629 " 1731 = MSSQL(2012)",
630 " 1731 = MSSQL(2014)",
631 " 200 = MySQL323",
632 " 300 = MySQL4.1/MySQL5",
633 " 3100 = Oracle H: Type (Oracle 7+)",
634 " 112 = Oracle S: Type (Oracle 11+)",
635 " 12300 = Oracle T: Type (Oracle 12+)",
636 " 8000 = Sybase ASE",
637 "",
638 "[[ HTTP, SMTP, LDAP Server ]]",
639 "",
640 " 141 = EPiServer 6.x < v4",
641 " 1441 = EPiServer 6.x > v4",
642 " 1600 = Apache $apr1$",
643 " 12600 = ColdFusion 10+",
644 " 1421 = hMailServer",
645 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
646 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
647 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
648 "",
649 "[[ Checksums ]]",
650 "",
651 " 11500 = CRC32",
652 "",
653 "[[ Operating-Systems ]]",
654 "",
655 " 3000 = LM",
656 " 1000 = NTLM",
657 " 1100 = Domain Cached Credentials (DCC), MS Cache",
658 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
659 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
660 " 1500 = descrypt, DES(Unix), Traditional DES",
661 " 12400 = BSDiCrypt, Extended DES",
662 " 500 = md5crypt $1$, MD5(Unix)",
663 " 3200 = bcrypt $2*$, Blowfish(Unix)",
664 " 7400 = sha256crypt $5$, SHA256(Unix)",
665 " 1800 = sha512crypt $6$, SHA512(Unix)",
666 " 122 = OSX v10.4",
667 " 122 = OSX v10.5",
668 " 122 = OSX v10.6",
669 " 1722 = OSX v10.7",
670 " 7100 = OSX v10.8",
671 " 7100 = OSX v10.9",
672 " 7100 = OSX v10.10",
673 " 6300 = AIX {smd5}",
674 " 6700 = AIX {ssha1}",
675 " 6400 = AIX {ssha256}",
676 " 6500 = AIX {ssha512}",
677 " 2400 = Cisco-PIX",
678 " 2410 = Cisco-ASA",
679 " 500 = Cisco-IOS $1$",
680 " 5700 = Cisco-IOS $4$",
681 " 9200 = Cisco-IOS $8$",
682 " 9300 = Cisco-IOS $9$",
683 " 22 = Juniper Netscreen/SSG (ScreenOS)",
684 " 501 = Juniper IVE",
685 " 5800 = Android PIN",
686 " 8100 = Citrix Netscaler",
687 " 8500 = RACF",
688 " 7200 = GRUB 2",
689 " 9900 = Radmin2",
690 " 125 = ArubaOS",
691 "",
692 "[[ Enterprise Application Software (EAS) ]]",
693 "",
694 " 7700 = SAP CODVN B (BCODE)",
695 " 7800 = SAP CODVN F/G (PASSCODE)",
696 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
697 " 8600 = Lotus Notes/Domino 5",
698 " 8700 = Lotus Notes/Domino 6",
699 " 9100 = Lotus Notes/Domino 8",
700 " 133 = PeopleSoft",
701 " 13500 = PeopleSoft Token",
702 "",
703 "[[ Archives ]]",
704 "",
705 " 11600 = 7-Zip",
706 " 12500 = RAR3-hp",
707 " 13000 = RAR5",
708 " 13200 = AxCrypt",
709 " 13300 = AxCrypt in memory SHA1",
710 " 13600 = WinZip",
711 "",
712 "[[ Full-Disk encryptions (FDE) ]]",
713 "",
714 " 62XY = TrueCrypt 5.0+",
715 " X = 1 = PBKDF2-HMAC-RipeMD160",
716 " X = 2 = PBKDF2-HMAC-SHA512",
717 " X = 3 = PBKDF2-HMAC-Whirlpool",
718 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
719 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
720 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
721 " Y = 3 = XTS 1536 bit (Ciphers: All)",
722 " 8800 = Android FDE < v4.3",
723 " 12900 = Android FDE (Samsung DEK)",
724 " 12200 = eCryptfs",
725 "",
726 "[[ Documents ]]",
727 "",
728 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
729 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
730 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
731 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
732 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
733 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
734 " 9400 = MS Office 2007",
735 " 9500 = MS Office 2010",
736 " 9600 = MS Office 2013",
737 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
738 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
739 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
740 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
741 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
742 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
743 "",
744 "[[ Password Managers ]]",
745 "",
746 " 9000 = Password Safe v2",
747 " 5200 = Password Safe v3",
748 " 6800 = Lastpass",
749 " 6600 = 1Password, agilekeychain",
750 " 8200 = 1Password, cloudkeychain",
751 " 11300 = Bitcoin/Litecoin wallet.dat",
752 " 12700 = Blockchain, My Wallet",
753 " 13400 = Keepass 1 (AES/Twofish) and Keepass 2 (AES)",
754 "",
755 NULL
756 };
757
758 /**
759 * hashcat specific functions
760 */
761
762 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
763 {
764 int exec_pos = (int) device_param->exec_pos - last_num_entries;
765
766 if (exec_pos < 0) exec_pos += EXEC_CACHE;
767
768 double exec_ms_sum = 0;
769
770 int exec_ms_cnt = 0;
771
772 for (int i = 0; i < last_num_entries; i++)
773 {
774 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
775
776 if (exec_ms)
777 {
778 exec_ms_sum += exec_ms;
779
780 exec_ms_cnt++;
781 }
782 }
783
784 if (exec_ms_cnt == 0) return 0;
785
786 return exec_ms_sum / exec_ms_cnt;
787 }
788
789 void status_display_automat ()
790 {
791 FILE *out = stdout;
792
793 fprintf (out, "STATUS\t%u\t", data.devices_status);
794
795 /**
796 * speed new
797 */
798
799 fprintf (out, "SPEED\t");
800
801 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
802 {
803 hc_device_param_t *device_param = &data.devices_param[device_id];
804
805 if (device_param->skipped) continue;
806
807 u64 speed_cnt = 0;
808 double speed_ms = 0;
809
810 for (int i = 0; i < SPEED_CACHE; i++)
811 {
812 speed_cnt += device_param->speed_cnt[i];
813 speed_ms += device_param->speed_ms[i];
814 }
815
816 speed_cnt /= SPEED_CACHE;
817 speed_ms /= SPEED_CACHE;
818
819 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
820 }
821
822 /**
823 * exec time
824 */
825
826 fprintf (out, "EXEC_RUNTIME\t");
827
828 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
829 {
830 hc_device_param_t *device_param = &data.devices_param[device_id];
831
832 if (device_param->skipped) continue;
833
834 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
835
836 fprintf (out, "%f\t", exec_ms_avg);
837 }
838
839 /**
840 * words_cur
841 */
842
843 u64 words_cur = get_lowest_words_done ();
844
845 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
846
847 /**
848 * counter
849 */
850
851 u64 progress_total = data.words_cnt * data.salts_cnt;
852
853 u64 all_done = 0;
854 u64 all_rejected = 0;
855 u64 all_restored = 0;
856
857 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
858 {
859 all_done += data.words_progress_done[salt_pos];
860 all_rejected += data.words_progress_rejected[salt_pos];
861 all_restored += data.words_progress_restored[salt_pos];
862 }
863
864 u64 progress_cur = all_restored + all_done + all_rejected;
865 u64 progress_end = progress_total;
866
867 u64 progress_skip = 0;
868
869 if (data.skip)
870 {
871 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
872
873 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
874 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
875 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
876 }
877
878 if (data.limit)
879 {
880 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
881
882 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
883 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
884 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
885 }
886
887 u64 progress_cur_relative_skip = progress_cur - progress_skip;
888 u64 progress_end_relative_skip = progress_end - progress_skip;
889
890 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
891
892 /**
893 * cracks
894 */
895
896 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
897 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
898
899 /**
900 * temperature
901 */
902
903 #ifdef HAVE_HWMON
904 if (data.gpu_temp_disable == 0)
905 {
906 fprintf (out, "TEMP\t");
907
908 hc_thread_mutex_lock (mux_adl);
909
910 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
911 {
912 hc_device_param_t *device_param = &data.devices_param[device_id];
913
914 if (device_param->skipped) continue;
915
916 int temp = hm_get_temperature_with_device_id (device_id);
917
918 fprintf (out, "%d\t", temp);
919 }
920
921 hc_thread_mutex_unlock (mux_adl);
922 }
923 #endif // HAVE_HWMON
924
925 /**
926 * flush
927 */
928
929 #ifdef _WIN
930 fputc ('\r', out);
931 fputc ('\n', out);
932 #endif
933
934 #ifdef _POSIX
935 fputc ('\n', out);
936 #endif
937
938 fflush (out);
939 }
940
941 void status_display ()
942 {
943 if (data.devices_status == STATUS_INIT) return;
944 if (data.devices_status == STATUS_STARTING) return;
945 if (data.devices_status == STATUS_BYPASS) return;
946
947 if (data.status_automat == 1)
948 {
949 status_display_automat ();
950
951 return;
952 }
953
954 char tmp_buf[1000] = { 0 };
955
956 uint tmp_len = 0;
957
958 log_info ("Session.Name...: %s", data.session);
959
960 char *status_type = strstatus (data.devices_status);
961
962 uint hash_mode = data.hash_mode;
963
964 char *hash_type = strhashtype (hash_mode); // not a bug
965
966 log_info ("Status.........: %s", status_type);
967
968 /**
969 * show rules
970 */
971
972 if (data.rp_files_cnt)
973 {
974 uint i;
975
976 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
977 {
978 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
979 }
980
981 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
982
983 log_info ("Rules.Type.....: %s", tmp_buf);
984
985 tmp_len = 0;
986 }
987
988 if (data.rp_gen)
989 {
990 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
991
992 if (data.rp_gen_seed)
993 {
994 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
995 }
996 }
997
998 /**
999 * show input
1000 */
1001
1002 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1003 {
1004 if (data.wordlist_mode == WL_MODE_FILE)
1005 {
1006 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1007 }
1008 else if (data.wordlist_mode == WL_MODE_STDIN)
1009 {
1010 log_info ("Input.Mode.....: Pipe");
1011 }
1012 }
1013 else if (data.attack_mode == ATTACK_MODE_COMBI)
1014 {
1015 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1016 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1017 }
1018 else if (data.attack_mode == ATTACK_MODE_BF)
1019 {
1020 char *mask = data.mask;
1021
1022 if (mask != NULL)
1023 {
1024 uint mask_len = data.css_cnt;
1025
1026 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1027
1028 if (mask_len > 0)
1029 {
1030 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1031 {
1032 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1033 {
1034 mask_len -= data.salts_buf[0].salt_len;
1035 }
1036 }
1037
1038 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1039
1040 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1041 }
1042
1043 if (data.maskcnt > 1)
1044 {
1045 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1046
1047 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1048 }
1049
1050 log_info ("Input.Mode.....: %s", tmp_buf);
1051 }
1052
1053 tmp_len = 0;
1054 }
1055 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1056 {
1057 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1058 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1059 }
1060 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1061 {
1062 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1063 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1064 }
1065
1066 if (data.digests_cnt == 1)
1067 {
1068 if (data.hash_mode == 2500)
1069 {
1070 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1071
1072 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1073 (char *) data.salts_buf[0].salt_buf,
1074 wpa->orig_mac1[0],
1075 wpa->orig_mac1[1],
1076 wpa->orig_mac1[2],
1077 wpa->orig_mac1[3],
1078 wpa->orig_mac1[4],
1079 wpa->orig_mac1[5],
1080 wpa->orig_mac2[0],
1081 wpa->orig_mac2[1],
1082 wpa->orig_mac2[2],
1083 wpa->orig_mac2[3],
1084 wpa->orig_mac2[4],
1085 wpa->orig_mac2[5]);
1086 }
1087 else if (data.hash_mode == 5200)
1088 {
1089 log_info ("Hash.Target....: File (%s)", data.hashfile);
1090 }
1091 else if (data.hash_mode == 9000)
1092 {
1093 log_info ("Hash.Target....: File (%s)", data.hashfile);
1094 }
1095 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1096 {
1097 log_info ("Hash.Target....: File (%s)", data.hashfile);
1098 }
1099 else
1100 {
1101 char out_buf[HCBUFSIZ] = { 0 };
1102
1103 ascii_digest (out_buf, 0, 0);
1104
1105 // limit length
1106 if (strlen (out_buf) > 40)
1107 {
1108 out_buf[41] = '.';
1109 out_buf[42] = '.';
1110 out_buf[43] = '.';
1111 out_buf[44] = 0;
1112 }
1113
1114 log_info ("Hash.Target....: %s", out_buf);
1115 }
1116 }
1117 else
1118 {
1119 if (data.hash_mode == 3000)
1120 {
1121 char out_buf1[32] = { 0 };
1122 char out_buf2[32] = { 0 };
1123
1124 ascii_digest (out_buf1, 0, 0);
1125 ascii_digest (out_buf2, 0, 1);
1126
1127 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1128 }
1129 else
1130 {
1131 log_info ("Hash.Target....: File (%s)", data.hashfile);
1132 }
1133 }
1134
1135 log_info ("Hash.Type......: %s", hash_type);
1136
1137 /**
1138 * speed new
1139 */
1140
1141 u64 speed_cnt[DEVICES_MAX] = { 0 };
1142 double speed_ms[DEVICES_MAX] = { 0 };
1143
1144 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1145 {
1146 hc_device_param_t *device_param = &data.devices_param[device_id];
1147
1148 if (device_param->skipped) continue;
1149
1150 speed_cnt[device_id] = 0;
1151 speed_ms[device_id] = 0;
1152
1153 for (int i = 0; i < SPEED_CACHE; i++)
1154 {
1155 speed_cnt[device_id] += device_param->speed_cnt[i];
1156 speed_ms[device_id] += device_param->speed_ms[i];
1157 }
1158
1159 speed_cnt[device_id] /= SPEED_CACHE;
1160 speed_ms[device_id] /= SPEED_CACHE;
1161 }
1162
1163 double hashes_all_ms = 0;
1164
1165 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1166
1167 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1168 {
1169 hc_device_param_t *device_param = &data.devices_param[device_id];
1170
1171 if (device_param->skipped) continue;
1172
1173 hashes_dev_ms[device_id] = 0;
1174
1175 if (speed_ms[device_id])
1176 {
1177 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1178
1179 hashes_all_ms += hashes_dev_ms[device_id];
1180 }
1181 }
1182
1183 /**
1184 * exec time
1185 */
1186
1187 double exec_all_ms[DEVICES_MAX] = { 0 };
1188
1189 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1190 {
1191 hc_device_param_t *device_param = &data.devices_param[device_id];
1192
1193 if (device_param->skipped) continue;
1194
1195 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1196
1197 exec_all_ms[device_id] = exec_ms_avg;
1198 }
1199
1200 /**
1201 * timers
1202 */
1203
1204 double ms_running = 0;
1205
1206 hc_timer_get (data.timer_running, ms_running);
1207
1208 double ms_paused = data.ms_paused;
1209
1210 if (data.devices_status == STATUS_PAUSED)
1211 {
1212 double ms_paused_tmp = 0;
1213
1214 hc_timer_get (data.timer_paused, ms_paused_tmp);
1215
1216 ms_paused += ms_paused_tmp;
1217 }
1218
1219 #ifdef WIN
1220
1221 __time64_t sec_run = ms_running / 1000;
1222
1223 #else
1224
1225 time_t sec_run = ms_running / 1000;
1226
1227 #endif
1228
1229 if (sec_run)
1230 {
1231 char display_run[32] = { 0 };
1232
1233 struct tm tm_run;
1234
1235 struct tm *tmp = NULL;
1236
1237 #ifdef WIN
1238
1239 tmp = _gmtime64 (&sec_run);
1240
1241 #else
1242
1243 tmp = gmtime (&sec_run);
1244
1245 #endif
1246
1247 if (tmp != NULL)
1248 {
1249 memset (&tm_run, 0, sizeof (tm_run));
1250
1251 memcpy (&tm_run, tmp, sizeof (tm_run));
1252
1253 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1254
1255 char *start = ctime (&data.proc_start);
1256
1257 size_t start_len = strlen (start);
1258
1259 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1260 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1261
1262 log_info ("Time.Started...: %s (%s)", start, display_run);
1263 }
1264 }
1265 else
1266 {
1267 log_info ("Time.Started...: 0 secs");
1268 }
1269
1270 /**
1271 * counters
1272 */
1273
1274 u64 progress_total = data.words_cnt * data.salts_cnt;
1275
1276 u64 all_done = 0;
1277 u64 all_rejected = 0;
1278 u64 all_restored = 0;
1279
1280 u64 progress_noneed = 0;
1281
1282 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1283 {
1284 all_done += data.words_progress_done[salt_pos];
1285 all_rejected += data.words_progress_rejected[salt_pos];
1286 all_restored += data.words_progress_restored[salt_pos];
1287
1288 // Important for ETA only
1289
1290 if (data.salts_shown[salt_pos] == 1)
1291 {
1292 const u64 all = data.words_progress_done[salt_pos]
1293 + data.words_progress_rejected[salt_pos]
1294 + data.words_progress_restored[salt_pos];
1295
1296 const u64 left = data.words_cnt - all;
1297
1298 progress_noneed += left;
1299 }
1300 }
1301
1302 u64 progress_cur = all_restored + all_done + all_rejected;
1303 u64 progress_end = progress_total;
1304
1305 u64 progress_skip = 0;
1306
1307 if (data.skip)
1308 {
1309 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1310
1311 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1312 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1313 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1314 }
1315
1316 if (data.limit)
1317 {
1318 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1319
1320 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1321 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1322 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1323 }
1324
1325 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1326 u64 progress_end_relative_skip = progress_end - progress_skip;
1327
1328 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1329 {
1330 if (data.devices_status != STATUS_CRACKED)
1331 {
1332 #ifdef WIN
1333 __time64_t sec_etc = 0;
1334 #else
1335 time_t sec_etc = 0;
1336 #endif
1337
1338 if (hashes_all_ms)
1339 {
1340 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1341
1342 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1343
1344 sec_etc = ms_left / 1000;
1345 }
1346
1347 if (sec_etc == 0)
1348 {
1349 //log_info ("Time.Estimated.: 0 secs");
1350 }
1351 else if ((u64) sec_etc > ETC_MAX)
1352 {
1353 log_info ("Time.Estimated.: > 10 Years");
1354 }
1355 else
1356 {
1357 char display_etc[32] = { 0 };
1358
1359 struct tm tm_etc;
1360
1361 struct tm *tmp = NULL;
1362
1363 #ifdef WIN
1364
1365 tmp = _gmtime64 (&sec_etc);
1366
1367 #else
1368
1369 tmp = gmtime (&sec_etc);
1370
1371 #endif
1372
1373 if (tmp != NULL)
1374 {
1375 memset (&tm_etc, 0, sizeof (tm_etc));
1376
1377 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1378
1379 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1380
1381 time_t now;
1382
1383 time (&now);
1384
1385 now += sec_etc;
1386
1387 char *etc = ctime (&now);
1388
1389 size_t etc_len = strlen (etc);
1390
1391 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1392 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1393
1394 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1395 }
1396 }
1397 }
1398 }
1399
1400 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1401 {
1402 hc_device_param_t *device_param = &data.devices_param[device_id];
1403
1404 if (device_param->skipped) continue;
1405
1406 char display_dev_cur[16] = { 0 };
1407
1408 strncpy (display_dev_cur, "0.00", 4);
1409
1410 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1411
1412 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1413 }
1414
1415 char display_all_cur[16] = { 0 };
1416
1417 strncpy (display_all_cur, "0.00", 4);
1418
1419 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1420
1421 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1422
1423 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1424 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1425
1426 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1427
1428 // crack-per-time
1429
1430 if (data.digests_cnt > 100)
1431 {
1432 time_t now = time (NULL);
1433
1434 int cpt_cur_min = 0;
1435 int cpt_cur_hour = 0;
1436 int cpt_cur_day = 0;
1437
1438 for (int i = 0; i < CPT_BUF; i++)
1439 {
1440 const uint cracked = data.cpt_buf[i].cracked;
1441 const time_t timestamp = data.cpt_buf[i].timestamp;
1442
1443 if ((timestamp + 60) > now)
1444 {
1445 cpt_cur_min += cracked;
1446 }
1447
1448 if ((timestamp + 3600) > now)
1449 {
1450 cpt_cur_hour += cracked;
1451 }
1452
1453 if ((timestamp + 86400) > now)
1454 {
1455 cpt_cur_day += cracked;
1456 }
1457 }
1458
1459 double ms_real = ms_running - ms_paused;
1460
1461 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1462 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1463 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1464
1465 if ((data.cpt_start + 86400) < now)
1466 {
1467 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1468 cpt_cur_min,
1469 cpt_cur_hour,
1470 cpt_cur_day,
1471 cpt_avg_min,
1472 cpt_avg_hour,
1473 cpt_avg_day);
1474 }
1475 else if ((data.cpt_start + 3600) < now)
1476 {
1477 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1478 cpt_cur_min,
1479 cpt_cur_hour,
1480 cpt_avg_min,
1481 cpt_avg_hour,
1482 cpt_avg_day);
1483 }
1484 else if ((data.cpt_start + 60) < now)
1485 {
1486 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1487 cpt_cur_min,
1488 cpt_avg_min,
1489 cpt_avg_hour,
1490 cpt_avg_day);
1491 }
1492 else
1493 {
1494 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1495 cpt_avg_min,
1496 cpt_avg_hour,
1497 cpt_avg_day);
1498 }
1499 }
1500
1501 // Restore point
1502
1503 u64 restore_point = get_lowest_words_done ();
1504
1505 u64 restore_total = data.words_base;
1506
1507 float percent_restore = 0;
1508
1509 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1510
1511 if (progress_end_relative_skip)
1512 {
1513 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1514 {
1515 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1516 float percent_rejected = 0.0;
1517
1518 if (progress_cur)
1519 {
1520 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1521 }
1522
1523 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1524 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1525
1526 if (data.restore_disable == 0)
1527 {
1528 if (percent_finished != 1)
1529 {
1530 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1531 }
1532 }
1533 }
1534 }
1535 else
1536 {
1537 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1538 {
1539 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1540 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1541
1542 if (data.restore_disable == 0)
1543 {
1544 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1545 }
1546 }
1547 else
1548 {
1549 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1550 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1551
1552 // --restore not allowed if stdin is used -- really? why?
1553
1554 //if (data.restore_disable == 0)
1555 //{
1556 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1557 //}
1558 }
1559 }
1560
1561 #ifdef HAVE_HWMON
1562 if (data.gpu_temp_disable == 0)
1563 {
1564 hc_thread_mutex_lock (mux_adl);
1565
1566 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1567 {
1568 hc_device_param_t *device_param = &data.devices_param[device_id];
1569
1570 if (device_param->skipped) continue;
1571
1572 #define HM_STR_BUF_SIZE 255
1573
1574 if (data.hm_device[device_id].fan_supported == 1)
1575 {
1576 char utilization[HM_STR_BUF_SIZE] = { 0 };
1577 char temperature[HM_STR_BUF_SIZE] = { 0 };
1578 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1579
1580 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1581 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1582
1583 if (device_param->vendor_id == VENDOR_ID_AMD)
1584 {
1585 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1586 }
1587 else if (device_param->vendor_id == VENDOR_ID_NV)
1588 {
1589 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1590 }
1591
1592 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1593 }
1594 else
1595 {
1596 char utilization[HM_STR_BUF_SIZE] = { 0 };
1597 char temperature[HM_STR_BUF_SIZE] = { 0 };
1598
1599 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1600 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1601
1602 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1603 }
1604 }
1605
1606 hc_thread_mutex_unlock (mux_adl);
1607 }
1608 #endif // HAVE_HWMON
1609 }
1610
1611 static void status_benchmark_automat ()
1612 {
1613 u64 speed_cnt[DEVICES_MAX] = { 0 };
1614 double speed_ms[DEVICES_MAX] = { 0 };
1615
1616 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1617 {
1618 hc_device_param_t *device_param = &data.devices_param[device_id];
1619
1620 if (device_param->skipped) continue;
1621
1622 speed_cnt[device_id] = device_param->speed_cnt[0];
1623 speed_ms[device_id] = device_param->speed_ms[0];
1624 }
1625
1626 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1627
1628 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1629 {
1630 hc_device_param_t *device_param = &data.devices_param[device_id];
1631
1632 if (device_param->skipped) continue;
1633
1634 hashes_dev_ms[device_id] = 0;
1635
1636 if (speed_ms[device_id])
1637 {
1638 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1639 }
1640 }
1641
1642 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1643 {
1644 hc_device_param_t *device_param = &data.devices_param[device_id];
1645
1646 if (device_param->skipped) continue;
1647
1648 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1649 }
1650 }
1651
1652 static void status_benchmark ()
1653 {
1654 if (data.devices_status == STATUS_INIT) return;
1655 if (data.devices_status == STATUS_STARTING) return;
1656 if (data.devices_status == STATUS_BYPASS) return;
1657
1658 if (data.status_automat == 1)
1659 {
1660 status_benchmark_automat ();
1661
1662 return;
1663 }
1664
1665 u64 speed_cnt[DEVICES_MAX] = { 0 };
1666 double speed_ms[DEVICES_MAX] = { 0 };
1667
1668 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1669 {
1670 hc_device_param_t *device_param = &data.devices_param[device_id];
1671
1672 if (device_param->skipped) continue;
1673
1674 speed_cnt[device_id] = device_param->speed_cnt[0];
1675 speed_ms[device_id] = device_param->speed_ms[0];
1676 }
1677
1678 double hashes_all_ms = 0;
1679
1680 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1681
1682 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1683 {
1684 hc_device_param_t *device_param = &data.devices_param[device_id];
1685
1686 if (device_param->skipped) continue;
1687
1688 hashes_dev_ms[device_id] = 0;
1689
1690 if (speed_ms[device_id])
1691 {
1692 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1693
1694 hashes_all_ms += hashes_dev_ms[device_id];
1695 }
1696 }
1697
1698 /**
1699 * exec time
1700 */
1701
1702 double exec_all_ms[DEVICES_MAX] = { 0 };
1703
1704 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1705 {
1706 hc_device_param_t *device_param = &data.devices_param[device_id];
1707
1708 if (device_param->skipped) continue;
1709
1710 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1711
1712 exec_all_ms[device_id] = exec_ms_avg;
1713 }
1714
1715 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1716 {
1717 hc_device_param_t *device_param = &data.devices_param[device_id];
1718
1719 if (device_param->skipped) continue;
1720
1721 char display_dev_cur[16] = { 0 };
1722
1723 strncpy (display_dev_cur, "0.00", 4);
1724
1725 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1726
1727 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1728 }
1729
1730 char display_all_cur[16] = { 0 };
1731
1732 strncpy (display_all_cur, "0.00", 4);
1733
1734 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1735
1736 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1737 }
1738
1739 /**
1740 * hashcat -only- functions
1741 */
1742
1743 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1744 {
1745 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1746 {
1747 if (attack_kern == ATTACK_KERN_STRAIGHT)
1748 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1749 else if (attack_kern == ATTACK_KERN_COMBI)
1750 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1751 else if (attack_kern == ATTACK_KERN_BF)
1752 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1753 }
1754 else
1755 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1756 }
1757
1758 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1759 {
1760 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1761 {
1762 if (attack_kern == ATTACK_KERN_STRAIGHT)
1763 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1764 else if (attack_kern == ATTACK_KERN_COMBI)
1765 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1766 else if (attack_kern == ATTACK_KERN_BF)
1767 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1768 }
1769 else
1770 {
1771 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1772 }
1773 }
1774
1775 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1776 {
1777 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1778 {
1779 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1780 }
1781 else
1782 {
1783 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1784 }
1785 }
1786
1787 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1788 {
1789 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1790 {
1791 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1792 }
1793 else
1794 {
1795 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1796 }
1797 }
1798
1799 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1800 {
1801 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1802 }
1803
1804 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1805 {
1806 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1807 }
1808
1809 static uint convert_from_hex (char *line_buf, const uint line_len)
1810 {
1811 if (line_len & 1) return (line_len); // not in hex
1812
1813 if (data.hex_wordlist == 1)
1814 {
1815 uint i;
1816 uint j;
1817
1818 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1819 {
1820 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1821 }
1822
1823 memset (line_buf + i, 0, line_len - i);
1824
1825 return (i);
1826 }
1827 else if (line_len >= 6) // $HEX[] = 6
1828 {
1829 if (line_buf[0] != '$') return (line_len);
1830 if (line_buf[1] != 'H') return (line_len);
1831 if (line_buf[2] != 'E') return (line_len);
1832 if (line_buf[3] != 'X') return (line_len);
1833 if (line_buf[4] != '[') return (line_len);
1834 if (line_buf[line_len - 1] != ']') return (line_len);
1835
1836 uint i;
1837 uint j;
1838
1839 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1840 {
1841 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1842 }
1843
1844 memset (line_buf + i, 0, line_len - i);
1845
1846 return (i);
1847 }
1848
1849 return (line_len);
1850 }
1851
1852 static void clear_prompt ()
1853 {
1854 fputc ('\r', stdout);
1855
1856 for (size_t i = 0; i < strlen (PROMPT); i++)
1857 {
1858 fputc (' ', stdout);
1859 }
1860
1861 fputc ('\r', stdout);
1862
1863 fflush (stdout);
1864 }
1865
1866 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1867 {
1868 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1869 }
1870
1871 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1872 {
1873 char *outfile = data.outfile;
1874 uint quiet = data.quiet;
1875 FILE *pot_fp = data.pot_fp;
1876 uint loopback = data.loopback;
1877 uint debug_mode = data.debug_mode;
1878 char *debug_file = data.debug_file;
1879
1880 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1881 int debug_rule_len = 0; // -1 error
1882 uint debug_plain_len = 0;
1883
1884 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1885
1886 // hash
1887
1888 char out_buf[HCBUFSIZ] = { 0 };
1889
1890 ascii_digest (out_buf, salt_pos, digest_pos);
1891
1892 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1893
1894 // plain
1895
1896 plain_t plain;
1897
1898 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1899
1900 uint gidvid = plain.gidvid;
1901 uint il_pos = plain.il_pos;
1902
1903 u64 crackpos = device_param->words_off;
1904
1905 uint plain_buf[16] = { 0 };
1906
1907 u8 *plain_ptr = (u8 *) plain_buf;
1908 unsigned int plain_len = 0;
1909
1910 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1911 {
1912 u64 gidd = gidvid;
1913 u64 gidm = 0;
1914
1915 pw_t pw;
1916
1917 gidd_to_pw_t (device_param, gidd, &pw);
1918
1919 for (int i = 0, j = gidm; i < 16; i++, j++)
1920 {
1921 plain_buf[i] = pw.i[j];
1922 }
1923
1924 plain_len = pw.pw_len;
1925
1926 const uint off = device_param->innerloop_pos + il_pos;
1927
1928 if (debug_mode > 0)
1929 {
1930 debug_rule_len = 0;
1931
1932 // save rule
1933 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1934 {
1935 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1936
1937 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1938 }
1939
1940 // save plain
1941 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1942 {
1943 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1944
1945 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1946
1947 debug_plain_len = plain_len;
1948 }
1949 }
1950
1951 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1952
1953 crackpos += gidvid;
1954 crackpos *= data.kernel_rules_cnt;
1955 crackpos += device_param->innerloop_pos + il_pos;
1956
1957 if (plain_len > data.pw_max) plain_len = data.pw_max;
1958 }
1959 else if (data.attack_mode == ATTACK_MODE_COMBI)
1960 {
1961 u64 gidd = gidvid;
1962 u64 gidm = 0;
1963
1964 pw_t pw;
1965
1966 gidd_to_pw_t (device_param, gidd, &pw);
1967
1968 for (int i = 0, j = gidm; i < 16; i++, j++)
1969 {
1970 plain_buf[i] = pw.i[j];
1971 }
1972
1973 plain_len = pw.pw_len;
1974
1975 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1976 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1977
1978 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1979 {
1980 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1981 }
1982 else
1983 {
1984 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1985
1986 memcpy (plain_ptr, comb_buf, comb_len);
1987 }
1988
1989 plain_len += comb_len;
1990
1991 crackpos += gidvid;
1992 crackpos *= data.combs_cnt;
1993 crackpos += device_param->innerloop_pos + il_pos;
1994
1995 if (data.pw_max != PW_DICTMAX1)
1996 {
1997 if (plain_len > data.pw_max) plain_len = data.pw_max;
1998 }
1999 }
2000 else if (data.attack_mode == ATTACK_MODE_BF)
2001 {
2002 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2003 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2004
2005 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2006 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2007
2008 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2009 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2010
2011 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2012 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2013
2014 plain_len = data.css_cnt;
2015
2016 crackpos += gidvid;
2017 crackpos *= data.bfs_cnt;
2018 crackpos += device_param->innerloop_pos + il_pos;
2019 }
2020 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2021 {
2022 u64 gidd = gidvid;
2023 u64 gidm = 0;
2024
2025 pw_t pw;
2026
2027 gidd_to_pw_t (device_param, gidd, &pw);
2028
2029 for (int i = 0, j = gidm; i < 16; i++, j++)
2030 {
2031 plain_buf[i] = pw.i[j];
2032 }
2033
2034 plain_len = pw.pw_len;
2035
2036 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2037
2038 uint start = 0;
2039 uint stop = device_param->kernel_params_mp_buf32[4];
2040
2041 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2042
2043 plain_len += start + stop;
2044
2045 crackpos += gidvid;
2046 crackpos *= data.combs_cnt;
2047 crackpos += device_param->innerloop_pos + il_pos;
2048
2049 if (data.pw_max != PW_DICTMAX1)
2050 {
2051 if (plain_len > data.pw_max) plain_len = data.pw_max;
2052 }
2053 }
2054 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2055 {
2056 u64 gidd = gidvid;
2057 u64 gidm = 0;
2058
2059 pw_t pw;
2060
2061 gidd_to_pw_t (device_param, gidd, &pw);
2062
2063 for (int i = 0, j = gidm; i < 16; i++, j++)
2064 {
2065 plain_buf[i] = pw.i[j];
2066 }
2067
2068 plain_len = pw.pw_len;
2069
2070 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2071
2072 uint start = 0;
2073 uint stop = device_param->kernel_params_mp_buf32[4];
2074
2075 memmove (plain_ptr + stop, plain_ptr, plain_len);
2076
2077 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2078
2079 plain_len += start + stop;
2080
2081 crackpos += gidvid;
2082 crackpos *= data.combs_cnt;
2083 crackpos += device_param->innerloop_pos + il_pos;
2084
2085 if (data.pw_max != PW_DICTMAX1)
2086 {
2087 if (plain_len > data.pw_max) plain_len = data.pw_max;
2088 }
2089 }
2090
2091 if (data.attack_mode == ATTACK_MODE_BF)
2092 {
2093 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2094 {
2095 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2096 {
2097 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2098 {
2099 plain_len = plain_len - data.salts_buf[0].salt_len;
2100 }
2101 }
2102
2103 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2104 {
2105 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2106 {
2107 plain_ptr[j] = plain_ptr[i];
2108 }
2109
2110 plain_len = plain_len / 2;
2111 }
2112 }
2113 }
2114
2115 // if enabled, update also the potfile
2116
2117 if (pot_fp)
2118 {
2119 lock_file (pot_fp);
2120
2121 fprintf (pot_fp, "%s:", out_buf);
2122
2123 format_plain (pot_fp, plain_ptr, plain_len, 1);
2124
2125 fputc ('\n', pot_fp);
2126
2127 fflush (pot_fp);
2128
2129 unlock_file (pot_fp);
2130 }
2131
2132 // outfile
2133
2134 FILE *out_fp = NULL;
2135
2136 if (outfile != NULL)
2137 {
2138 if ((out_fp = fopen (outfile, "ab")) == NULL)
2139 {
2140 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2141
2142 out_fp = stdout;
2143 }
2144 lock_file (out_fp);
2145 }
2146 else
2147 {
2148 out_fp = stdout;
2149
2150 if (quiet == 0) clear_prompt ();
2151 }
2152
2153 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2154
2155 if (outfile != NULL)
2156 {
2157 if (out_fp != stdout)
2158 {
2159 fclose (out_fp);
2160 }
2161 }
2162 else
2163 {
2164 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2165 {
2166 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2167 {
2168 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2169 if (quiet == 0) fflush (stdout);
2170 }
2171 }
2172 }
2173
2174 // loopback
2175
2176 if (loopback)
2177 {
2178 char *loopback_file = data.loopback_file;
2179
2180 FILE *fb_fp = NULL;
2181
2182 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2183 {
2184 lock_file (fb_fp);
2185
2186 format_plain (fb_fp, plain_ptr, plain_len, 1);
2187
2188 fputc ('\n', fb_fp);
2189
2190 fclose (fb_fp);
2191 }
2192 }
2193
2194 // (rule) debug mode
2195
2196 // the next check implies that:
2197 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2198 // - debug_mode > 0
2199
2200 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2201 {
2202 if (debug_rule_len < 0) debug_rule_len = 0;
2203
2204 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2205
2206 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2207
2208 if ((quiet == 0) && (debug_file == NULL))
2209 {
2210 fprintf (stdout, "%s", PROMPT);
2211
2212 fflush (stdout);
2213 }
2214 }
2215 }
2216
2217 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2218 {
2219 salt_t *salt_buf = &data.salts_buf[salt_pos];
2220
2221 int found = 0;
2222
2223 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2224
2225 for (uint i = 0; i < device_param->kernel_threads; i++) if (device_param->result[i] == 1) found = 1;
2226
2227 if (found == 1)
2228 {
2229 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2230
2231 log_info_nn ("");
2232
2233 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2234
2235 uint cpt_cracked = 0;
2236
2237 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2238 {
2239 uint idx = salt_buf->digests_offset + digest_pos;
2240
2241 if (data.digests_shown_tmp[idx] == 0) continue;
2242
2243 if (data.digests_shown[idx] == 1) continue;
2244
2245 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2246 {
2247 data.digests_shown[idx] = 1;
2248
2249 data.digests_done++;
2250
2251 cpt_cracked++;
2252
2253 salt_buf->digests_done++;
2254
2255 if (salt_buf->digests_done == salt_buf->digests_cnt)
2256 {
2257 data.salts_shown[salt_pos] = 1;
2258
2259 data.salts_done++;
2260 }
2261 }
2262
2263 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2264
2265 check_hash (device_param, salt_pos, digest_pos);
2266 }
2267
2268 if (cpt_cracked > 0)
2269 {
2270 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2271 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2272
2273 data.cpt_pos++;
2274
2275 data.cpt_total += cpt_cracked;
2276
2277 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2278 }
2279
2280 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2281 {
2282 // we need to reset cracked state on the device
2283 // otherwise host thinks again and again the hash was cracked
2284 // and returns invalid password each time
2285
2286 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2287
2288 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2289 }
2290
2291 memset (device_param->result, 0, device_param->size_results);
2292
2293 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2294 }
2295 }
2296
2297 static void save_hash ()
2298 {
2299 char *hashfile = data.hashfile;
2300
2301 char new_hashfile[256] = { 0 };
2302 char old_hashfile[256] = { 0 };
2303
2304 snprintf (new_hashfile, 255, "%s.new", hashfile);
2305 snprintf (old_hashfile, 255, "%s.old", hashfile);
2306
2307 unlink (new_hashfile);
2308
2309 char separator = data.separator;
2310
2311 FILE *fp = fopen (new_hashfile, "wb");
2312
2313 if (fp == NULL)
2314 {
2315 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2316
2317 exit (-1);
2318 }
2319
2320 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2321 {
2322 if (data.salts_shown[salt_pos] == 1) continue;
2323
2324 salt_t *salt_buf = &data.salts_buf[salt_pos];
2325
2326 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2327 {
2328 uint idx = salt_buf->digests_offset + digest_pos;
2329
2330 if (data.digests_shown[idx] == 1) continue;
2331
2332 if (data.hash_mode != 2500)
2333 {
2334 char out_buf[HCBUFSIZ] = { 0 };
2335
2336 if (data.username == 1)
2337 {
2338 user_t *user = data.hash_info[idx]->user;
2339
2340 uint i;
2341
2342 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2343
2344 fputc (separator, fp);
2345 }
2346
2347 ascii_digest (out_buf, salt_pos, digest_pos);
2348
2349 fputs (out_buf, fp);
2350
2351 log_out (fp, "");
2352 }
2353 else
2354 {
2355 hccap_t hccap;
2356
2357 to_hccap_t (&hccap, salt_pos, digest_pos);
2358
2359 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2360 }
2361 }
2362 }
2363
2364 fflush (fp);
2365
2366 fclose (fp);
2367
2368 unlink (old_hashfile);
2369
2370 if (rename (hashfile, old_hashfile) != 0)
2371 {
2372 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2373
2374 exit (-1);
2375 }
2376
2377 unlink (hashfile);
2378
2379 if (rename (new_hashfile, hashfile) != 0)
2380 {
2381 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2382
2383 exit (-1);
2384 }
2385
2386 unlink (old_hashfile);
2387 }
2388
2389 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2390 {
2391 // function called only in case kernel_power_all > words_left
2392
2393 float kernel_power_div = (float) (total_left) / kernel_power_all;
2394
2395 kernel_power_div += kernel_power_div / 100;
2396
2397 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2398
2399 while (kernel_power_new < total_left)
2400 {
2401 kernel_power_div += kernel_power_div / 100;
2402
2403 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2404 }
2405
2406 if (data.quiet == 0)
2407 {
2408 clear_prompt ();
2409
2410 //log_info ("");
2411
2412 log_info ("INFO: approaching final keyspace, workload adjusted");
2413 log_info ("");
2414
2415 fprintf (stdout, "%s", PROMPT);
2416
2417 fflush (stdout);
2418 }
2419
2420 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2421
2422 return kernel_power_div;
2423 }
2424
2425 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2426 {
2427 uint num_elements = num;
2428
2429 device_param->kernel_params_buf32[30] = data.combs_mode;
2430 device_param->kernel_params_buf32[31] = num;
2431
2432 uint kernel_threads = device_param->kernel_threads;
2433
2434 while (num_elements % kernel_threads) num_elements++;
2435
2436 cl_kernel kernel = NULL;
2437
2438 switch (kern_run)
2439 {
2440 case KERN_RUN_1: kernel = device_param->kernel1; break;
2441 case KERN_RUN_12: kernel = device_param->kernel12; break;
2442 case KERN_RUN_2: kernel = device_param->kernel2; break;
2443 case KERN_RUN_23: kernel = device_param->kernel23; break;
2444 case KERN_RUN_3: kernel = device_param->kernel3; break;
2445 }
2446
2447 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2448 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2449 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2450 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2451 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2452 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2453 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2454 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2455 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2456 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2457 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2458
2459 cl_event event;
2460
2461 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2462 {
2463 const size_t global_work_size[3] = { num_elements, 32, 1 };
2464 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2465
2466 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2467 }
2468 else
2469 {
2470 if (kern_run == KERN_RUN_2)
2471 {
2472 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2473 {
2474 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2475 }
2476 }
2477
2478 while (num_elements % kernel_threads) num_elements++;
2479
2480 const size_t global_work_size[3] = { num_elements, 1, 1 };
2481 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2482
2483 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2484 }
2485
2486 hc_clFlush (data.ocl, device_param->command_queue);
2487
2488 hc_clWaitForEvents (data.ocl, 1, &event);
2489
2490 if (event_update)
2491 {
2492 cl_ulong time_start;
2493 cl_ulong time_end;
2494
2495 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2496 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2497
2498 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2499
2500 uint exec_pos = device_param->exec_pos;
2501
2502 device_param->exec_ms[exec_pos] = exec_time;
2503
2504 exec_pos++;
2505
2506 if (exec_pos == EXEC_CACHE)
2507 {
2508 exec_pos = 0;
2509 }
2510
2511 device_param->exec_pos = exec_pos;
2512 }
2513
2514 hc_clReleaseEvent (data.ocl, event);
2515
2516 hc_clFinish (data.ocl, device_param->command_queue);
2517 }
2518
2519 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2520 {
2521 uint num_elements = num;
2522
2523 switch (kern_run)
2524 {
2525 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2526 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2527 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2528 }
2529
2530 // causes problems with special threads like in bcrypt
2531 // const uint kernel_threads = device_param->kernel_threads;
2532
2533 uint kernel_threads = device_param->kernel_threads;
2534
2535 while (num_elements % kernel_threads) num_elements++;
2536
2537 cl_kernel kernel = NULL;
2538
2539 switch (kern_run)
2540 {
2541 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2542 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2543 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2544 }
2545
2546 switch (kern_run)
2547 {
2548 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2549 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2550 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2551 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2552 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2553 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2554 break;
2555 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2556 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2557 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2558 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2559 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2560 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2561 break;
2562 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2563 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2564 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2565 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2566 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2567 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2568 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2569 break;
2570 }
2571
2572 const size_t global_work_size[3] = { num_elements, 1, 1 };
2573 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2574
2575 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2576
2577 hc_clFlush (data.ocl, device_param->command_queue);
2578
2579 hc_clFinish (data.ocl, device_param->command_queue);
2580 }
2581
2582 static void run_kernel_tm (hc_device_param_t *device_param)
2583 {
2584 const uint num_elements = 1024; // fixed
2585
2586 uint kernel_threads = 32;
2587
2588 cl_kernel kernel = device_param->kernel_tm;
2589
2590 const size_t global_work_size[3] = { num_elements, 1, 1 };
2591 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2592
2593 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2594
2595 hc_clFlush (data.ocl, device_param->command_queue);
2596
2597 hc_clFinish (data.ocl, device_param->command_queue);
2598 }
2599
2600 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2601 {
2602 uint num_elements = num;
2603
2604 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2605 device_param->kernel_params_amp_buf32[6] = num_elements;
2606
2607 // causes problems with special threads like in bcrypt
2608 // const uint kernel_threads = device_param->kernel_threads;
2609
2610 uint kernel_threads = device_param->kernel_threads;
2611
2612 while (num_elements % kernel_threads) num_elements++;
2613
2614 cl_kernel kernel = device_param->kernel_amp;
2615
2616 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2617 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2618
2619 const size_t global_work_size[3] = { num_elements, 1, 1 };
2620 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2621
2622 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2623
2624 hc_clFlush (data.ocl, device_param->command_queue);
2625
2626 hc_clFinish (data.ocl, device_param->command_queue);
2627 }
2628
2629 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2630 {
2631 int rc = -1;
2632
2633 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2634 {
2635 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2636
2637 const cl_uchar zero = 0;
2638
2639 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2640 }
2641
2642 if (rc != 0)
2643 {
2644 // NOTE: clEnqueueFillBuffer () always fails with -59
2645 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2646 // How's that possible, OpenCL 1.2 support is advertised??
2647 // We need to workaround...
2648
2649 #define FILLSZ 0x100000
2650
2651 char *tmp = (char *) mymalloc (FILLSZ);
2652
2653 for (size_t i = 0; i < size; i += FILLSZ)
2654 {
2655 const size_t left = size - i;
2656
2657 const size_t fillsz = MIN (FILLSZ, left);
2658
2659 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2660 }
2661
2662 myfree (tmp);
2663 }
2664 }
2665
2666 static void choose_kernel (hc_device_param_t *device_param, const uint attack_exec, const uint attack_mode, const uint opts_type, const salt_t *salt_buf, const uint highest_pw_len, const uint pws_cnt)
2667 {
2668 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2669 {
2670 if (attack_mode == ATTACK_MODE_BF)
2671 {
2672 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2673 {
2674 const uint size_tm = 32 * sizeof (bs_word_t);
2675
2676 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2677
2678 run_kernel_tm (device_param);
2679
2680 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2681 }
2682 }
2683
2684 if (highest_pw_len < 16)
2685 {
2686 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2687 }
2688 else if (highest_pw_len < 32)
2689 {
2690 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2691 }
2692 else
2693 {
2694 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2695 }
2696 }
2697 else
2698 {
2699 run_kernel_amp (device_param, pws_cnt);
2700
2701 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2702
2703 if (opts_type & OPTS_TYPE_HOOK12)
2704 {
2705 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2706 }
2707
2708 uint iter = salt_buf->salt_iter;
2709
2710 uint loop_step = device_param->kernel_loops;
2711
2712 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2713 {
2714 uint loop_left = iter - loop_pos;
2715
2716 loop_left = MIN (loop_left, loop_step);
2717
2718 device_param->kernel_params_buf32[25] = loop_pos;
2719 device_param->kernel_params_buf32[26] = loop_left;
2720
2721 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2722
2723 if (data.devices_status == STATUS_CRACKED) break;
2724 if (data.devices_status == STATUS_ABORTED) break;
2725 if (data.devices_status == STATUS_QUIT) break;
2726
2727 /**
2728 * speed
2729 */
2730
2731 const float iter_part = (float) (loop_pos + loop_left) / iter;
2732
2733 const u64 perf_sum_all = pws_cnt * iter_part;
2734
2735 double speed_ms;
2736
2737 hc_timer_get (device_param->timer_speed, speed_ms);
2738
2739 const u32 speed_pos = device_param->speed_pos;
2740
2741 device_param->speed_cnt[speed_pos] = perf_sum_all;
2742
2743 device_param->speed_ms[speed_pos] = speed_ms;
2744
2745 if (data.benchmark == 1)
2746 {
2747 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2748 }
2749 }
2750
2751 if (opts_type & OPTS_TYPE_HOOK23)
2752 {
2753 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2754
2755 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2756
2757 // do something with data
2758
2759 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2760 }
2761
2762 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2763 }
2764 }
2765
2766 static int run_rule_engine (const int rule_len, const char *rule_buf)
2767 {
2768 if (rule_len == 0)
2769 {
2770 return 0;
2771 }
2772 else if (rule_len == 1)
2773 {
2774 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2775 }
2776
2777 return 1;
2778 }
2779
2780 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2781 {
2782 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2783 {
2784 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2785 }
2786 else if (data.attack_kern == ATTACK_KERN_COMBI)
2787 {
2788 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2789 {
2790 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2791 {
2792 for (u32 i = 0; i < pws_cnt; i++)
2793 {
2794 const u32 pw_len = device_param->pws_buf[i].pw_len;
2795
2796 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2797
2798 ptr[pw_len] = 0x01;
2799 }
2800 }
2801 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2802 {
2803 for (u32 i = 0; i < pws_cnt; i++)
2804 {
2805 const u32 pw_len = device_param->pws_buf[i].pw_len;
2806
2807 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2808
2809 ptr[pw_len] = 0x80;
2810 }
2811 }
2812 }
2813
2814 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2815 }
2816 else if (data.attack_kern == ATTACK_KERN_BF)
2817 {
2818 const u64 off = device_param->words_off;
2819
2820 device_param->kernel_params_mp_l_buf64[3] = off;
2821
2822 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2823 }
2824 }
2825
2826 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2827 {
2828 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2829
2830 device_param->kernel_params_buf32[25] = 0;
2831 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2832 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2833
2834 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2835 {
2836 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2837 }
2838 else
2839 {
2840 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2841 }
2842
2843 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2844
2845 return exec_ms_prev;
2846 }
2847
2848 static void autotune (hc_device_param_t *device_param)
2849 {
2850 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2851
2852 const u32 kernel_accel_min = device_param->kernel_accel_min;
2853 const u32 kernel_accel_max = device_param->kernel_accel_max;
2854
2855 const u32 kernel_loops_min = device_param->kernel_loops_min;
2856 const u32 kernel_loops_max = device_param->kernel_loops_max;
2857
2858 u32 kernel_accel = kernel_accel_min;
2859 u32 kernel_loops = kernel_loops_min;
2860
2861 // init some fake words
2862
2863 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2864
2865 for (u32 i = 0; i < kernel_power_max; i++)
2866 {
2867 device_param->pws_buf[i].i[0] = i;
2868 device_param->pws_buf[i].i[1] = 0x01234567;
2869 device_param->pws_buf[i].pw_len = 7;
2870 }
2871
2872 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2873
2874 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2875 {
2876 run_kernel_amp (device_param, kernel_power_max);
2877 }
2878
2879 // begin actual testing
2880
2881 double exec_ms_final = try_run (device_param, kernel_accel, kernel_loops);
2882
2883 if ((kernel_loops_min == kernel_loops_max) || (kernel_accel_min == kernel_accel_max))
2884 {
2885 // we do this in case the user specified a fixed -u and -n on the commandline
2886 // so we have a cached kernel for benchmark
2887
2888 try_run (device_param, kernel_accel, kernel_loops);
2889 try_run (device_param, kernel_accel, kernel_loops);
2890 try_run (device_param, kernel_accel, kernel_loops);
2891 try_run (device_param, kernel_accel, kernel_loops);
2892 try_run (device_param, kernel_accel, kernel_loops);
2893 }
2894
2895 // first find out highest kernel-loops that stays below target_ms
2896
2897 #define STEPS_CNT 10
2898
2899 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
2900 {
2901 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
2902
2903 if (exec_ms < target_ms) break;
2904 }
2905
2906 // now the same for kernel-accel but with the new kernel-loops from previous loop set
2907
2908 if (kernel_accel_min < kernel_accel_max)
2909 {
2910 for (int i = 0; i < STEPS_CNT; i++)
2911 {
2912 const u32 kernel_accel_try = 1 << i;
2913
2914 if (kernel_accel_try < kernel_accel_min) continue;
2915 if (kernel_accel_try > kernel_accel_max) break;
2916
2917 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
2918
2919 if (exec_ms > target_ms) break;
2920
2921 exec_ms_final = exec_ms;
2922
2923 kernel_accel = kernel_accel_try;
2924 }
2925 }
2926
2927 // there's a chance that we have a fixed kernel_loops but not a fixed kernel_accel
2928 // in such a case the above function would not create any change
2929 // we'll use the runtime to find out if we're allow to do last improvement
2930
2931 if (exec_ms_final > 0)
2932 {
2933 if ((exec_ms_final * 2) <= target_ms)
2934 {
2935 const double exec_left = target_ms / exec_ms_final;
2936
2937 const double accel_left = kernel_accel_max / kernel_accel;
2938
2939 const int exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
2940
2941 if (exec_accel_min >= 2)
2942 {
2943 kernel_accel *= exec_accel_min;
2944 }
2945 }
2946 }
2947
2948 // balancing the workload turns out to be very efficient
2949
2950 if (kernel_loops_min != kernel_loops_max)
2951 {
2952 const u32 kernel_power_balance = kernel_accel * kernel_loops;
2953
2954 u32 sqrtv;
2955
2956 for (sqrtv = 1; sqrtv < 0x100000; sqrtv++)
2957 {
2958 if ((sqrtv * sqrtv) >= kernel_power_balance) break;
2959 }
2960
2961 const u32 kernel_accel_try = sqrtv;
2962 const u32 kernel_loops_try = sqrtv;
2963
2964 if ((kernel_accel_try <= kernel_accel_max) && (kernel_loops_try >= kernel_loops_min))
2965 {
2966 kernel_accel = kernel_accel_try;
2967 kernel_loops = kernel_loops_try;
2968 }
2969 }
2970
2971 // reset fake words
2972
2973 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
2974
2975 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2976 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_amp_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2977
2978 // reset timer
2979
2980 device_param->exec_pos = 0;
2981
2982 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
2983
2984 // store
2985
2986 device_param->kernel_accel = kernel_accel;
2987 device_param->kernel_loops = kernel_loops;
2988
2989 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2990
2991 device_param->kernel_power = kernel_power;
2992
2993 #ifdef DEBUG
2994
2995 if (data.quiet == 0)
2996 {
2997 clear_prompt ();
2998
2999 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3000 "Device #%u: autotuned kernel-loops to %u\n",
3001 device_param->device_id + 1, kernel_accel,
3002 device_param->device_id + 1, kernel_loops);
3003
3004 fprintf (stdout, "%s", PROMPT);
3005
3006 fflush (stdout);
3007 }
3008
3009 #endif
3010 }
3011
3012 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3013 {
3014 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3015
3016 // init speed timer
3017
3018 uint speed_pos = device_param->speed_pos;
3019
3020 #ifdef _POSIX
3021 if (device_param->timer_speed.tv_sec == 0)
3022 {
3023 hc_timer_set (&device_param->timer_speed);
3024 }
3025 #endif
3026
3027 #ifdef _WIN
3028 if (device_param->timer_speed.QuadPart == 0)
3029 {
3030 hc_timer_set (&device_param->timer_speed);
3031 }
3032 #endif
3033
3034 // find higest password length, this is for optimization stuff
3035
3036 uint highest_pw_len = 0;
3037
3038 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3039 {
3040 }
3041 else if (data.attack_kern == ATTACK_KERN_COMBI)
3042 {
3043 }
3044 else if (data.attack_kern == ATTACK_KERN_BF)
3045 {
3046 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3047 + device_param->kernel_params_mp_l_buf32[5];
3048 }
3049
3050 // iteration type
3051
3052 uint innerloop_step = 0;
3053 uint innerloop_cnt = 0;
3054
3055 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3056 else innerloop_step = 1;
3057
3058 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3059 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3060 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3061
3062 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3063
3064 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3065 {
3066 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3067
3068 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3069
3070 if (data.devices_status == STATUS_CRACKED) break;
3071 if (data.devices_status == STATUS_ABORTED) break;
3072 if (data.devices_status == STATUS_QUIT) break;
3073 if (data.devices_status == STATUS_BYPASS) break;
3074
3075 salt_t *salt_buf = &data.salts_buf[salt_pos];
3076
3077 device_param->kernel_params_buf32[24] = salt_pos;
3078 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3079 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3080
3081 FILE *combs_fp = device_param->combs_fp;
3082
3083 if (data.attack_mode == ATTACK_MODE_COMBI)
3084 {
3085 rewind (combs_fp);
3086 }
3087
3088 // innerloops
3089
3090 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3091 {
3092 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3093
3094 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3095
3096 if (data.devices_status == STATUS_CRACKED) break;
3097 if (data.devices_status == STATUS_ABORTED) break;
3098 if (data.devices_status == STATUS_QUIT) break;
3099 if (data.devices_status == STATUS_BYPASS) break;
3100
3101 uint innerloop_left = innerloop_cnt - innerloop_pos;
3102
3103 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3104
3105 device_param->innerloop_pos = innerloop_pos;
3106 device_param->innerloop_left = innerloop_left;
3107
3108 device_param->kernel_params_buf32[27] = innerloop_left;
3109
3110 // i think we can get rid of this
3111 if (innerloop_left == 0)
3112 {
3113 puts ("bug, how should this happen????\n");
3114
3115 continue;
3116 }
3117
3118 if (data.salts_shown[salt_pos] == 1)
3119 {
3120 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3121
3122 continue;
3123 }
3124
3125 // initialize amplifiers
3126
3127 if (data.attack_mode == ATTACK_MODE_COMBI)
3128 {
3129 uint i = 0;
3130
3131 while (i < innerloop_left)
3132 {
3133 if (feof (combs_fp)) break;
3134
3135 int line_len = fgetl (combs_fp, line_buf);
3136
3137 if (line_len >= PW_MAX1) continue;
3138
3139 line_len = convert_from_hex (line_buf, line_len);
3140
3141 char *line_buf_new = line_buf;
3142
3143 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3144 {
3145 char rule_buf_out[BLOCK_SIZE] = { 0 };
3146
3147 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3148
3149 if (rule_len_out < 0)
3150 {
3151 data.words_progress_rejected[salt_pos] += pws_cnt;
3152
3153 continue;
3154 }
3155
3156 line_len = rule_len_out;
3157
3158 line_buf_new = rule_buf_out;
3159 }
3160
3161 line_len = MIN (line_len, PW_DICTMAX);
3162
3163 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3164
3165 memcpy (ptr, line_buf_new, line_len);
3166
3167 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3168
3169 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3170 {
3171 uppercase (ptr, line_len);
3172 }
3173
3174 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3175 {
3176 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3177 {
3178 ptr[line_len] = 0x80;
3179 }
3180
3181 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3182 {
3183 ptr[line_len] = 0x01;
3184 }
3185 }
3186
3187 device_param->combs_buf[i].pw_len = line_len;
3188
3189 i++;
3190 }
3191
3192 for (uint j = i; j < innerloop_left; j++)
3193 {
3194 device_param->combs_buf[j].i[0] = 0;
3195 device_param->combs_buf[j].i[1] = 0;
3196 device_param->combs_buf[j].i[2] = 0;
3197 device_param->combs_buf[j].i[3] = 0;
3198 device_param->combs_buf[j].i[4] = 0;
3199 device_param->combs_buf[j].i[5] = 0;
3200 device_param->combs_buf[j].i[6] = 0;
3201 device_param->combs_buf[j].i[7] = 0;
3202
3203 device_param->combs_buf[j].pw_len = 0;
3204 }
3205
3206 innerloop_left = i;
3207 }
3208 else if (data.attack_mode == ATTACK_MODE_BF)
3209 {
3210 u64 off = innerloop_pos;
3211
3212 device_param->kernel_params_mp_r_buf64[3] = off;
3213
3214 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3215 }
3216 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3217 {
3218 u64 off = innerloop_pos;
3219
3220 device_param->kernel_params_mp_buf64[3] = off;
3221
3222 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3223 }
3224 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3225 {
3226 u64 off = innerloop_pos;
3227
3228 device_param->kernel_params_mp_buf64[3] = off;
3229
3230 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3231 }
3232
3233 // copy amplifiers
3234
3235 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3236 {
3237 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, innerloop_pos * sizeof (kernel_rule_t), 0, innerloop_left * sizeof (kernel_rule_t), 0, NULL, NULL);
3238 }
3239 else if (data.attack_mode == ATTACK_MODE_COMBI)
3240 {
3241 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_combs_c, CL_TRUE, 0, innerloop_left * sizeof (comb_t), device_param->combs_buf, 0, NULL, NULL);
3242 }
3243 else if (data.attack_mode == ATTACK_MODE_BF)
3244 {
3245 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_bfs, device_param->d_bfs_c, 0, 0, innerloop_left * sizeof (bf_t), 0, NULL, NULL);
3246 }
3247 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3248 {
3249 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3250 }
3251 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3252 {
3253 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3254 }
3255
3256 if (data.benchmark == 1)
3257 {
3258 hc_timer_set (&device_param->timer_speed);
3259 }
3260
3261 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3262
3263 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3264
3265 if (data.devices_status == STATUS_CRACKED) break;
3266 if (data.devices_status == STATUS_ABORTED) break;
3267 if (data.devices_status == STATUS_QUIT) break;
3268
3269 /**
3270 * result
3271 */
3272
3273 hc_thread_mutex_lock (mux_display);
3274
3275 check_cracked (device_param, salt_pos);
3276
3277 hc_thread_mutex_unlock (mux_display);
3278
3279 /**
3280 * progress
3281 */
3282
3283 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3284
3285 hc_thread_mutex_lock (mux_counter);
3286
3287 data.words_progress_done[salt_pos] += perf_sum_all;
3288
3289 hc_thread_mutex_unlock (mux_counter);
3290
3291 /**
3292 * speed
3293 */
3294
3295 double speed_ms;
3296
3297 hc_timer_get (device_param->timer_speed, speed_ms);
3298
3299 hc_timer_set (&device_param->timer_speed);
3300
3301 hc_thread_mutex_lock (mux_display);
3302
3303 // current speed
3304
3305 device_param->speed_cnt[speed_pos] = perf_sum_all;
3306
3307 device_param->speed_ms[speed_pos] = speed_ms;
3308
3309 hc_thread_mutex_unlock (mux_display);
3310
3311 speed_pos++;
3312
3313 if (speed_pos == SPEED_CACHE)
3314 {
3315 speed_pos = 0;
3316 }
3317
3318 /**
3319 * benchmark
3320 */
3321
3322 if (data.benchmark == 1) break;
3323 }
3324 }
3325
3326 device_param->speed_pos = speed_pos;
3327
3328 myfree (line_buf);
3329 }
3330
3331 static void load_segment (wl_data_t *wl_data, FILE *fd)
3332 {
3333 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3334
3335 wl_data->pos = 0;
3336
3337 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3338
3339 wl_data->buf[wl_data->cnt] = 0;
3340
3341 if (wl_data->cnt == 0) return;
3342
3343 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3344
3345 while (!feof (fd))
3346 {
3347 if (wl_data->cnt == wl_data->avail)
3348 {
3349 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3350
3351 wl_data->avail += wl_data->incr;
3352 }
3353
3354 const int c = fgetc (fd);
3355
3356 if (c == EOF) break;
3357
3358 wl_data->buf[wl_data->cnt] = (char) c;
3359
3360 wl_data->cnt++;
3361
3362 if (c == '\n') break;
3363 }
3364
3365 // ensure stream ends with a newline
3366
3367 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3368 {
3369 wl_data->cnt++;
3370
3371 wl_data->buf[wl_data->cnt - 1] = '\n';
3372 }
3373
3374 return;
3375 }
3376
3377 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3378 {
3379 char *ptr = buf;
3380
3381 for (u32 i = 0; i < sz; i++, ptr++)
3382 {
3383 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3384
3385 if (i == 7)
3386 {
3387 *off = i;
3388 *len = i;
3389
3390 return;
3391 }
3392
3393 if (*ptr != '\n') continue;
3394
3395 *off = i + 1;
3396
3397 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3398
3399 *len = i;
3400
3401 return;
3402 }
3403
3404 *off = sz;
3405 *len = sz;
3406 }
3407
3408 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3409 {
3410 char *ptr = buf;
3411
3412 for (u32 i = 0; i < sz; i++, ptr++)
3413 {
3414 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3415
3416 if (*ptr != '\n') continue;
3417
3418 *off = i + 1;
3419
3420 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3421
3422 *len = i;
3423
3424 return;
3425 }
3426
3427 *off = sz;
3428 *len = sz;
3429 }
3430
3431 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3432 {
3433 char *ptr = buf;
3434
3435 for (u32 i = 0; i < sz; i++, ptr++)
3436 {
3437 if (*ptr != '\n') continue;
3438
3439 *off = i + 1;
3440
3441 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3442
3443 *len = i;
3444
3445 return;
3446 }
3447
3448 *off = sz;
3449 *len = sz;
3450 }
3451
3452 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3453 {
3454 while (wl_data->pos < wl_data->cnt)
3455 {
3456 uint off;
3457 uint len;
3458
3459 char *ptr = wl_data->buf + wl_data->pos;
3460
3461 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3462
3463 wl_data->pos += off;
3464
3465 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3466 {
3467 char rule_buf_out[BLOCK_SIZE] = { 0 };
3468
3469 int rule_len_out = -1;
3470
3471 if (len < BLOCK_SIZE)
3472 {
3473 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3474 }
3475
3476 if (rule_len_out < 0)
3477 {
3478 continue;
3479 }
3480
3481 if (rule_len_out > PW_MAX)
3482 {
3483 continue;
3484 }
3485 }
3486 else
3487 {
3488 if (len > PW_MAX)
3489 {
3490 continue;
3491 }
3492 }
3493
3494 *out_buf = ptr;
3495 *out_len = len;
3496
3497 return;
3498 }
3499
3500 if (feof (fd))
3501 {
3502 fprintf (stderr, "BUG feof()!!\n");
3503
3504 return;
3505 }
3506
3507 load_segment (wl_data, fd);
3508
3509 get_next_word (wl_data, fd, out_buf, out_len);
3510 }
3511
3512 #ifdef _POSIX
3513 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3514 #endif
3515
3516 #ifdef _WIN
3517 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3518 #endif
3519 {
3520 hc_signal (NULL);
3521
3522 dictstat_t d;
3523
3524 d.cnt = 0;
3525
3526 #ifdef _POSIX
3527 fstat (fileno (fd), &d.stat);
3528 #endif
3529
3530 #ifdef _WIN
3531 _fstat64 (fileno (fd), &d.stat);
3532 #endif
3533
3534 d.stat.st_mode = 0;
3535 d.stat.st_nlink = 0;
3536 d.stat.st_uid = 0;
3537 d.stat.st_gid = 0;
3538 d.stat.st_rdev = 0;
3539 d.stat.st_atime = 0;
3540
3541 #ifdef _POSIX
3542 d.stat.st_blksize = 0;
3543 d.stat.st_blocks = 0;
3544 #endif
3545
3546 if (d.stat.st_size == 0) return 0;
3547
3548 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3549
3550 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3551 {
3552 if (d_cache)
3553 {
3554 u64 cnt = d_cache->cnt;
3555
3556 u64 keyspace = cnt;
3557
3558 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3559 {
3560 keyspace *= data.kernel_rules_cnt;
3561 }
3562 else if (data.attack_kern == ATTACK_KERN_COMBI)
3563 {
3564 keyspace *= data.combs_cnt;
3565 }
3566
3567 if (data.quiet == 0) log_info ("Cache-hit dictionary stats %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) d.stat.st_size, (unsigned long long int) cnt, (unsigned long long int) keyspace);
3568 if (data.quiet == 0) log_info ("");
3569
3570 hc_signal (sigHandler_default);
3571
3572 return (keyspace);
3573 }
3574 }
3575
3576 time_t now = 0;
3577 time_t prev = 0;
3578
3579 u64 comp = 0;
3580 u64 cnt = 0;
3581 u64 cnt2 = 0;
3582
3583 while (!feof (fd))
3584 {
3585 load_segment (wl_data, fd);
3586
3587 comp += wl_data->cnt;
3588
3589 u32 i = 0;
3590
3591 while (i < wl_data->cnt)
3592 {
3593 u32 len;
3594 u32 off;
3595
3596 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3597
3598 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3599 {
3600 char rule_buf_out[BLOCK_SIZE] = { 0 };
3601
3602 int rule_len_out = -1;
3603
3604 if (len < BLOCK_SIZE)
3605 {
3606 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3607 }
3608
3609 if (rule_len_out < 0)
3610 {
3611 len = PW_MAX1;
3612 }
3613 else
3614 {
3615 len = rule_len_out;
3616 }
3617 }
3618
3619 if (len < PW_MAX1)
3620 {
3621 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3622 {
3623 cnt += data.kernel_rules_cnt;
3624 }
3625 else if (data.attack_kern == ATTACK_KERN_COMBI)
3626 {
3627 cnt += data.combs_cnt;
3628 }
3629
3630 d.cnt++;
3631 }
3632
3633 i += off;
3634
3635 cnt2++;
3636 }
3637
3638 time (&now);
3639
3640 if ((now - prev) == 0) continue;
3641
3642 float percent = (float) comp / (float) d.stat.st_size;
3643
3644 if (data.quiet == 0) log_info_nn ("Generating dictionary stats for %s: %llu bytes (%.2f%%), %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, percent * 100, (unsigned long long int) cnt2, (unsigned long long int) cnt);
3645
3646 time (&prev);
3647 }
3648
3649 if (data.quiet == 0) log_info ("Generated dictionary stats for %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, (unsigned long long int) cnt2, (unsigned long long int) cnt);
3650 if (data.quiet == 0) log_info ("");
3651
3652 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3653
3654 hc_signal (sigHandler_default);
3655
3656 return (cnt);
3657 }
3658
3659 static void *thread_monitor (void *p)
3660 {
3661 uint runtime_check = 0;
3662 uint remove_check = 0;
3663 uint status_check = 0;
3664 uint restore_check = 0;
3665
3666 uint restore_left = data.restore_timer;
3667 uint remove_left = data.remove_timer;
3668 uint status_left = data.status_timer;
3669
3670 #ifdef HAVE_HWMON
3671 uint hwmon_check = 0;
3672
3673 // these variables are mainly used for fan control (AMD only)
3674
3675 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3676
3677 // temperature controller "loopback" values
3678
3679 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3680 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3681
3682 #ifdef HAVE_ADL
3683 int temp_threshold = 1; // degrees celcius
3684
3685 int fan_speed_min = 15; // in percentage
3686 int fan_speed_max = 100;
3687 #endif // HAVE_ADL
3688
3689 time_t last_temp_check_time;
3690 #endif // HAVE_HWMON
3691
3692 uint sleep_time = 1;
3693
3694 if (data.runtime)
3695 {
3696 runtime_check = 1;
3697 }
3698
3699 if (data.restore_timer)
3700 {
3701 restore_check = 1;
3702 }
3703
3704 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3705 {
3706 remove_check = 1;
3707 }
3708
3709 if (data.status == 1)
3710 {
3711 status_check = 1;
3712 }
3713
3714 #ifdef HAVE_HWMON
3715 if (data.gpu_temp_disable == 0)
3716 {
3717 time (&last_temp_check_time);
3718
3719 hwmon_check = 1;
3720 }
3721 #endif
3722
3723 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3724 {
3725 #ifdef HAVE_HWMON
3726 if (hwmon_check == 0)
3727 #endif
3728 return (p);
3729 }
3730
3731 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3732 {
3733 hc_sleep (sleep_time);
3734
3735 if (data.devices_status != STATUS_RUNNING) continue;
3736
3737 #ifdef HAVE_HWMON
3738 if (hwmon_check == 1)
3739 {
3740 hc_thread_mutex_lock (mux_adl);
3741
3742 time_t temp_check_time;
3743
3744 time (&temp_check_time);
3745
3746 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3747
3748 if (Ta == 0) Ta = 1;
3749
3750 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3751 {
3752 hc_device_param_t *device_param = &data.devices_param[device_id];
3753
3754 if (device_param->skipped) continue;
3755
3756 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3757
3758 const int temperature = hm_get_temperature_with_device_id (device_id);
3759
3760 if (temperature > (int) data.gpu_temp_abort)
3761 {
3762 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3763
3764 if (data.devices_status != STATUS_QUIT) myabort ();
3765
3766 break;
3767 }
3768
3769 #ifdef HAVE_ADL
3770 const int gpu_temp_retain = data.gpu_temp_retain;
3771
3772 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3773 {
3774 if (data.hm_device[device_id].fan_supported == 1)
3775 {
3776 int temp_cur = temperature;
3777
3778 int temp_diff_new = gpu_temp_retain - temp_cur;
3779
3780 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3781
3782 // calculate Ta value (time difference in seconds between the last check and this check)
3783
3784 last_temp_check_time = temp_check_time;
3785
3786 float Kp = 1.8;
3787 float Ki = 0.005;
3788 float Kd = 6;
3789
3790 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3791
3792 int fan_diff_required = (int) (Kp * (float)temp_diff_new + Ki * Ta * (float)temp_diff_sum[device_id] + Kd * ((float)(temp_diff_new - temp_diff_old[device_id])) / Ta);
3793
3794 if (abs (fan_diff_required) >= temp_threshold)
3795 {
3796 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3797
3798 int fan_speed_level = fan_speed_cur;
3799
3800 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3801
3802 int fan_speed_new = fan_speed_level - fan_diff_required;
3803
3804 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3805 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3806
3807 if (fan_speed_new != fan_speed_cur)
3808 {
3809 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3810 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3811
3812 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3813 {
3814 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3815
3816 fan_speed_chgd[device_id] = 1;
3817 }
3818
3819 temp_diff_old[device_id] = temp_diff_new;
3820 }
3821 }
3822 }
3823 }
3824 #endif // HAVE_ADL
3825 }
3826
3827 hc_thread_mutex_unlock (mux_adl);
3828 }
3829 #endif // HAVE_HWMON
3830
3831 if (restore_check == 1)
3832 {
3833 restore_left--;
3834
3835 if (restore_left == 0)
3836 {
3837 if (data.restore_disable == 0) cycle_restore ();
3838
3839 restore_left = data.restore_timer;
3840 }
3841 }
3842
3843 if ((runtime_check == 1) && (data.runtime_start > 0))
3844 {
3845 time_t runtime_cur;
3846
3847 time (&runtime_cur);
3848
3849 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3850
3851 if (runtime_left <= 0)
3852 {
3853 if (data.benchmark == 0)
3854 {
3855 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3856 }
3857
3858 if (data.devices_status != STATUS_QUIT) myabort ();
3859 }
3860 }
3861
3862 if (remove_check == 1)
3863 {
3864 remove_left--;
3865
3866 if (remove_left == 0)
3867 {
3868 if (data.digests_saved != data.digests_done)
3869 {
3870 data.digests_saved = data.digests_done;
3871
3872 save_hash ();
3873 }
3874
3875 remove_left = data.remove_timer;
3876 }
3877 }
3878
3879 if (status_check == 1)
3880 {
3881 status_left--;
3882
3883 if (status_left == 0)
3884 {
3885 hc_thread_mutex_lock (mux_display);
3886
3887 if (data.quiet == 0) clear_prompt ();
3888
3889 if (data.quiet == 0) log_info ("");
3890
3891 status_display ();
3892
3893 if (data.quiet == 0) log_info ("");
3894
3895 hc_thread_mutex_unlock (mux_display);
3896
3897 status_left = data.status_timer;
3898 }
3899 }
3900 }
3901
3902 #ifdef HAVE_HWMON
3903 myfree (fan_speed_chgd);
3904
3905 myfree (temp_diff_old);
3906 myfree (temp_diff_sum);
3907 #endif
3908
3909 p = NULL;
3910
3911 return (p);
3912 }
3913
3914 static void *thread_outfile_remove (void *p)
3915 {
3916 // some hash-dependent constants
3917 char *outfile_dir = data.outfile_check_directory;
3918 uint dgst_size = data.dgst_size;
3919 uint isSalted = data.isSalted;
3920 uint esalt_size = data.esalt_size;
3921 uint hash_mode = data.hash_mode;
3922
3923 uint outfile_check_timer = data.outfile_check_timer;
3924
3925 char separator = data.separator;
3926
3927 // some hash-dependent functions
3928 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3929 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3930
3931 // buffers
3932 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3933
3934 hash_buf.digest = mymalloc (dgst_size);
3935
3936 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3937
3938 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3939
3940 uint digest_buf[64] = { 0 };
3941
3942 outfile_data_t *out_info = NULL;
3943
3944 char **out_files = NULL;
3945
3946 time_t folder_mtime = 0;
3947
3948 int out_cnt = 0;
3949
3950 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3951
3952 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3953 {
3954 hc_sleep (1);
3955
3956 if (data.devices_status != STATUS_RUNNING) continue;
3957
3958 check_left--;
3959
3960 if (check_left == 0)
3961 {
3962 struct stat outfile_check_stat;
3963
3964 if (stat (outfile_dir, &outfile_check_stat) == 0)
3965 {
3966 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3967
3968 if (is_dir == 1)
3969 {
3970 if (outfile_check_stat.st_mtime > folder_mtime)
3971 {
3972 char **out_files_new = scan_directory (outfile_dir);
3973
3974 int out_cnt_new = count_dictionaries (out_files_new);
3975
3976 outfile_data_t *out_info_new = NULL;
3977
3978 if (out_cnt_new > 0)
3979 {
3980 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3981
3982 for (int i = 0; i < out_cnt_new; i++)
3983 {
3984 out_info_new[i].file_name = out_files_new[i];
3985
3986 // check if there are files that we have seen/checked before (and not changed)
3987
3988 for (int j = 0; j < out_cnt; j++)
3989 {
3990 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3991 {
3992 struct stat outfile_stat;
3993
3994 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3995 {
3996 if (outfile_stat.st_ctime == out_info[j].ctime)
3997 {
3998 out_info_new[i].ctime = out_info[j].ctime;
3999 out_info_new[i].seek = out_info[j].seek;
4000 }
4001 }
4002 }
4003 }
4004 }
4005 }
4006
4007 local_free (out_info);
4008 local_free (out_files);
4009
4010 out_files = out_files_new;
4011 out_cnt = out_cnt_new;
4012 out_info = out_info_new;
4013
4014 folder_mtime = outfile_check_stat.st_mtime;
4015 }
4016
4017 for (int j = 0; j < out_cnt; j++)
4018 {
4019 FILE *fp = fopen (out_info[j].file_name, "rb");
4020
4021 if (fp != NULL)
4022 {
4023 //hc_thread_mutex_lock (mux_display);
4024
4025 #ifdef _POSIX
4026 struct stat outfile_stat;
4027
4028 fstat (fileno (fp), &outfile_stat);
4029 #endif
4030
4031 #ifdef _WIN
4032 struct stat64 outfile_stat;
4033
4034 _fstat64 (fileno (fp), &outfile_stat);
4035 #endif
4036
4037 if (outfile_stat.st_ctime > out_info[j].ctime)
4038 {
4039 out_info[j].ctime = outfile_stat.st_ctime;
4040 out_info[j].seek = 0;
4041 }
4042
4043 fseek (fp, out_info[j].seek, SEEK_SET);
4044
4045 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4046
4047 while (!feof (fp))
4048 {
4049 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4050
4051 if (ptr == NULL) break;
4052
4053 int line_len = strlen (line_buf);
4054
4055 if (line_len <= 0) continue;
4056
4057 int iter = MAX_CUT_TRIES;
4058
4059 for (uint i = line_len - 1; i && iter; i--, line_len--)
4060 {
4061 if (line_buf[i] != separator) continue;
4062
4063 int parser_status = PARSER_OK;
4064
4065 if ((hash_mode != 2500) && (hash_mode != 6800))
4066 {
4067 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4068 }
4069
4070 uint found = 0;
4071
4072 if (parser_status == PARSER_OK)
4073 {
4074 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4075 {
4076 if (data.salts_shown[salt_pos] == 1) continue;
4077
4078 salt_t *salt_buf = &data.salts_buf[salt_pos];
4079
4080 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4081 {
4082 uint idx = salt_buf->digests_offset + digest_pos;
4083
4084 if (data.digests_shown[idx] == 1) continue;
4085
4086 uint cracked = 0;
4087
4088 if (hash_mode == 6800)
4089 {
4090 if (i == salt_buf->salt_len)
4091 {
4092 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4093 }
4094 }
4095 else if (hash_mode == 2500)
4096 {
4097 // BSSID : MAC1 : MAC2 (:plain)
4098 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4099 {
4100 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4101
4102 if (!cracked) continue;
4103
4104 // now compare MAC1 and MAC2 too, since we have this additional info
4105 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4106 char *mac2_pos = mac1_pos + 12 + 1;
4107
4108 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4109 wpa_t *wpa = &wpas[salt_pos];
4110
4111 // compare hex string(s) vs binary MAC address(es)
4112
4113 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4114 {
4115 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4116 {
4117 cracked = 0;
4118
4119 break;
4120 }
4121 }
4122
4123 // early skip ;)
4124 if (!cracked) continue;
4125
4126 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4127 {
4128 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4129 {
4130 cracked = 0;
4131
4132 break;
4133 }
4134 }
4135 }
4136 }
4137 else
4138 {
4139 char *digests_buf_ptr = (char *) data.digests_buf;
4140
4141 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4142
4143 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4144 }
4145
4146 if (cracked == 1)
4147 {
4148 found = 1;
4149
4150 data.digests_shown[idx] = 1;
4151
4152 data.digests_done++;
4153
4154 salt_buf->digests_done++;
4155
4156 if (salt_buf->digests_done == salt_buf->digests_cnt)
4157 {
4158 data.salts_shown[salt_pos] = 1;
4159
4160 data.salts_done++;
4161
4162 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4163 }
4164 }
4165 }
4166
4167 if (data.devices_status == STATUS_CRACKED) break;
4168 }
4169 }
4170
4171 if (found) break;
4172
4173 if (data.devices_status == STATUS_CRACKED) break;
4174
4175 iter--;
4176 }
4177
4178 if (data.devices_status == STATUS_CRACKED) break;
4179 }
4180
4181 myfree (line_buf);
4182
4183 out_info[j].seek = ftell (fp);
4184
4185 //hc_thread_mutex_unlock (mux_display);
4186
4187 fclose (fp);
4188 }
4189 }
4190 }
4191 }
4192
4193 check_left = outfile_check_timer;
4194 }
4195 }
4196
4197 if (esalt_size) local_free (hash_buf.esalt);
4198
4199 if (isSalted) local_free (hash_buf.salt);
4200
4201 local_free (hash_buf.digest);
4202
4203 local_free (out_info);
4204
4205 local_free (out_files);
4206
4207 p = NULL;
4208
4209 return (p);
4210 }
4211
4212 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4213 {
4214 if (device_param->pws_cnt < device_param->kernel_power)
4215 {
4216 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4217
4218 u8 *ptr = (u8 *) pw->i;
4219
4220 memcpy (ptr, pw_buf, pw_len);
4221
4222 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4223
4224 pw->pw_len = pw_len;
4225
4226 device_param->pws_cnt++;
4227 }
4228 else
4229 {
4230 fprintf (stderr, "BUG pw_add()!!\n");
4231
4232 return;
4233 }
4234 }
4235
4236 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4237 {
4238 hc_thread_mutex_lock (mux_dispatcher);
4239
4240 const u64 words_cur = data.words_cur;
4241 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4242
4243 device_param->words_off = words_cur;
4244
4245 const u64 words_left = words_base - words_cur;
4246
4247 if (allow_div)
4248 {
4249 if (data.kernel_power_all > words_left)
4250 {
4251 if (data.kernel_power_div == 0)
4252 {
4253 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4254 }
4255 }
4256
4257 if (data.kernel_power_div)
4258 {
4259 if (device_param->kernel_power == device_param->kernel_power_user)
4260 {
4261 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4262
4263 if (kernel_power_new < device_param->kernel_power)
4264 {
4265 device_param->kernel_power = kernel_power_new;
4266 }
4267 }
4268 }
4269 }
4270
4271 const uint kernel_power = device_param->kernel_power;
4272
4273 uint work = MIN (words_left, kernel_power);
4274
4275 work = MIN (work, max);
4276
4277 data.words_cur += work;
4278
4279 hc_thread_mutex_unlock (mux_dispatcher);
4280
4281 return work;
4282 }
4283
4284 static void *thread_calc_stdin (void *p)
4285 {
4286 hc_device_param_t *device_param = (hc_device_param_t *) p;
4287
4288 if (device_param->skipped) return NULL;
4289
4290 autotune (device_param);
4291
4292 char *buf = (char *) mymalloc (HCBUFSIZ);
4293
4294 const uint attack_kern = data.attack_kern;
4295
4296 const uint kernel_power = device_param->kernel_power;
4297
4298 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4299 {
4300 hc_thread_mutex_lock (mux_dispatcher);
4301
4302 if (feof (stdin) != 0)
4303 {
4304 hc_thread_mutex_unlock (mux_dispatcher);
4305
4306 break;
4307 }
4308
4309 uint words_cur = 0;
4310
4311 while (words_cur < kernel_power)
4312 {
4313 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4314
4315 if (line_buf == NULL) break;
4316
4317 uint line_len = in_superchop (line_buf);
4318
4319 line_len = convert_from_hex (line_buf, line_len);
4320
4321 // post-process rule engine
4322
4323 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4324 {
4325 char rule_buf_out[BLOCK_SIZE] = { 0 };
4326
4327 int rule_len_out = -1;
4328
4329 if (line_len < BLOCK_SIZE)
4330 {
4331 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4332 }
4333
4334 if (rule_len_out < 0) continue;
4335
4336 line_buf = rule_buf_out;
4337 line_len = rule_len_out;
4338 }
4339
4340 if (line_len > PW_MAX)
4341 {
4342 continue;
4343 }
4344
4345 if (attack_kern == ATTACK_KERN_STRAIGHT)
4346 {
4347 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4348 {
4349 hc_thread_mutex_lock (mux_counter);
4350
4351 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4352 {
4353 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4354 }
4355
4356 hc_thread_mutex_unlock (mux_counter);
4357
4358 continue;
4359 }
4360 }
4361 else if (attack_kern == ATTACK_KERN_COMBI)
4362 {
4363 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4364 // since we still need to combine the plains
4365
4366 if (line_len > data.pw_max)
4367 {
4368 hc_thread_mutex_lock (mux_counter);
4369
4370 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4371 {
4372 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4373 }
4374
4375 hc_thread_mutex_unlock (mux_counter);
4376
4377 continue;
4378 }
4379 }
4380
4381 pw_add (device_param, (u8 *) line_buf, line_len);
4382
4383 words_cur++;
4384
4385 if (data.devices_status == STATUS_CRACKED) break;
4386 if (data.devices_status == STATUS_ABORTED) break;
4387 if (data.devices_status == STATUS_QUIT) break;
4388 if (data.devices_status == STATUS_BYPASS) break;
4389 }
4390
4391 hc_thread_mutex_unlock (mux_dispatcher);
4392
4393 if (data.devices_status == STATUS_CRACKED) break;
4394 if (data.devices_status == STATUS_ABORTED) break;
4395 if (data.devices_status == STATUS_QUIT) break;
4396 if (data.devices_status == STATUS_BYPASS) break;
4397
4398 // flush
4399
4400 const uint pws_cnt = device_param->pws_cnt;
4401
4402 if (pws_cnt)
4403 {
4404 run_copy (device_param, pws_cnt);
4405
4406 run_cracker (device_param, pws_cnt);
4407
4408 device_param->pws_cnt = 0;
4409
4410 if (attack_kern == ATTACK_KERN_STRAIGHT)
4411 {
4412 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4413 }
4414 else if (attack_kern == ATTACK_KERN_COMBI)
4415 {
4416 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4417 }
4418 }
4419 }
4420
4421 device_param->kernel_accel = 0;
4422 device_param->kernel_loops = 0;
4423
4424 myfree (buf);
4425
4426 return NULL;
4427 }
4428
4429 static void *thread_calc (void *p)
4430 {
4431 hc_device_param_t *device_param = (hc_device_param_t *) p;
4432
4433 if (device_param->skipped) return NULL;
4434
4435 autotune (device_param);
4436
4437 const uint attack_mode = data.attack_mode;
4438 const uint attack_kern = data.attack_kern;
4439
4440 if (attack_mode == ATTACK_MODE_BF)
4441 {
4442 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4443 {
4444 const uint work = get_work (device_param, -1, true);
4445
4446 if (work == 0) break;
4447
4448 const u64 words_off = device_param->words_off;
4449 const u64 words_fin = words_off + work;
4450
4451 const uint pws_cnt = work;
4452
4453 device_param->pws_cnt = pws_cnt;
4454
4455 if (pws_cnt)
4456 {
4457 run_copy (device_param, pws_cnt);
4458
4459 run_cracker (device_param, pws_cnt);
4460
4461 device_param->pws_cnt = 0;
4462
4463 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4464 }
4465
4466 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4467
4468 if (data.devices_status == STATUS_CRACKED) break;
4469 if (data.devices_status == STATUS_ABORTED) break;
4470 if (data.devices_status == STATUS_QUIT) break;
4471 if (data.devices_status == STATUS_BYPASS) break;
4472
4473 if (data.benchmark == 1) break;
4474
4475 device_param->words_done = words_fin;
4476 }
4477 }
4478 else
4479 {
4480 const uint segment_size = data.segment_size;
4481
4482 char *dictfile = data.dictfile;
4483
4484 if (attack_mode == ATTACK_MODE_COMBI)
4485 {
4486 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4487 {
4488 dictfile = data.dictfile2;
4489 }
4490 }
4491
4492 FILE *fd = fopen (dictfile, "rb");
4493
4494 if (fd == NULL)
4495 {
4496 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4497
4498 return NULL;
4499 }
4500
4501 if (attack_mode == ATTACK_MODE_COMBI)
4502 {
4503 const uint combs_mode = data.combs_mode;
4504
4505 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4506 {
4507 const char *dictfilec = data.dictfile2;
4508
4509 FILE *combs_fp = fopen (dictfilec, "rb");
4510
4511 if (combs_fp == NULL)
4512 {
4513 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4514
4515 fclose (fd);
4516
4517 return NULL;
4518 }
4519
4520 device_param->combs_fp = combs_fp;
4521 }
4522 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4523 {
4524 const char *dictfilec = data.dictfile;
4525
4526 FILE *combs_fp = fopen (dictfilec, "rb");
4527
4528 if (combs_fp == NULL)
4529 {
4530 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4531
4532 fclose (fd);
4533
4534 return NULL;
4535 }
4536
4537 device_param->combs_fp = combs_fp;
4538 }
4539 }
4540
4541 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4542
4543 wl_data->buf = (char *) mymalloc (segment_size);
4544 wl_data->avail = segment_size;
4545 wl_data->incr = segment_size;
4546 wl_data->cnt = 0;
4547 wl_data->pos = 0;
4548
4549 u64 words_cur = 0;
4550
4551 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4552 {
4553 u64 words_off = 0;
4554 u64 words_fin = 0;
4555
4556 bool allow_div = true;
4557
4558 u64 max = -1;
4559
4560 while (max)
4561 {
4562 const uint work = get_work (device_param, max, allow_div);
4563
4564 allow_div = false;
4565
4566 if (work == 0) break;
4567
4568 words_off = device_param->words_off;
4569 words_fin = words_off + work;
4570
4571 char *line_buf;
4572 uint line_len;
4573
4574 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4575
4576 max = 0;
4577
4578 for ( ; words_cur < words_fin; words_cur++)
4579 {
4580 get_next_word (wl_data, fd, &line_buf, &line_len);
4581
4582 line_len = convert_from_hex (line_buf, line_len);
4583
4584 // post-process rule engine
4585
4586 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4587 {
4588 char rule_buf_out[BLOCK_SIZE] = { 0 };
4589
4590 int rule_len_out = -1;
4591
4592 if (line_len < BLOCK_SIZE)
4593 {
4594 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4595 }
4596
4597 if (rule_len_out < 0) continue;
4598
4599 line_buf = rule_buf_out;
4600 line_len = rule_len_out;
4601 }
4602
4603 if (attack_kern == ATTACK_KERN_STRAIGHT)
4604 {
4605 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4606 {
4607 max++;
4608
4609 hc_thread_mutex_lock (mux_counter);
4610
4611 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4612 {
4613 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4614 }
4615
4616 hc_thread_mutex_unlock (mux_counter);
4617
4618 continue;
4619 }
4620 }
4621 else if (attack_kern == ATTACK_KERN_COMBI)
4622 {
4623 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4624 // since we still need to combine the plains
4625
4626 if (line_len > data.pw_max)
4627 {
4628 max++;
4629
4630 hc_thread_mutex_lock (mux_counter);
4631
4632 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4633 {
4634 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4635 }
4636
4637 hc_thread_mutex_unlock (mux_counter);
4638
4639 continue;
4640 }
4641 }
4642
4643 pw_add (device_param, (u8 *) line_buf, line_len);
4644
4645 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4646
4647 if (data.devices_status == STATUS_CRACKED) break;
4648 if (data.devices_status == STATUS_ABORTED) break;
4649 if (data.devices_status == STATUS_QUIT) break;
4650 if (data.devices_status == STATUS_BYPASS) break;
4651 }
4652
4653 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4654
4655 if (data.devices_status == STATUS_CRACKED) break;
4656 if (data.devices_status == STATUS_ABORTED) break;
4657 if (data.devices_status == STATUS_QUIT) break;
4658 if (data.devices_status == STATUS_BYPASS) break;
4659 }
4660
4661 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4662
4663 if (data.devices_status == STATUS_CRACKED) break;
4664 if (data.devices_status == STATUS_ABORTED) break;
4665 if (data.devices_status == STATUS_QUIT) break;
4666 if (data.devices_status == STATUS_BYPASS) break;
4667
4668 //
4669 // flush
4670 //
4671
4672 const uint pws_cnt = device_param->pws_cnt;
4673
4674 if (pws_cnt)
4675 {
4676 run_copy (device_param, pws_cnt);
4677
4678 run_cracker (device_param, pws_cnt);
4679
4680 device_param->pws_cnt = 0;
4681
4682 if (attack_kern == ATTACK_KERN_STRAIGHT)
4683 {
4684 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4685 }
4686 else if (attack_kern == ATTACK_KERN_COMBI)
4687 {
4688 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4689 }
4690 }
4691
4692 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4693
4694 if (data.devices_status == STATUS_CRACKED) break;
4695 if (data.devices_status == STATUS_ABORTED) break;
4696 if (data.devices_status == STATUS_QUIT) break;
4697 if (data.devices_status == STATUS_BYPASS) break;
4698
4699 if (words_fin == 0) break;
4700
4701 device_param->words_done = words_fin;
4702 }
4703
4704 if (attack_mode == ATTACK_MODE_COMBI)
4705 {
4706 fclose (device_param->combs_fp);
4707 }
4708
4709 free (wl_data->buf);
4710 free (wl_data);
4711
4712 fclose (fd);
4713 }
4714
4715 device_param->kernel_accel = 0;
4716 device_param->kernel_loops = 0;
4717
4718 return NULL;
4719 }
4720
4721 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4722 {
4723 if (!device_param)
4724 {
4725 log_error ("ERROR: %s : Invalid argument", __func__);
4726
4727 exit (-1);
4728 }
4729
4730 salt_t *salt_buf = &data.salts_buf[salt_pos];
4731
4732 device_param->kernel_params_buf32[24] = salt_pos;
4733 device_param->kernel_params_buf32[27] = 1;
4734 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4735 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4736 device_param->kernel_params_buf32[30] = 0;
4737 device_param->kernel_params_buf32[31] = 1;
4738
4739 char *dictfile_old = data.dictfile;
4740
4741 const char *weak_hash_check = "weak-hash-check";
4742
4743 data.dictfile = (char *) weak_hash_check;
4744
4745 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4746
4747 data.kernel_rules_buf[0].cmds[0] = 0;
4748
4749 /**
4750 * run the kernel
4751 */
4752
4753 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4754 {
4755 run_kernel (KERN_RUN_1, device_param, 1, false);
4756 }
4757 else
4758 {
4759 run_kernel (KERN_RUN_1, device_param, 1, false);
4760
4761 uint loop_step = 16;
4762
4763 const uint iter = salt_buf->salt_iter;
4764
4765 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4766 {
4767 uint loop_left = iter - loop_pos;
4768
4769 loop_left = MIN (loop_left, loop_step);
4770
4771 device_param->kernel_params_buf32[25] = loop_pos;
4772 device_param->kernel_params_buf32[26] = loop_left;
4773
4774 run_kernel (KERN_RUN_2, device_param, 1, false);
4775 }
4776
4777 run_kernel (KERN_RUN_3, device_param, 1, false);
4778 }
4779
4780 /**
4781 * result
4782 */
4783
4784 check_cracked (device_param, salt_pos);
4785
4786 /**
4787 * cleanup
4788 */
4789
4790 device_param->kernel_params_buf32[24] = 0;
4791 device_param->kernel_params_buf32[25] = 0;
4792 device_param->kernel_params_buf32[26] = 0;
4793 device_param->kernel_params_buf32[27] = 0;
4794 device_param->kernel_params_buf32[28] = 0;
4795 device_param->kernel_params_buf32[29] = 0;
4796 device_param->kernel_params_buf32[30] = 0;
4797 device_param->kernel_params_buf32[31] = 0;
4798
4799 data.dictfile = dictfile_old;
4800
4801 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4802 }
4803
4804 // hlfmt hashcat
4805
4806 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4807 {
4808 if (data.username == 0)
4809 {
4810 *hashbuf_pos = line_buf;
4811 *hashbuf_len = line_len;
4812 }
4813 else
4814 {
4815 char *pos = line_buf;
4816 int len = line_len;
4817
4818 for (int i = 0; i < line_len; i++, pos++, len--)
4819 {
4820 if (line_buf[i] == data.separator)
4821 {
4822 pos++;
4823
4824 len--;
4825
4826 break;
4827 }
4828 }
4829
4830 *hashbuf_pos = pos;
4831 *hashbuf_len = len;
4832 }
4833 }
4834
4835 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4836 {
4837 char *pos = NULL;
4838 int len = 0;
4839
4840 int sep_cnt = 0;
4841
4842 for (int i = 0; i < line_len; i++)
4843 {
4844 if (line_buf[i] == data.separator)
4845 {
4846 sep_cnt++;
4847
4848 continue;
4849 }
4850
4851 if (sep_cnt == 0)
4852 {
4853 if (pos == NULL) pos = line_buf + i;
4854
4855 len++;
4856 }
4857 }
4858
4859 *userbuf_pos = pos;
4860 *userbuf_len = len;
4861 }
4862
4863 // hlfmt pwdump
4864
4865 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4866 {
4867 int sep_cnt = 0;
4868
4869 int sep2_len = 0;
4870 int sep3_len = 0;
4871
4872 for (int i = 0; i < line_len; i++)
4873 {
4874 if (line_buf[i] == ':')
4875 {
4876 sep_cnt++;
4877
4878 continue;
4879 }
4880
4881 if (sep_cnt == 2) sep2_len++;
4882 if (sep_cnt == 3) sep3_len++;
4883 }
4884
4885 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4886
4887 return 0;
4888 }
4889
4890 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4891 {
4892 char *pos = NULL;
4893 int len = 0;
4894
4895 int sep_cnt = 0;
4896
4897 for (int i = 0; i < line_len; i++)
4898 {
4899 if (line_buf[i] == ':')
4900 {
4901 sep_cnt++;
4902
4903 continue;
4904 }
4905
4906 if (data.hash_mode == 1000)
4907 {
4908 if (sep_cnt == 3)
4909 {
4910 if (pos == NULL) pos = line_buf + i;
4911
4912 len++;
4913 }
4914 }
4915 else if (data.hash_mode == 3000)
4916 {
4917 if (sep_cnt == 2)
4918 {
4919 if (pos == NULL) pos = line_buf + i;
4920
4921 len++;
4922 }
4923 }
4924 }
4925
4926 *hashbuf_pos = pos;
4927 *hashbuf_len = len;
4928 }
4929
4930 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4931 {
4932 char *pos = NULL;
4933 int len = 0;
4934
4935 int sep_cnt = 0;
4936
4937 for (int i = 0; i < line_len; i++)
4938 {
4939 if (line_buf[i] == ':')
4940 {
4941 sep_cnt++;
4942
4943 continue;
4944 }
4945
4946 if (sep_cnt == 0)
4947 {
4948 if (pos == NULL) pos = line_buf + i;
4949
4950 len++;
4951 }
4952 }
4953
4954 *userbuf_pos = pos;
4955 *userbuf_len = len;
4956 }
4957
4958 // hlfmt passwd
4959
4960 static int hlfmt_detect_passwd (char *line_buf, int line_len)
4961 {
4962 int sep_cnt = 0;
4963
4964 char sep5_first = 0;
4965 char sep6_first = 0;
4966
4967 for (int i = 0; i < line_len; i++)
4968 {
4969 if (line_buf[i] == ':')
4970 {
4971 sep_cnt++;
4972
4973 continue;
4974 }
4975
4976 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4977 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4978 }
4979
4980 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4981
4982 return 0;
4983 }
4984
4985 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4986 {
4987 char *pos = NULL;
4988 int len = 0;
4989
4990 int sep_cnt = 0;
4991
4992 for (int i = 0; i < line_len; i++)
4993 {
4994 if (line_buf[i] == ':')
4995 {
4996 sep_cnt++;
4997
4998 continue;
4999 }
5000
5001 if (sep_cnt == 1)
5002 {
5003 if (pos == NULL) pos = line_buf + i;
5004
5005 len++;
5006 }
5007 }
5008
5009 *hashbuf_pos = pos;
5010 *hashbuf_len = len;
5011 }
5012
5013 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5014 {
5015 char *pos = NULL;
5016 int len = 0;
5017
5018 int sep_cnt = 0;
5019
5020 for (int i = 0; i < line_len; i++)
5021 {
5022 if (line_buf[i] == ':')
5023 {
5024 sep_cnt++;
5025
5026 continue;
5027 }
5028
5029 if (sep_cnt == 0)
5030 {
5031 if (pos == NULL) pos = line_buf + i;
5032
5033 len++;
5034 }
5035 }
5036
5037 *userbuf_pos = pos;
5038 *userbuf_len = len;
5039 }
5040
5041 // hlfmt shadow
5042
5043 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5044 {
5045 int sep_cnt = 0;
5046
5047 for (int i = 0; i < line_len; i++)
5048 {
5049 if (line_buf[i] == ':') sep_cnt++;
5050 }
5051
5052 if (sep_cnt == 8) return 1;
5053
5054 return 0;
5055 }
5056
5057 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5058 {
5059 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5060 }
5061
5062 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5063 {
5064 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5065 }
5066
5067 // hlfmt main
5068
5069 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5070 {
5071 switch (hashfile_format)
5072 {
5073 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5074 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5075 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5076 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5077 }
5078 }
5079
5080 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5081 {
5082 switch (hashfile_format)
5083 {
5084 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5085 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5086 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5087 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5088 }
5089 }
5090
5091 char *strhlfmt (const uint hashfile_format)
5092 {
5093 switch (hashfile_format)
5094 {
5095 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5096 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5097 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5098 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5099 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5100 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5101 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5102 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5103 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5104 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5105 }
5106
5107 return ((char *) "Unknown");
5108 }
5109
5110 static uint hlfmt_detect (FILE *fp, uint max_check)
5111 {
5112 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5113
5114 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5115 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5116
5117 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5118
5119 uint num_check = 0;
5120
5121 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5122
5123 while (!feof (fp))
5124 {
5125 int line_len = fgetl (fp, line_buf);
5126
5127 if (line_len == 0) continue;
5128
5129 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5130 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5131 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5132
5133 if (num_check == max_check) break;
5134
5135 num_check++;
5136 }
5137
5138 myfree (line_buf);
5139
5140 uint hashlist_format = HLFMT_HASHCAT;
5141
5142 for (int i = 1; i < HLFMTS_CNT; i++)
5143 {
5144 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5145
5146 hashlist_format = i;
5147 }
5148
5149 free (formats_cnt);
5150
5151 return hashlist_format;
5152 }
5153
5154 /**
5155 * some further helper function
5156 */
5157
5158 // wrapper around mymalloc for ADL
5159
5160 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5161 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5162 {
5163 return mymalloc (iSize);
5164 }
5165 #endif
5166
5167 static uint generate_bitmaps (const uint digests_cnt, const uint dgst_size, const uint dgst_shifts, char *digests_buf_ptr, const uint bitmap_mask, const uint bitmap_size, uint *bitmap_a, uint *bitmap_b, uint *bitmap_c, uint *bitmap_d, const u64 collisions_max)
5168 {
5169 u64 collisions = 0;
5170
5171 const uint dgst_pos0 = data.dgst_pos0;
5172 const uint dgst_pos1 = data.dgst_pos1;
5173 const uint dgst_pos2 = data.dgst_pos2;
5174 const uint dgst_pos3 = data.dgst_pos3;
5175
5176 memset (bitmap_a, 0, bitmap_size);
5177 memset (bitmap_b, 0, bitmap_size);
5178 memset (bitmap_c, 0, bitmap_size);
5179 memset (bitmap_d, 0, bitmap_size);
5180
5181 for (uint i = 0; i < digests_cnt; i++)
5182 {
5183 uint *digest_ptr = (uint *) digests_buf_ptr;
5184
5185 digests_buf_ptr += dgst_size;
5186
5187 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5188 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5189 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5190 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5191
5192 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5193 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5194 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5195 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5196
5197 if (bitmap_a[idx0] & val0) collisions++;
5198 if (bitmap_b[idx1] & val1) collisions++;
5199 if (bitmap_c[idx2] & val2) collisions++;
5200 if (bitmap_d[idx3] & val3) collisions++;
5201
5202 bitmap_a[idx0] |= val0;
5203 bitmap_b[idx1] |= val1;
5204 bitmap_c[idx2] |= val2;
5205 bitmap_d[idx3] |= val3;
5206
5207 if (collisions >= collisions_max) return 0x7fffffff;
5208 }
5209
5210 return collisions;
5211 }
5212
5213 /**
5214 * main
5215 */
5216
5217 int main (int argc, char **argv)
5218 {
5219 /**
5220 * To help users a bit
5221 */
5222
5223 char *compute = getenv ("COMPUTE");
5224
5225 if (compute)
5226 {
5227 static char display[100];
5228
5229 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5230
5231 putenv (display);
5232 }
5233 else
5234 {
5235 if (getenv ("DISPLAY") == NULL)
5236 putenv ((char *) "DISPLAY=:0");
5237 }
5238
5239 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5240 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5241
5242 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5243 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5244
5245 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5246 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5247
5248 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5249 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5250
5251 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5252 putenv ((char *) "POCL_KERNEL_CACHE=0");
5253
5254 umask (077);
5255
5256 /**
5257 * Real init
5258 */
5259
5260 memset (&data, 0, sizeof (hc_global_data_t));
5261
5262 time_t proc_start;
5263
5264 time (&proc_start);
5265
5266 data.proc_start = proc_start;
5267
5268 int myargc = argc;
5269 char **myargv = argv;
5270
5271 hc_thread_mutex_init (mux_dispatcher);
5272 hc_thread_mutex_init (mux_counter);
5273 hc_thread_mutex_init (mux_display);
5274 hc_thread_mutex_init (mux_adl);
5275
5276 /**
5277 * commandline parameters
5278 */
5279
5280 uint usage = USAGE;
5281 uint version = VERSION;
5282 uint quiet = QUIET;
5283 uint benchmark = BENCHMARK;
5284 uint show = SHOW;
5285 uint left = LEFT;
5286 uint username = USERNAME;
5287 uint remove = REMOVE;
5288 uint remove_timer = REMOVE_TIMER;
5289 u64 skip = SKIP;
5290 u64 limit = LIMIT;
5291 uint keyspace = KEYSPACE;
5292 uint potfile_disable = POTFILE_DISABLE;
5293 char *potfile_path = NULL;
5294 uint debug_mode = DEBUG_MODE;
5295 char *debug_file = NULL;
5296 char *induction_dir = NULL;
5297 char *outfile_check_dir = NULL;
5298 uint force = FORCE;
5299 uint runtime = RUNTIME;
5300 uint hash_mode = HASH_MODE;
5301 uint attack_mode = ATTACK_MODE;
5302 uint markov_disable = MARKOV_DISABLE;
5303 uint markov_classic = MARKOV_CLASSIC;
5304 uint markov_threshold = MARKOV_THRESHOLD;
5305 char *markov_hcstat = NULL;
5306 char *outfile = NULL;
5307 uint outfile_format = OUTFILE_FORMAT;
5308 uint outfile_autohex = OUTFILE_AUTOHEX;
5309 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5310 uint restore = RESTORE;
5311 uint restore_timer = RESTORE_TIMER;
5312 uint restore_disable = RESTORE_DISABLE;
5313 uint status = STATUS;
5314 uint status_timer = STATUS_TIMER;
5315 uint status_automat = STATUS_AUTOMAT;
5316 uint loopback = LOOPBACK;
5317 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5318 char *session = NULL;
5319 uint hex_charset = HEX_CHARSET;
5320 uint hex_salt = HEX_SALT;
5321 uint hex_wordlist = HEX_WORDLIST;
5322 uint rp_gen = RP_GEN;
5323 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5324 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5325 uint rp_gen_seed = RP_GEN_SEED;
5326 char *rule_buf_l = (char *) RULE_BUF_L;
5327 char *rule_buf_r = (char *) RULE_BUF_R;
5328 uint increment = INCREMENT;
5329 uint increment_min = INCREMENT_MIN;
5330 uint increment_max = INCREMENT_MAX;
5331 char *cpu_affinity = NULL;
5332 OCL_PTR *ocl = NULL;
5333 char *opencl_devices = NULL;
5334 char *opencl_platforms = NULL;
5335 char *opencl_device_types = NULL;
5336 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5337 char *truecrypt_keyfiles = NULL;
5338 uint workload_profile = WORKLOAD_PROFILE;
5339 uint kernel_accel = KERNEL_ACCEL;
5340 uint kernel_loops = KERNEL_LOOPS;
5341 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5342 #ifdef HAVE_HWMON
5343 uint gpu_temp_abort = GPU_TEMP_ABORT;
5344 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5345 #ifdef HAVE_ADL
5346 uint powertune_enable = POWERTUNE_ENABLE;
5347 #endif
5348 #endif
5349 uint logfile_disable = LOGFILE_DISABLE;
5350 uint segment_size = SEGMENT_SIZE;
5351 uint scrypt_tmto = SCRYPT_TMTO;
5352 char separator = SEPARATOR;
5353 uint bitmap_min = BITMAP_MIN;
5354 uint bitmap_max = BITMAP_MAX;
5355 char *custom_charset_1 = NULL;
5356 char *custom_charset_2 = NULL;
5357 char *custom_charset_3 = NULL;
5358 char *custom_charset_4 = NULL;
5359
5360 #define IDX_HELP 'h'
5361 #define IDX_VERSION 'V'
5362 #define IDX_VERSION_LOWER 'v'
5363 #define IDX_QUIET 0xff02
5364 #define IDX_SHOW 0xff03
5365 #define IDX_LEFT 0xff04
5366 #define IDX_REMOVE 0xff05
5367 #define IDX_REMOVE_TIMER 0xff37
5368 #define IDX_SKIP 's'
5369 #define IDX_LIMIT 'l'
5370 #define IDX_KEYSPACE 0xff35
5371 #define IDX_POTFILE_DISABLE 0xff06
5372 #define IDX_POTFILE_PATH 0xffe0
5373 #define IDX_DEBUG_MODE 0xff43
5374 #define IDX_DEBUG_FILE 0xff44
5375 #define IDX_INDUCTION_DIR 0xff46
5376 #define IDX_OUTFILE_CHECK_DIR 0xff47
5377 #define IDX_USERNAME 0xff07
5378 #define IDX_FORCE 0xff08
5379 #define IDX_RUNTIME 0xff09
5380 #define IDX_BENCHMARK 'b'
5381 #define IDX_HASH_MODE 'm'
5382 #define IDX_ATTACK_MODE 'a'
5383 #define IDX_RP_FILE 'r'
5384 #define IDX_RP_GEN 'g'
5385 #define IDX_RP_GEN_FUNC_MIN 0xff10
5386 #define IDX_RP_GEN_FUNC_MAX 0xff11
5387 #define IDX_RP_GEN_SEED 0xff34
5388 #define IDX_RULE_BUF_L 'j'
5389 #define IDX_RULE_BUF_R 'k'
5390 #define IDX_INCREMENT 'i'
5391 #define IDX_INCREMENT_MIN 0xff12
5392 #define IDX_INCREMENT_MAX 0xff13
5393 #define IDX_OUTFILE 'o'
5394 #define IDX_OUTFILE_FORMAT 0xff14
5395 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5396 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5397 #define IDX_RESTORE 0xff15
5398 #define IDX_RESTORE_DISABLE 0xff27
5399 #define IDX_STATUS 0xff17
5400 #define IDX_STATUS_TIMER 0xff18
5401 #define IDX_STATUS_AUTOMAT 0xff50
5402 #define IDX_LOOPBACK 0xff38
5403 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5404 #define IDX_SESSION 0xff19
5405 #define IDX_HEX_CHARSET 0xff20
5406 #define IDX_HEX_SALT 0xff21
5407 #define IDX_HEX_WORDLIST 0xff40
5408 #define IDX_MARKOV_DISABLE 0xff22
5409 #define IDX_MARKOV_CLASSIC 0xff23
5410 #define IDX_MARKOV_THRESHOLD 't'
5411 #define IDX_MARKOV_HCSTAT 0xff24
5412 #define IDX_CPU_AFFINITY 0xff25
5413 #define IDX_OPENCL_DEVICES 'd'
5414 #define IDX_OPENCL_PLATFORMS 0xff72
5415 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5416 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5417 #define IDX_WORKLOAD_PROFILE 'w'
5418 #define IDX_KERNEL_ACCEL 'n'
5419 #define IDX_KERNEL_LOOPS 'u'
5420 #define IDX_GPU_TEMP_DISABLE 0xff29
5421 #define IDX_GPU_TEMP_ABORT 0xff30
5422 #define IDX_GPU_TEMP_RETAIN 0xff31
5423 #define IDX_POWERTUNE_ENABLE 0xff41
5424 #define IDX_LOGFILE_DISABLE 0xff51
5425 #define IDX_TRUECRYPT_KEYFILES 0xff52
5426 #define IDX_SCRYPT_TMTO 0xff61
5427 #define IDX_SEGMENT_SIZE 'c'
5428 #define IDX_SEPARATOR 'p'
5429 #define IDX_BITMAP_MIN 0xff70
5430 #define IDX_BITMAP_MAX 0xff71
5431 #define IDX_CUSTOM_CHARSET_1 '1'
5432 #define IDX_CUSTOM_CHARSET_2 '2'
5433 #define IDX_CUSTOM_CHARSET_3 '3'
5434 #define IDX_CUSTOM_CHARSET_4 '4'
5435
5436 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5437
5438 struct option long_options[] =
5439 {
5440 {"help", no_argument, 0, IDX_HELP},
5441 {"version", no_argument, 0, IDX_VERSION},
5442 {"quiet", no_argument, 0, IDX_QUIET},
5443 {"show", no_argument, 0, IDX_SHOW},
5444 {"left", no_argument, 0, IDX_LEFT},
5445 {"username", no_argument, 0, IDX_USERNAME},
5446 {"remove", no_argument, 0, IDX_REMOVE},
5447 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5448 {"skip", required_argument, 0, IDX_SKIP},
5449 {"limit", required_argument, 0, IDX_LIMIT},
5450 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5451 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5452 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5453 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5454 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5455 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5456 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5457 {"force", no_argument, 0, IDX_FORCE},
5458 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5459 {"restore", no_argument, 0, IDX_RESTORE},
5460 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5461 {"status", no_argument, 0, IDX_STATUS},
5462 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5463 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5464 {"loopback", no_argument, 0, IDX_LOOPBACK},
5465 {"weak-hash-threshold",
5466 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5467 {"session", required_argument, 0, IDX_SESSION},
5468 {"runtime", required_argument, 0, IDX_RUNTIME},
5469 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5470 {"generate-rules-func-min",
5471 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5472 {"generate-rules-func-max",
5473 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5474 {"generate-rules-seed",
5475 required_argument, 0, IDX_RP_GEN_SEED},
5476 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5477 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5478 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5479 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5480 {"rules-file", required_argument, 0, IDX_RP_FILE},
5481 {"outfile", required_argument, 0, IDX_OUTFILE},
5482 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5483 {"outfile-autohex-disable",
5484 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5485 {"outfile-check-timer",
5486 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5487 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5488 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5489 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5490 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5491 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5492 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5493 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5494 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5495 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5496 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5497 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5498 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5499 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5500 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5501 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5502 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5503 #ifdef HAVE_HWMON
5504 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5505 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5506 #ifdef HAVE_ADL
5507 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5508 #endif
5509 #endif // HAVE_HWMON
5510 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5511 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5512 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5513 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5514 // deprecated
5515 {"seperator", required_argument, 0, IDX_SEPARATOR},
5516 {"separator", required_argument, 0, IDX_SEPARATOR},
5517 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5518 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5519 {"increment", no_argument, 0, IDX_INCREMENT},
5520 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5521 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5522 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5523 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5524 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5525 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5526
5527 {0, 0, 0, 0}
5528 };
5529
5530 uint rp_files_cnt = 0;
5531
5532 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5533
5534 int option_index = 0;
5535 int c = -1;
5536
5537 optind = 1;
5538 optopt = 0;
5539
5540 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5541 {
5542 switch (c)
5543 {
5544 case IDX_HELP: usage = 1; break;
5545 case IDX_VERSION:
5546 case IDX_VERSION_LOWER: version = 1; break;
5547 case IDX_RESTORE: restore = 1; break;
5548 case IDX_SESSION: session = optarg; break;
5549 case IDX_SHOW: show = 1; break;
5550 case IDX_LEFT: left = 1; break;
5551 case '?': return (-1);
5552 }
5553 }
5554
5555 if (optopt != 0)
5556 {
5557 log_error ("ERROR: Invalid argument specified");
5558
5559 return (-1);
5560 }
5561
5562 /**
5563 * exit functions
5564 */
5565
5566 if (version)
5567 {
5568 log_info ("%s", VERSION_TAG);
5569
5570 return (0);
5571 }
5572
5573 if (usage)
5574 {
5575 usage_big_print (PROGNAME);
5576
5577 return (0);
5578 }
5579
5580 /**
5581 * session needs to be set, always!
5582 */
5583
5584 if (session == NULL) session = (char *) PROGNAME;
5585
5586 /**
5587 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5588 */
5589
5590 char *exec_path = get_exec_path ();
5591
5592 #ifdef LINUX
5593
5594 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5595 char *resolved_exec_path = realpath (exec_path, NULL);
5596
5597 char *install_dir = get_install_dir (resolved_exec_path);
5598 char *profile_dir = NULL;
5599 char *session_dir = NULL;
5600 char *shared_dir = NULL;
5601
5602 if (strcmp (install_dir, resolved_install_folder) == 0)
5603 {
5604 struct passwd *pw = getpwuid (getuid ());
5605
5606 const char *homedir = pw->pw_dir;
5607
5608 profile_dir = get_profile_dir (homedir);
5609 session_dir = get_session_dir (profile_dir);
5610 shared_dir = strdup (SHARED_FOLDER);
5611
5612 mkdir (profile_dir, 0700);
5613 mkdir (session_dir, 0700);
5614 }
5615 else
5616 {
5617 profile_dir = install_dir;
5618 session_dir = install_dir;
5619 shared_dir = install_dir;
5620 }
5621
5622 myfree (resolved_install_folder);
5623 myfree (resolved_exec_path);
5624
5625 #else
5626
5627 char *install_dir = get_install_dir (exec_path);
5628 char *profile_dir = install_dir;
5629 char *session_dir = install_dir;
5630 char *shared_dir = install_dir;
5631
5632 #endif
5633
5634 data.install_dir = install_dir;
5635 data.profile_dir = profile_dir;
5636 data.session_dir = session_dir;
5637 data.shared_dir = shared_dir;
5638
5639 myfree (exec_path);
5640
5641 /**
5642 * kernel cache, we need to make sure folder exist
5643 */
5644
5645 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5646
5647 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5648
5649 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5650
5651 mkdir (kernels_folder, 0700);
5652
5653 myfree (kernels_folder);
5654
5655 /**
5656 * session
5657 */
5658
5659 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5660
5661 data.session = session;
5662
5663 char *eff_restore_file = (char *) mymalloc (session_size);
5664 char *new_restore_file = (char *) mymalloc (session_size);
5665
5666 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5667 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5668
5669 data.eff_restore_file = eff_restore_file;
5670 data.new_restore_file = new_restore_file;
5671
5672 if (((show == 1) || (left == 1)) && (restore == 1))
5673 {
5674 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5675 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5676
5677 return (-1);
5678 }
5679
5680 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5681 if ((show == 1) || (left == 1))
5682 {
5683 restore_disable = 1;
5684
5685 restore = 0;
5686 }
5687
5688 data.restore_disable = restore_disable;
5689
5690 restore_data_t *rd = init_restore (argc, argv);
5691
5692 data.rd = rd;
5693
5694 /**
5695 * restore file
5696 */
5697
5698 if (restore == 1)
5699 {
5700 read_restore (eff_restore_file, rd);
5701
5702 if (rd->version_bin < RESTORE_MIN)
5703 {
5704 log_error ("ERROR: Incompatible restore-file version");
5705
5706 return (-1);
5707 }
5708
5709 myargc = rd->argc;
5710 myargv = rd->argv;
5711
5712 #ifdef _POSIX
5713 rd->pid = getpid ();
5714 #elif _WIN
5715 rd->pid = GetCurrentProcessId ();
5716 #endif
5717 }
5718
5719 uint hash_mode_chgd = 0;
5720 uint runtime_chgd = 0;
5721 uint kernel_loops_chgd = 0;
5722 uint kernel_accel_chgd = 0;
5723 uint attack_mode_chgd = 0;
5724 uint outfile_format_chgd = 0;
5725 uint rp_gen_seed_chgd = 0;
5726 uint remove_timer_chgd = 0;
5727 uint increment_min_chgd = 0;
5728 uint increment_max_chgd = 0;
5729 uint workload_profile_chgd = 0;
5730 uint opencl_vector_width_chgd = 0;
5731
5732 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5733 uint gpu_temp_retain_chgd = 0;
5734 uint gpu_temp_abort_chgd = 0;
5735 #endif
5736
5737 optind = 1;
5738 optopt = 0;
5739 option_index = 0;
5740
5741 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5742 {
5743 switch (c)
5744 {
5745 //case IDX_HELP: usage = 1; break;
5746 //case IDX_VERSION: version = 1; break;
5747 //case IDX_RESTORE: restore = 1; break;
5748 case IDX_QUIET: quiet = 1; break;
5749 //case IDX_SHOW: show = 1; break;
5750 case IDX_SHOW: break;
5751 //case IDX_LEFT: left = 1; break;
5752 case IDX_LEFT: break;
5753 case IDX_USERNAME: username = 1; break;
5754 case IDX_REMOVE: remove = 1; break;
5755 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5756 remove_timer_chgd = 1; break;
5757 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5758 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5759 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5760 case IDX_DEBUG_FILE: debug_file = optarg; break;
5761 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5762 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5763 case IDX_FORCE: force = 1; break;
5764 case IDX_SKIP: skip = atoll (optarg); break;
5765 case IDX_LIMIT: limit = atoll (optarg); break;
5766 case IDX_KEYSPACE: keyspace = 1; break;
5767 case IDX_BENCHMARK: benchmark = 1; break;
5768 case IDX_RESTORE: break;
5769 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5770 case IDX_STATUS: status = 1; break;
5771 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5772 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5773 case IDX_LOOPBACK: loopback = 1; break;
5774 case IDX_WEAK_HASH_THRESHOLD:
5775 weak_hash_threshold = atoi (optarg); break;
5776 //case IDX_SESSION: session = optarg; break;
5777 case IDX_SESSION: break;
5778 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5779 hash_mode_chgd = 1; break;
5780 case IDX_RUNTIME: runtime = atoi (optarg);
5781 runtime_chgd = 1; break;
5782 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5783 attack_mode_chgd = 1; break;
5784 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5785 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5786 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5787 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5788 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5789 rp_gen_seed_chgd = 1; break;
5790 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5791 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5792 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5793 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5794 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5795 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5796 case IDX_OUTFILE: outfile = optarg; break;
5797 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5798 outfile_format_chgd = 1; break;
5799 case IDX_OUTFILE_AUTOHEX_DISABLE:
5800 outfile_autohex = 0; break;
5801 case IDX_OUTFILE_CHECK_TIMER:
5802 outfile_check_timer = atoi (optarg); break;
5803 case IDX_HEX_CHARSET: hex_charset = 1; break;
5804 case IDX_HEX_SALT: hex_salt = 1; break;
5805 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5806 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5807 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5808 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5809 case IDX_OPENCL_DEVICE_TYPES:
5810 opencl_device_types = optarg; break;
5811 case IDX_OPENCL_VECTOR_WIDTH:
5812 opencl_vector_width = atoi (optarg);
5813 opencl_vector_width_chgd = 1; break;
5814 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5815 workload_profile_chgd = 1; break;
5816 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5817 kernel_accel_chgd = 1; break;
5818 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5819 kernel_loops_chgd = 1; break;
5820 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5821 #ifdef HAVE_HWMON
5822 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5823 #ifdef HAVE_ADL
5824 gpu_temp_abort_chgd = 1;
5825 #endif
5826 break;
5827 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5828 #ifdef HAVE_ADL
5829 gpu_temp_retain_chgd = 1;
5830 #endif
5831 break;
5832 #ifdef HAVE_ADL
5833 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5834 #endif
5835 #endif // HAVE_HWMON
5836 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5837 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5838 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5839 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5840 case IDX_SEPARATOR: separator = optarg[0]; break;
5841 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5842 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5843 case IDX_INCREMENT: increment = 1; break;
5844 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5845 increment_min_chgd = 1; break;
5846 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5847 increment_max_chgd = 1; break;
5848 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5849 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5850 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5851 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5852
5853 default:
5854 log_error ("ERROR: Invalid argument specified");
5855 return (-1);
5856 }
5857 }
5858
5859 if (optopt != 0)
5860 {
5861 log_error ("ERROR: Invalid argument specified");
5862
5863 return (-1);
5864 }
5865
5866 /**
5867 * Inform user things getting started,
5868 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5869 * - we do not need to check algorithm_pos
5870 */
5871
5872 if (quiet == 0)
5873 {
5874 if (benchmark == 1)
5875 {
5876 if (status_automat == 0)
5877 {
5878 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
5879 log_info ("");
5880 }
5881 else
5882 {
5883 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
5884 }
5885 }
5886 else if (restore == 1)
5887 {
5888 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
5889 log_info ("");
5890 }
5891 else
5892 {
5893 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
5894 log_info ("");
5895 }
5896 }
5897
5898 /**
5899 * sanity check
5900 */
5901
5902 if (attack_mode > 7)
5903 {
5904 log_error ("ERROR: Invalid attack-mode specified");
5905
5906 return (-1);
5907 }
5908
5909 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5910 {
5911 log_error ("ERROR: Invalid runtime specified");
5912
5913 return (-1);
5914 }
5915
5916 if (hash_mode_chgd && hash_mode > 13600) // just added to remove compiler warnings for hash_mode_chgd
5917 {
5918 log_error ("ERROR: Invalid hash-type specified");
5919
5920 return (-1);
5921 }
5922
5923 // renamed hash modes
5924
5925 if (hash_mode_chgd)
5926 {
5927 int n = -1;
5928
5929 switch (hash_mode)
5930 {
5931 case 123: n = 124;
5932 break;
5933 }
5934
5935 if (n >= 0)
5936 {
5937 log_error ("Old -m specified, use -m %d instead", n);
5938
5939 return (-1);
5940 }
5941 }
5942
5943 if (username == 1)
5944 {
5945 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5946 {
5947 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5948
5949 return (-1);
5950 }
5951 }
5952
5953 if (outfile_format > 16)
5954 {
5955 log_error ("ERROR: Invalid outfile-format specified");
5956
5957 return (-1);
5958 }
5959
5960 if (left == 1)
5961 {
5962 if (outfile_format_chgd == 1)
5963 {
5964 if (outfile_format > 1)
5965 {
5966 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5967
5968 return (-1);
5969 }
5970 }
5971 else
5972 {
5973 outfile_format = OUTFILE_FMT_HASH;
5974 }
5975 }
5976
5977 if (show == 1)
5978 {
5979 if (outfile_format_chgd == 1)
5980 {
5981 if ((outfile_format > 7) && (outfile_format < 16))
5982 {
5983 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5984
5985 return (-1);
5986 }
5987 }
5988 }
5989
5990 if (increment_min < INCREMENT_MIN)
5991 {
5992 log_error ("ERROR: Invalid increment-min specified");
5993
5994 return (-1);
5995 }
5996
5997 if (increment_max > INCREMENT_MAX)
5998 {
5999 log_error ("ERROR: Invalid increment-max specified");
6000
6001 return (-1);
6002 }
6003
6004 if (increment_min > increment_max)
6005 {
6006 log_error ("ERROR: Invalid increment-min specified");
6007
6008 return (-1);
6009 }
6010
6011 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6012 {
6013 log_error ("ERROR: increment is not allowed in attack-mode 0");
6014
6015 return (-1);
6016 }
6017
6018 if ((increment == 0) && (increment_min_chgd == 1))
6019 {
6020 log_error ("ERROR: increment-min is only supported together with increment switch");
6021
6022 return (-1);
6023 }
6024
6025 if ((increment == 0) && (increment_max_chgd == 1))
6026 {
6027 log_error ("ERROR: increment-max is only supported together with increment switch");
6028
6029 return (-1);
6030 }
6031
6032 if (rp_files_cnt && rp_gen)
6033 {
6034 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6035
6036 return (-1);
6037 }
6038
6039 if (rp_files_cnt || rp_gen)
6040 {
6041 if (attack_mode != ATTACK_MODE_STRAIGHT)
6042 {
6043 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6044
6045 return (-1);
6046 }
6047 }
6048
6049 if (rp_gen_func_min > rp_gen_func_max)
6050 {
6051 log_error ("ERROR: Invalid rp-gen-func-min specified");
6052
6053 return (-1);
6054 }
6055
6056 if (kernel_accel_chgd == 1)
6057 {
6058 if (kernel_accel < 1)
6059 {
6060 log_error ("ERROR: Invalid kernel-accel specified");
6061
6062 return (-1);
6063 }
6064
6065 if (kernel_accel > 1024)
6066 {
6067 log_error ("ERROR: Invalid kernel-accel specified");
6068
6069 return (-1);
6070 }
6071 }
6072
6073 if (kernel_loops_chgd == 1)
6074 {
6075 if (kernel_loops < 1)
6076 {
6077 log_error ("ERROR: Invalid kernel-loops specified");
6078
6079 return (-1);
6080 }
6081
6082 if (kernel_loops > 1024)
6083 {
6084 log_error ("ERROR: Invalid kernel-loops specified");
6085
6086 return (-1);
6087 }
6088 }
6089
6090 if ((workload_profile < 1) || (workload_profile > 3))
6091 {
6092 log_error ("ERROR: workload-profile %i not available", workload_profile);
6093
6094 return (-1);
6095 }
6096
6097 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6098 {
6099 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6100
6101 return (-1);
6102 }
6103
6104 if (show == 1 || left == 1)
6105 {
6106 attack_mode = ATTACK_MODE_NONE;
6107
6108 if (remove == 1)
6109 {
6110 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6111
6112 return (-1);
6113 }
6114
6115 if (potfile_disable == 1)
6116 {
6117 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6118
6119 return (-1);
6120 }
6121 }
6122
6123 uint attack_kern = ATTACK_KERN_NONE;
6124
6125 switch (attack_mode)
6126 {
6127 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6128 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6129 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6130 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6131 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6132 }
6133
6134 if (benchmark == 0)
6135 {
6136 if (keyspace == 1)
6137 {
6138 int num_additional_params = 1;
6139
6140 if (attack_kern == ATTACK_KERN_COMBI)
6141 {
6142 num_additional_params = 2;
6143 }
6144
6145 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6146
6147 if (keyspace_wordlist_specified == 0) optind--;
6148 }
6149
6150 if (attack_kern == ATTACK_KERN_NONE)
6151 {
6152 if ((optind + 1) != myargc)
6153 {
6154 usage_mini_print (myargv[0]);
6155
6156 return (-1);
6157 }
6158 }
6159 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6160 {
6161 if ((optind + 1) > myargc)
6162 {
6163 usage_mini_print (myargv[0]);
6164
6165 return (-1);
6166 }
6167 }
6168 else if (attack_kern == ATTACK_KERN_COMBI)
6169 {
6170 if ((optind + 3) != myargc)
6171 {
6172 usage_mini_print (myargv[0]);
6173
6174 return (-1);
6175 }
6176 }
6177 else if (attack_kern == ATTACK_KERN_BF)
6178 {
6179 if ((optind + 1) > myargc)
6180 {
6181 usage_mini_print (myargv[0]);
6182
6183 return (-1);
6184 }
6185 }
6186 else
6187 {
6188 usage_mini_print (myargv[0]);
6189
6190 return (-1);
6191 }
6192 }
6193 else
6194 {
6195 if (myargv[optind] != 0)
6196 {
6197 log_error ("ERROR: Invalid argument for benchmark mode specified");
6198
6199 return (-1);
6200 }
6201
6202 if (attack_mode_chgd == 1)
6203 {
6204 if (attack_mode != ATTACK_MODE_BF)
6205 {
6206 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6207
6208 return (-1);
6209 }
6210 }
6211 }
6212
6213 if (skip != 0 && limit != 0)
6214 {
6215 limit += skip;
6216 }
6217
6218 if (keyspace == 1)
6219 {
6220 if (show == 1)
6221 {
6222 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6223
6224 return (-1);
6225 }
6226 else if (left == 1)
6227 {
6228 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6229
6230 return (-1);
6231 }
6232
6233 potfile_disable = 1;
6234
6235 restore_disable = 1;
6236
6237 restore = 0;
6238
6239 weak_hash_threshold = 0;
6240
6241 quiet = 1;
6242 }
6243
6244 if (remove_timer_chgd == 1)
6245 {
6246 if (remove == 0)
6247 {
6248 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6249
6250 return (-1);
6251 }
6252
6253 if (remove_timer < 1)
6254 {
6255 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6256
6257 return (-1);
6258 }
6259 }
6260
6261 if (loopback == 1)
6262 {
6263 if (attack_mode == ATTACK_MODE_STRAIGHT)
6264 {
6265 if ((rp_files_cnt == 0) && (rp_gen == 0))
6266 {
6267 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6268
6269 return (-1);
6270 }
6271 }
6272 else
6273 {
6274 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6275
6276 return (-1);
6277 }
6278 }
6279
6280 if (debug_mode > 0)
6281 {
6282 if (attack_mode != ATTACK_MODE_STRAIGHT)
6283 {
6284 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6285
6286 return (-1);
6287 }
6288
6289 if ((rp_files_cnt == 0) && (rp_gen == 0))
6290 {
6291 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6292
6293 return (-1);
6294 }
6295 }
6296
6297 if (debug_mode > 4)
6298 {
6299 log_error ("ERROR: Invalid debug-mode specified");
6300
6301 return (-1);
6302 }
6303
6304 if (debug_file != NULL)
6305 {
6306 if (debug_mode < 1)
6307 {
6308 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6309
6310 return (-1);
6311 }
6312 }
6313
6314 if (induction_dir != NULL)
6315 {
6316 if (attack_mode == ATTACK_MODE_BF)
6317 {
6318 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6319
6320 return (-1);
6321 }
6322 }
6323
6324 if (attack_mode != ATTACK_MODE_STRAIGHT)
6325 {
6326 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6327 {
6328 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6329
6330 return (-1);
6331 }
6332
6333 weak_hash_threshold = 0;
6334 }
6335
6336 /**
6337 * induction directory
6338 */
6339
6340 char *induction_directory = NULL;
6341
6342 if (attack_mode != ATTACK_MODE_BF)
6343 {
6344 if (induction_dir == NULL)
6345 {
6346 induction_directory = (char *) mymalloc (session_size);
6347
6348 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6349
6350 // create induction folder if it does not already exist
6351
6352 if (keyspace == 0)
6353 {
6354 if (rmdir (induction_directory) == -1)
6355 {
6356 if (errno == ENOENT)
6357 {
6358 // good, we can ignore
6359 }
6360 else if (errno == ENOTEMPTY)
6361 {
6362 char *induction_directory_mv = (char *) mymalloc (session_size);
6363
6364 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6365
6366 if (rename (induction_directory, induction_directory_mv) != 0)
6367 {
6368 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6369
6370 return (-1);
6371 }
6372 }
6373 else
6374 {
6375 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6376
6377 return (-1);
6378 }
6379 }
6380
6381 if (mkdir (induction_directory, 0700) == -1)
6382 {
6383 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6384
6385 return (-1);
6386 }
6387 }
6388 }
6389 else
6390 {
6391 induction_directory = induction_dir;
6392 }
6393 }
6394
6395 data.induction_directory = induction_directory;
6396
6397 /**
6398 * loopback
6399 */
6400
6401 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6402
6403 char *loopback_file = (char *) mymalloc (loopback_size);
6404
6405 /**
6406 * tuning db
6407 */
6408
6409 char tuning_db_file[256] = { 0 };
6410
6411 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6412
6413 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6414
6415 /**
6416 * outfile-check directory
6417 */
6418
6419 char *outfile_check_directory = NULL;
6420
6421 if (outfile_check_dir == NULL)
6422 {
6423 outfile_check_directory = (char *) mymalloc (session_size);
6424
6425 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6426 }
6427 else
6428 {
6429 outfile_check_directory = outfile_check_dir;
6430 }
6431
6432 data.outfile_check_directory = outfile_check_directory;
6433
6434 if (keyspace == 0)
6435 {
6436 struct stat outfile_check_stat;
6437
6438 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6439 {
6440 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6441
6442 if (is_dir == 0)
6443 {
6444 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6445
6446 return (-1);
6447 }
6448 }
6449 else if (outfile_check_dir == NULL)
6450 {
6451 if (mkdir (outfile_check_directory, 0700) == -1)
6452 {
6453 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6454
6455 return (-1);
6456 }
6457 }
6458 }
6459
6460 /**
6461 * special other stuff
6462 */
6463
6464 if (hash_mode == 9710)
6465 {
6466 outfile_format = 5;
6467 outfile_format_chgd = 1;
6468 }
6469
6470 if (hash_mode == 9810)
6471 {
6472 outfile_format = 5;
6473 outfile_format_chgd = 1;
6474 }
6475
6476 if (hash_mode == 10410)
6477 {
6478 outfile_format = 5;
6479 outfile_format_chgd = 1;
6480 }
6481
6482 /**
6483 * store stuff
6484 */
6485
6486 data.hash_mode = hash_mode;
6487 data.restore = restore;
6488 data.restore_timer = restore_timer;
6489 data.restore_disable = restore_disable;
6490 data.status = status;
6491 data.status_timer = status_timer;
6492 data.status_automat = status_automat;
6493 data.loopback = loopback;
6494 data.runtime = runtime;
6495 data.remove = remove;
6496 data.remove_timer = remove_timer;
6497 data.debug_mode = debug_mode;
6498 data.debug_file = debug_file;
6499 data.username = username;
6500 data.quiet = quiet;
6501 data.outfile = outfile;
6502 data.outfile_format = outfile_format;
6503 data.outfile_autohex = outfile_autohex;
6504 data.hex_charset = hex_charset;
6505 data.hex_salt = hex_salt;
6506 data.hex_wordlist = hex_wordlist;
6507 data.separator = separator;
6508 data.rp_files = rp_files;
6509 data.rp_files_cnt = rp_files_cnt;
6510 data.rp_gen = rp_gen;
6511 data.rp_gen_seed = rp_gen_seed;
6512 data.force = force;
6513 data.benchmark = benchmark;
6514 data.skip = skip;
6515 data.limit = limit;
6516 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6517 data.powertune_enable = powertune_enable;
6518 #endif
6519 data.logfile_disable = logfile_disable;
6520 data.truecrypt_keyfiles = truecrypt_keyfiles;
6521 data.scrypt_tmto = scrypt_tmto;
6522 data.workload_profile = workload_profile;
6523
6524 /**
6525 * cpu affinity
6526 */
6527
6528 if (cpu_affinity)
6529 {
6530 set_cpu_affinity (cpu_affinity);
6531 }
6532
6533 if (rp_gen_seed_chgd == 0)
6534 {
6535 srand (proc_start);
6536 }
6537 else
6538 {
6539 srand (rp_gen_seed);
6540 }
6541
6542 /**
6543 * logfile init
6544 */
6545
6546 if (logfile_disable == 0)
6547 {
6548 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6549
6550 char *logfile = (char *) mymalloc (logfile_size);
6551
6552 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6553
6554 data.logfile = logfile;
6555
6556 char *topid = logfile_generate_topid ();
6557
6558 data.topid = topid;
6559 }
6560
6561 // logfile_append() checks for logfile_disable internally to make it easier from here
6562
6563 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6564 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6565 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6566 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6567 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6568 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6569 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6570 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6571 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6572 #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));
6573
6574 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6575 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6576 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6577 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6578 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6579 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6580 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6581 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6582
6583 logfile_top_msg ("START");
6584
6585 logfile_top_uint (attack_mode);
6586 logfile_top_uint (attack_kern);
6587 logfile_top_uint (benchmark);
6588 logfile_top_uint (bitmap_min);
6589 logfile_top_uint (bitmap_max);
6590 logfile_top_uint (debug_mode);
6591 logfile_top_uint (force);
6592 logfile_top_uint (kernel_accel);
6593 logfile_top_uint (kernel_loops);
6594 logfile_top_uint (gpu_temp_disable);
6595 #ifdef HAVE_HWMON
6596 logfile_top_uint (gpu_temp_abort);
6597 logfile_top_uint (gpu_temp_retain);
6598 #endif
6599 logfile_top_uint (hash_mode);
6600 logfile_top_uint (hex_charset);
6601 logfile_top_uint (hex_salt);
6602 logfile_top_uint (hex_wordlist);
6603 logfile_top_uint (increment);
6604 logfile_top_uint (increment_max);
6605 logfile_top_uint (increment_min);
6606 logfile_top_uint (keyspace);
6607 logfile_top_uint (left);
6608 logfile_top_uint (logfile_disable);
6609 logfile_top_uint (loopback);
6610 logfile_top_uint (markov_classic);
6611 logfile_top_uint (markov_disable);
6612 logfile_top_uint (markov_threshold);
6613 logfile_top_uint (outfile_autohex);
6614 logfile_top_uint (outfile_check_timer);
6615 logfile_top_uint (outfile_format);
6616 logfile_top_uint (potfile_disable);
6617 logfile_top_string (potfile_path);
6618 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6619 logfile_top_uint (powertune_enable);
6620 #endif
6621 logfile_top_uint (scrypt_tmto);
6622 logfile_top_uint (quiet);
6623 logfile_top_uint (remove);
6624 logfile_top_uint (remove_timer);
6625 logfile_top_uint (restore);
6626 logfile_top_uint (restore_disable);
6627 logfile_top_uint (restore_timer);
6628 logfile_top_uint (rp_gen);
6629 logfile_top_uint (rp_gen_func_max);
6630 logfile_top_uint (rp_gen_func_min);
6631 logfile_top_uint (rp_gen_seed);
6632 logfile_top_uint (runtime);
6633 logfile_top_uint (segment_size);
6634 logfile_top_uint (show);
6635 logfile_top_uint (status);
6636 logfile_top_uint (status_automat);
6637 logfile_top_uint (status_timer);
6638 logfile_top_uint (usage);
6639 logfile_top_uint (username);
6640 logfile_top_uint (version);
6641 logfile_top_uint (weak_hash_threshold);
6642 logfile_top_uint (workload_profile);
6643 logfile_top_uint64 (limit);
6644 logfile_top_uint64 (skip);
6645 logfile_top_char (separator);
6646 logfile_top_string (cpu_affinity);
6647 logfile_top_string (custom_charset_1);
6648 logfile_top_string (custom_charset_2);
6649 logfile_top_string (custom_charset_3);
6650 logfile_top_string (custom_charset_4);
6651 logfile_top_string (debug_file);
6652 logfile_top_string (opencl_devices);
6653 logfile_top_string (opencl_platforms);
6654 logfile_top_string (opencl_device_types);
6655 logfile_top_uint (opencl_vector_width);
6656 logfile_top_string (induction_dir);
6657 logfile_top_string (markov_hcstat);
6658 logfile_top_string (outfile);
6659 logfile_top_string (outfile_check_dir);
6660 logfile_top_string (rule_buf_l);
6661 logfile_top_string (rule_buf_r);
6662 logfile_top_string (session);
6663 logfile_top_string (truecrypt_keyfiles);
6664
6665 /**
6666 * Init OpenCL library loader
6667 */
6668
6669 if (keyspace == 0)
6670 {
6671 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6672
6673 ocl_init (ocl);
6674
6675 data.ocl = ocl;
6676 }
6677
6678 /**
6679 * OpenCL platform selection
6680 */
6681
6682 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6683
6684 /**
6685 * OpenCL device selection
6686 */
6687
6688 u32 devices_filter = setup_devices_filter (opencl_devices);
6689
6690 /**
6691 * OpenCL device type selection
6692 */
6693
6694 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6695
6696 /**
6697 * benchmark
6698 */
6699
6700 if (benchmark == 1)
6701 {
6702 /**
6703 * disable useless stuff for benchmark
6704 */
6705
6706 status_timer = 0;
6707 restore_timer = 0;
6708 restore_disable = 1;
6709 potfile_disable = 1;
6710 weak_hash_threshold = 0;
6711 gpu_temp_disable = 1;
6712
6713 data.status_timer = status_timer;
6714 data.restore_timer = restore_timer;
6715 data.restore_disable = restore_disable;
6716
6717 /**
6718 * force attack mode to be bruteforce
6719 */
6720
6721 attack_mode = ATTACK_MODE_BF;
6722 attack_kern = ATTACK_KERN_BF;
6723
6724 if (workload_profile_chgd == 0)
6725 {
6726 workload_profile = 3;
6727
6728 data.workload_profile = workload_profile;
6729 }
6730 }
6731
6732 /**
6733 * config
6734 */
6735
6736 uint hash_type = 0;
6737 uint salt_type = 0;
6738 uint attack_exec = 0;
6739 uint opts_type = 0;
6740 uint kern_type = 0;
6741 uint dgst_size = 0;
6742 uint esalt_size = 0;
6743 uint opti_type = 0;
6744 uint dgst_pos0 = -1;
6745 uint dgst_pos1 = -1;
6746 uint dgst_pos2 = -1;
6747 uint dgst_pos3 = -1;
6748
6749 int (*parse_func) (char *, uint, hash_t *);
6750 int (*sort_by_digest) (const void *, const void *);
6751
6752 uint algorithm_pos = 0;
6753 uint algorithm_max = 1;
6754
6755 uint *algorithms = default_benchmark_algorithms;
6756
6757 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6758
6759 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6760 {
6761 /*
6762 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6763 * the following algos are skipped entirely
6764 */
6765
6766 if (algorithm_pos > 0)
6767 {
6768 local_free (rd);
6769
6770 rd = init_restore (argc, argv);
6771
6772 data.rd = rd;
6773 }
6774
6775 /**
6776 * update hash_mode in case of multihash benchmark
6777 */
6778
6779 if (benchmark == 1)
6780 {
6781 if (hash_mode_chgd == 0)
6782 {
6783 hash_mode = algorithms[algorithm_pos];
6784
6785 data.hash_mode = hash_mode;
6786 }
6787
6788 quiet = 1;
6789
6790 data.quiet = quiet;
6791 }
6792
6793 switch (hash_mode)
6794 {
6795 case 0: hash_type = HASH_TYPE_MD5;
6796 salt_type = SALT_TYPE_NONE;
6797 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6798 opts_type = OPTS_TYPE_PT_GENERATE_LE
6799 | OPTS_TYPE_PT_ADD80
6800 | OPTS_TYPE_PT_ADDBITS14;
6801 kern_type = KERN_TYPE_MD5;
6802 dgst_size = DGST_SIZE_4_4;
6803 parse_func = md5_parse_hash;
6804 sort_by_digest = sort_by_digest_4_4;
6805 opti_type = OPTI_TYPE_ZERO_BYTE
6806 | OPTI_TYPE_PRECOMPUTE_INIT
6807 | OPTI_TYPE_PRECOMPUTE_MERKLE
6808 | OPTI_TYPE_MEET_IN_MIDDLE
6809 | OPTI_TYPE_EARLY_SKIP
6810 | OPTI_TYPE_NOT_ITERATED
6811 | OPTI_TYPE_NOT_SALTED
6812 | OPTI_TYPE_RAW_HASH;
6813 dgst_pos0 = 0;
6814 dgst_pos1 = 3;
6815 dgst_pos2 = 2;
6816 dgst_pos3 = 1;
6817 break;
6818
6819 case 10: hash_type = HASH_TYPE_MD5;
6820 salt_type = SALT_TYPE_INTERN;
6821 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6822 opts_type = OPTS_TYPE_PT_GENERATE_LE
6823 | OPTS_TYPE_ST_ADD80
6824 | OPTS_TYPE_ST_ADDBITS14;
6825 kern_type = KERN_TYPE_MD5_PWSLT;
6826 dgst_size = DGST_SIZE_4_4;
6827 parse_func = md5s_parse_hash;
6828 sort_by_digest = sort_by_digest_4_4;
6829 opti_type = OPTI_TYPE_ZERO_BYTE
6830 | OPTI_TYPE_PRECOMPUTE_INIT
6831 | OPTI_TYPE_PRECOMPUTE_MERKLE
6832 | OPTI_TYPE_MEET_IN_MIDDLE
6833 | OPTI_TYPE_EARLY_SKIP
6834 | OPTI_TYPE_NOT_ITERATED
6835 | OPTI_TYPE_APPENDED_SALT
6836 | OPTI_TYPE_RAW_HASH;
6837 dgst_pos0 = 0;
6838 dgst_pos1 = 3;
6839 dgst_pos2 = 2;
6840 dgst_pos3 = 1;
6841 break;
6842
6843 case 11: hash_type = HASH_TYPE_MD5;
6844 salt_type = SALT_TYPE_INTERN;
6845 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6846 opts_type = OPTS_TYPE_PT_GENERATE_LE
6847 | OPTS_TYPE_ST_ADD80
6848 | OPTS_TYPE_ST_ADDBITS14;
6849 kern_type = KERN_TYPE_MD5_PWSLT;
6850 dgst_size = DGST_SIZE_4_4;
6851 parse_func = joomla_parse_hash;
6852 sort_by_digest = sort_by_digest_4_4;
6853 opti_type = OPTI_TYPE_ZERO_BYTE
6854 | OPTI_TYPE_PRECOMPUTE_INIT
6855 | OPTI_TYPE_PRECOMPUTE_MERKLE
6856 | OPTI_TYPE_MEET_IN_MIDDLE
6857 | OPTI_TYPE_EARLY_SKIP
6858 | OPTI_TYPE_NOT_ITERATED
6859 | OPTI_TYPE_APPENDED_SALT
6860 | OPTI_TYPE_RAW_HASH;
6861 dgst_pos0 = 0;
6862 dgst_pos1 = 3;
6863 dgst_pos2 = 2;
6864 dgst_pos3 = 1;
6865 break;
6866
6867 case 12: hash_type = HASH_TYPE_MD5;
6868 salt_type = SALT_TYPE_INTERN;
6869 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6870 opts_type = OPTS_TYPE_PT_GENERATE_LE
6871 | OPTS_TYPE_ST_ADD80
6872 | OPTS_TYPE_ST_ADDBITS14;
6873 kern_type = KERN_TYPE_MD5_PWSLT;
6874 dgst_size = DGST_SIZE_4_4;
6875 parse_func = postgresql_parse_hash;
6876 sort_by_digest = sort_by_digest_4_4;
6877 opti_type = OPTI_TYPE_ZERO_BYTE
6878 | OPTI_TYPE_PRECOMPUTE_INIT
6879 | OPTI_TYPE_PRECOMPUTE_MERKLE
6880 | OPTI_TYPE_MEET_IN_MIDDLE
6881 | OPTI_TYPE_EARLY_SKIP
6882 | OPTI_TYPE_NOT_ITERATED
6883 | OPTI_TYPE_APPENDED_SALT
6884 | OPTI_TYPE_RAW_HASH;
6885 dgst_pos0 = 0;
6886 dgst_pos1 = 3;
6887 dgst_pos2 = 2;
6888 dgst_pos3 = 1;
6889 break;
6890
6891 case 20: hash_type = HASH_TYPE_MD5;
6892 salt_type = SALT_TYPE_INTERN;
6893 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6894 opts_type = OPTS_TYPE_PT_GENERATE_LE
6895 | OPTS_TYPE_PT_ADD80
6896 | OPTS_TYPE_PT_ADDBITS14;
6897 kern_type = KERN_TYPE_MD5_SLTPW;
6898 dgst_size = DGST_SIZE_4_4;
6899 parse_func = md5s_parse_hash;
6900 sort_by_digest = sort_by_digest_4_4;
6901 opti_type = OPTI_TYPE_ZERO_BYTE
6902 | OPTI_TYPE_PRECOMPUTE_INIT
6903 | OPTI_TYPE_PRECOMPUTE_MERKLE
6904 | OPTI_TYPE_EARLY_SKIP
6905 | OPTI_TYPE_NOT_ITERATED
6906 | OPTI_TYPE_PREPENDED_SALT
6907 | OPTI_TYPE_RAW_HASH;
6908 dgst_pos0 = 0;
6909 dgst_pos1 = 3;
6910 dgst_pos2 = 2;
6911 dgst_pos3 = 1;
6912 break;
6913
6914 case 21: hash_type = HASH_TYPE_MD5;
6915 salt_type = SALT_TYPE_INTERN;
6916 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6917 opts_type = OPTS_TYPE_PT_GENERATE_LE
6918 | OPTS_TYPE_PT_ADD80
6919 | OPTS_TYPE_PT_ADDBITS14;
6920 kern_type = KERN_TYPE_MD5_SLTPW;
6921 dgst_size = DGST_SIZE_4_4;
6922 parse_func = osc_parse_hash;
6923 sort_by_digest = sort_by_digest_4_4;
6924 opti_type = OPTI_TYPE_ZERO_BYTE
6925 | OPTI_TYPE_PRECOMPUTE_INIT
6926 | OPTI_TYPE_PRECOMPUTE_MERKLE
6927 | OPTI_TYPE_EARLY_SKIP
6928 | OPTI_TYPE_NOT_ITERATED
6929 | OPTI_TYPE_PREPENDED_SALT
6930 | OPTI_TYPE_RAW_HASH;
6931 dgst_pos0 = 0;
6932 dgst_pos1 = 3;
6933 dgst_pos2 = 2;
6934 dgst_pos3 = 1;
6935 break;
6936
6937 case 22: hash_type = HASH_TYPE_MD5;
6938 salt_type = SALT_TYPE_EMBEDDED;
6939 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6940 opts_type = OPTS_TYPE_PT_GENERATE_LE
6941 | OPTS_TYPE_PT_ADD80
6942 | OPTS_TYPE_PT_ADDBITS14;
6943 kern_type = KERN_TYPE_MD5_SLTPW;
6944 dgst_size = DGST_SIZE_4_4;
6945 parse_func = netscreen_parse_hash;
6946 sort_by_digest = sort_by_digest_4_4;
6947 opti_type = OPTI_TYPE_ZERO_BYTE
6948 | OPTI_TYPE_PRECOMPUTE_INIT
6949 | OPTI_TYPE_PRECOMPUTE_MERKLE
6950 | OPTI_TYPE_EARLY_SKIP
6951 | OPTI_TYPE_NOT_ITERATED
6952 | OPTI_TYPE_PREPENDED_SALT
6953 | OPTI_TYPE_RAW_HASH;
6954 dgst_pos0 = 0;
6955 dgst_pos1 = 3;
6956 dgst_pos2 = 2;
6957 dgst_pos3 = 1;
6958 break;
6959
6960 case 23: hash_type = HASH_TYPE_MD5;
6961 salt_type = SALT_TYPE_EMBEDDED;
6962 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6963 opts_type = OPTS_TYPE_PT_GENERATE_LE
6964 | OPTS_TYPE_PT_ADD80
6965 | OPTS_TYPE_PT_ADDBITS14;
6966 kern_type = KERN_TYPE_MD5_SLTPW;
6967 dgst_size = DGST_SIZE_4_4;
6968 parse_func = skype_parse_hash;
6969 sort_by_digest = sort_by_digest_4_4;
6970 opti_type = OPTI_TYPE_ZERO_BYTE
6971 | OPTI_TYPE_PRECOMPUTE_INIT
6972 | OPTI_TYPE_PRECOMPUTE_MERKLE
6973 | OPTI_TYPE_EARLY_SKIP
6974 | OPTI_TYPE_NOT_ITERATED
6975 | OPTI_TYPE_PREPENDED_SALT
6976 | OPTI_TYPE_RAW_HASH;
6977 dgst_pos0 = 0;
6978 dgst_pos1 = 3;
6979 dgst_pos2 = 2;
6980 dgst_pos3 = 1;
6981 break;
6982
6983 case 30: hash_type = HASH_TYPE_MD5;
6984 salt_type = SALT_TYPE_INTERN;
6985 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6986 opts_type = OPTS_TYPE_PT_GENERATE_LE
6987 | OPTS_TYPE_PT_UNICODE
6988 | OPTS_TYPE_ST_ADD80
6989 | OPTS_TYPE_ST_ADDBITS14;
6990 kern_type = KERN_TYPE_MD5_PWUSLT;
6991 dgst_size = DGST_SIZE_4_4;
6992 parse_func = md5s_parse_hash;
6993 sort_by_digest = sort_by_digest_4_4;
6994 opti_type = OPTI_TYPE_ZERO_BYTE
6995 | OPTI_TYPE_PRECOMPUTE_INIT
6996 | OPTI_TYPE_PRECOMPUTE_MERKLE
6997 | OPTI_TYPE_MEET_IN_MIDDLE
6998 | OPTI_TYPE_EARLY_SKIP
6999 | OPTI_TYPE_NOT_ITERATED
7000 | OPTI_TYPE_APPENDED_SALT
7001 | OPTI_TYPE_RAW_HASH;
7002 dgst_pos0 = 0;
7003 dgst_pos1 = 3;
7004 dgst_pos2 = 2;
7005 dgst_pos3 = 1;
7006 break;
7007
7008 case 40: hash_type = HASH_TYPE_MD5;
7009 salt_type = SALT_TYPE_INTERN;
7010 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7011 opts_type = OPTS_TYPE_PT_GENERATE_LE
7012 | OPTS_TYPE_PT_ADD80
7013 | OPTS_TYPE_PT_ADDBITS14
7014 | OPTS_TYPE_PT_UNICODE;
7015 kern_type = KERN_TYPE_MD5_SLTPWU;
7016 dgst_size = DGST_SIZE_4_4;
7017 parse_func = md5s_parse_hash;
7018 sort_by_digest = sort_by_digest_4_4;
7019 opti_type = OPTI_TYPE_ZERO_BYTE
7020 | OPTI_TYPE_PRECOMPUTE_INIT
7021 | OPTI_TYPE_PRECOMPUTE_MERKLE
7022 | OPTI_TYPE_EARLY_SKIP
7023 | OPTI_TYPE_NOT_ITERATED
7024 | OPTI_TYPE_PREPENDED_SALT
7025 | OPTI_TYPE_RAW_HASH;
7026 dgst_pos0 = 0;
7027 dgst_pos1 = 3;
7028 dgst_pos2 = 2;
7029 dgst_pos3 = 1;
7030 break;
7031
7032 case 50: hash_type = HASH_TYPE_MD5;
7033 salt_type = SALT_TYPE_INTERN;
7034 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7035 opts_type = OPTS_TYPE_PT_GENERATE_LE
7036 | OPTS_TYPE_ST_ADD80
7037 | OPTS_TYPE_ST_ADDBITS14;
7038 kern_type = KERN_TYPE_HMACMD5_PW;
7039 dgst_size = DGST_SIZE_4_4;
7040 parse_func = hmacmd5_parse_hash;
7041 sort_by_digest = sort_by_digest_4_4;
7042 opti_type = OPTI_TYPE_ZERO_BYTE
7043 | OPTI_TYPE_NOT_ITERATED;
7044 dgst_pos0 = 0;
7045 dgst_pos1 = 3;
7046 dgst_pos2 = 2;
7047 dgst_pos3 = 1;
7048 break;
7049
7050 case 60: hash_type = HASH_TYPE_MD5;
7051 salt_type = SALT_TYPE_INTERN;
7052 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7053 opts_type = OPTS_TYPE_PT_GENERATE_LE
7054 | OPTS_TYPE_PT_ADD80
7055 | OPTS_TYPE_PT_ADDBITS14;
7056 kern_type = KERN_TYPE_HMACMD5_SLT;
7057 dgst_size = DGST_SIZE_4_4;
7058 parse_func = hmacmd5_parse_hash;
7059 sort_by_digest = sort_by_digest_4_4;
7060 opti_type = OPTI_TYPE_ZERO_BYTE
7061 | OPTI_TYPE_NOT_ITERATED;
7062 dgst_pos0 = 0;
7063 dgst_pos1 = 3;
7064 dgst_pos2 = 2;
7065 dgst_pos3 = 1;
7066 break;
7067
7068 case 100: hash_type = HASH_TYPE_SHA1;
7069 salt_type = SALT_TYPE_NONE;
7070 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7071 opts_type = OPTS_TYPE_PT_GENERATE_BE
7072 | OPTS_TYPE_PT_ADD80
7073 | OPTS_TYPE_PT_ADDBITS15;
7074 kern_type = KERN_TYPE_SHA1;
7075 dgst_size = DGST_SIZE_4_5;
7076 parse_func = sha1_parse_hash;
7077 sort_by_digest = sort_by_digest_4_5;
7078 opti_type = OPTI_TYPE_ZERO_BYTE
7079 | OPTI_TYPE_PRECOMPUTE_INIT
7080 | OPTI_TYPE_PRECOMPUTE_MERKLE
7081 | OPTI_TYPE_EARLY_SKIP
7082 | OPTI_TYPE_NOT_ITERATED
7083 | OPTI_TYPE_NOT_SALTED
7084 | OPTI_TYPE_RAW_HASH;
7085 dgst_pos0 = 3;
7086 dgst_pos1 = 4;
7087 dgst_pos2 = 2;
7088 dgst_pos3 = 1;
7089 break;
7090
7091 case 101: hash_type = HASH_TYPE_SHA1;
7092 salt_type = SALT_TYPE_NONE;
7093 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7094 opts_type = OPTS_TYPE_PT_GENERATE_BE
7095 | OPTS_TYPE_PT_ADD80
7096 | OPTS_TYPE_PT_ADDBITS15;
7097 kern_type = KERN_TYPE_SHA1;
7098 dgst_size = DGST_SIZE_4_5;
7099 parse_func = sha1b64_parse_hash;
7100 sort_by_digest = sort_by_digest_4_5;
7101 opti_type = OPTI_TYPE_ZERO_BYTE
7102 | OPTI_TYPE_PRECOMPUTE_INIT
7103 | OPTI_TYPE_PRECOMPUTE_MERKLE
7104 | OPTI_TYPE_EARLY_SKIP
7105 | OPTI_TYPE_NOT_ITERATED
7106 | OPTI_TYPE_NOT_SALTED
7107 | OPTI_TYPE_RAW_HASH;
7108 dgst_pos0 = 3;
7109 dgst_pos1 = 4;
7110 dgst_pos2 = 2;
7111 dgst_pos3 = 1;
7112 break;
7113
7114 case 110: hash_type = HASH_TYPE_SHA1;
7115 salt_type = SALT_TYPE_INTERN;
7116 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7117 opts_type = OPTS_TYPE_PT_GENERATE_BE
7118 | OPTS_TYPE_ST_ADD80
7119 | OPTS_TYPE_ST_ADDBITS15;
7120 kern_type = KERN_TYPE_SHA1_PWSLT;
7121 dgst_size = DGST_SIZE_4_5;
7122 parse_func = sha1s_parse_hash;
7123 sort_by_digest = sort_by_digest_4_5;
7124 opti_type = OPTI_TYPE_ZERO_BYTE
7125 | OPTI_TYPE_PRECOMPUTE_INIT
7126 | OPTI_TYPE_PRECOMPUTE_MERKLE
7127 | OPTI_TYPE_EARLY_SKIP
7128 | OPTI_TYPE_NOT_ITERATED
7129 | OPTI_TYPE_APPENDED_SALT
7130 | OPTI_TYPE_RAW_HASH;
7131 dgst_pos0 = 3;
7132 dgst_pos1 = 4;
7133 dgst_pos2 = 2;
7134 dgst_pos3 = 1;
7135 break;
7136
7137 case 111: hash_type = HASH_TYPE_SHA1;
7138 salt_type = SALT_TYPE_EMBEDDED;
7139 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7140 opts_type = OPTS_TYPE_PT_GENERATE_BE
7141 | OPTS_TYPE_ST_ADD80
7142 | OPTS_TYPE_ST_ADDBITS15;
7143 kern_type = KERN_TYPE_SHA1_PWSLT;
7144 dgst_size = DGST_SIZE_4_5;
7145 parse_func = sha1b64s_parse_hash;
7146 sort_by_digest = sort_by_digest_4_5;
7147 opti_type = OPTI_TYPE_ZERO_BYTE
7148 | OPTI_TYPE_PRECOMPUTE_INIT
7149 | OPTI_TYPE_PRECOMPUTE_MERKLE
7150 | OPTI_TYPE_EARLY_SKIP
7151 | OPTI_TYPE_NOT_ITERATED
7152 | OPTI_TYPE_APPENDED_SALT
7153 | OPTI_TYPE_RAW_HASH;
7154 dgst_pos0 = 3;
7155 dgst_pos1 = 4;
7156 dgst_pos2 = 2;
7157 dgst_pos3 = 1;
7158 break;
7159
7160 case 112: hash_type = HASH_TYPE_SHA1;
7161 salt_type = SALT_TYPE_INTERN;
7162 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7163 opts_type = OPTS_TYPE_PT_GENERATE_BE
7164 | OPTS_TYPE_ST_ADD80
7165 | OPTS_TYPE_ST_ADDBITS15
7166 | OPTS_TYPE_ST_HEX;
7167 kern_type = KERN_TYPE_SHA1_PWSLT;
7168 dgst_size = DGST_SIZE_4_5;
7169 parse_func = oracles_parse_hash;
7170 sort_by_digest = sort_by_digest_4_5;
7171 opti_type = OPTI_TYPE_ZERO_BYTE
7172 | OPTI_TYPE_PRECOMPUTE_INIT
7173 | OPTI_TYPE_PRECOMPUTE_MERKLE
7174 | OPTI_TYPE_EARLY_SKIP
7175 | OPTI_TYPE_NOT_ITERATED
7176 | OPTI_TYPE_APPENDED_SALT
7177 | OPTI_TYPE_RAW_HASH;
7178 dgst_pos0 = 3;
7179 dgst_pos1 = 4;
7180 dgst_pos2 = 2;
7181 dgst_pos3 = 1;
7182 break;
7183
7184 case 120: hash_type = HASH_TYPE_SHA1;
7185 salt_type = SALT_TYPE_INTERN;
7186 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7187 opts_type = OPTS_TYPE_PT_GENERATE_BE
7188 | OPTS_TYPE_PT_ADD80
7189 | OPTS_TYPE_PT_ADDBITS15;
7190 kern_type = KERN_TYPE_SHA1_SLTPW;
7191 dgst_size = DGST_SIZE_4_5;
7192 parse_func = sha1s_parse_hash;
7193 sort_by_digest = sort_by_digest_4_5;
7194 opti_type = OPTI_TYPE_ZERO_BYTE
7195 | OPTI_TYPE_PRECOMPUTE_INIT
7196 | OPTI_TYPE_PRECOMPUTE_MERKLE
7197 | OPTI_TYPE_EARLY_SKIP
7198 | OPTI_TYPE_NOT_ITERATED
7199 | OPTI_TYPE_PREPENDED_SALT
7200 | OPTI_TYPE_RAW_HASH;
7201 dgst_pos0 = 3;
7202 dgst_pos1 = 4;
7203 dgst_pos2 = 2;
7204 dgst_pos3 = 1;
7205 break;
7206
7207 case 121: hash_type = HASH_TYPE_SHA1;
7208 salt_type = SALT_TYPE_INTERN;
7209 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7210 opts_type = OPTS_TYPE_PT_GENERATE_BE
7211 | OPTS_TYPE_PT_ADD80
7212 | OPTS_TYPE_PT_ADDBITS15
7213 | OPTS_TYPE_ST_LOWER;
7214 kern_type = KERN_TYPE_SHA1_SLTPW;
7215 dgst_size = DGST_SIZE_4_5;
7216 parse_func = smf_parse_hash;
7217 sort_by_digest = sort_by_digest_4_5;
7218 opti_type = OPTI_TYPE_ZERO_BYTE
7219 | OPTI_TYPE_PRECOMPUTE_INIT
7220 | OPTI_TYPE_PRECOMPUTE_MERKLE
7221 | OPTI_TYPE_EARLY_SKIP
7222 | OPTI_TYPE_NOT_ITERATED
7223 | OPTI_TYPE_PREPENDED_SALT
7224 | OPTI_TYPE_RAW_HASH;
7225 dgst_pos0 = 3;
7226 dgst_pos1 = 4;
7227 dgst_pos2 = 2;
7228 dgst_pos3 = 1;
7229 break;
7230
7231 case 122: hash_type = HASH_TYPE_SHA1;
7232 salt_type = SALT_TYPE_EMBEDDED;
7233 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7234 opts_type = OPTS_TYPE_PT_GENERATE_BE
7235 | OPTS_TYPE_PT_ADD80
7236 | OPTS_TYPE_PT_ADDBITS15
7237 | OPTS_TYPE_ST_HEX;
7238 kern_type = KERN_TYPE_SHA1_SLTPW;
7239 dgst_size = DGST_SIZE_4_5;
7240 parse_func = osx1_parse_hash;
7241 sort_by_digest = sort_by_digest_4_5;
7242 opti_type = OPTI_TYPE_ZERO_BYTE
7243 | OPTI_TYPE_PRECOMPUTE_INIT
7244 | OPTI_TYPE_PRECOMPUTE_MERKLE
7245 | OPTI_TYPE_EARLY_SKIP
7246 | OPTI_TYPE_NOT_ITERATED
7247 | OPTI_TYPE_PREPENDED_SALT
7248 | OPTI_TYPE_RAW_HASH;
7249 dgst_pos0 = 3;
7250 dgst_pos1 = 4;
7251 dgst_pos2 = 2;
7252 dgst_pos3 = 1;
7253 break;
7254
7255 case 124: hash_type = HASH_TYPE_SHA1;
7256 salt_type = SALT_TYPE_EMBEDDED;
7257 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7258 opts_type = OPTS_TYPE_PT_GENERATE_BE
7259 | OPTS_TYPE_PT_ADD80
7260 | OPTS_TYPE_PT_ADDBITS15;
7261 kern_type = KERN_TYPE_SHA1_SLTPW;
7262 dgst_size = DGST_SIZE_4_5;
7263 parse_func = djangosha1_parse_hash;
7264 sort_by_digest = sort_by_digest_4_5;
7265 opti_type = OPTI_TYPE_ZERO_BYTE
7266 | OPTI_TYPE_PRECOMPUTE_INIT
7267 | OPTI_TYPE_PRECOMPUTE_MERKLE
7268 | OPTI_TYPE_EARLY_SKIP
7269 | OPTI_TYPE_NOT_ITERATED
7270 | OPTI_TYPE_PREPENDED_SALT
7271 | OPTI_TYPE_RAW_HASH;
7272 dgst_pos0 = 3;
7273 dgst_pos1 = 4;
7274 dgst_pos2 = 2;
7275 dgst_pos3 = 1;
7276 break;
7277
7278 case 125: hash_type = HASH_TYPE_SHA1;
7279 salt_type = SALT_TYPE_EMBEDDED;
7280 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7281 opts_type = OPTS_TYPE_PT_GENERATE_BE
7282 | OPTS_TYPE_PT_ADD80
7283 | OPTS_TYPE_PT_ADDBITS15
7284 | OPTS_TYPE_ST_HEX;
7285 kern_type = KERN_TYPE_SHA1_SLTPW;
7286 dgst_size = DGST_SIZE_4_5;
7287 parse_func = arubaos_parse_hash;
7288 sort_by_digest = sort_by_digest_4_5;
7289 opti_type = OPTI_TYPE_ZERO_BYTE
7290 | OPTI_TYPE_PRECOMPUTE_INIT
7291 | OPTI_TYPE_PRECOMPUTE_MERKLE
7292 | OPTI_TYPE_EARLY_SKIP
7293 | OPTI_TYPE_NOT_ITERATED
7294 | OPTI_TYPE_PREPENDED_SALT
7295 | OPTI_TYPE_RAW_HASH;
7296 dgst_pos0 = 3;
7297 dgst_pos1 = 4;
7298 dgst_pos2 = 2;
7299 dgst_pos3 = 1;
7300 break;
7301
7302 case 130: hash_type = HASH_TYPE_SHA1;
7303 salt_type = SALT_TYPE_INTERN;
7304 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7305 opts_type = OPTS_TYPE_PT_GENERATE_BE
7306 | OPTS_TYPE_PT_UNICODE
7307 | OPTS_TYPE_ST_ADD80
7308 | OPTS_TYPE_ST_ADDBITS15;
7309 kern_type = KERN_TYPE_SHA1_PWUSLT;
7310 dgst_size = DGST_SIZE_4_5;
7311 parse_func = sha1s_parse_hash;
7312 sort_by_digest = sort_by_digest_4_5;
7313 opti_type = OPTI_TYPE_ZERO_BYTE
7314 | OPTI_TYPE_PRECOMPUTE_INIT
7315 | OPTI_TYPE_PRECOMPUTE_MERKLE
7316 | OPTI_TYPE_EARLY_SKIP
7317 | OPTI_TYPE_NOT_ITERATED
7318 | OPTI_TYPE_APPENDED_SALT
7319 | OPTI_TYPE_RAW_HASH;
7320 dgst_pos0 = 3;
7321 dgst_pos1 = 4;
7322 dgst_pos2 = 2;
7323 dgst_pos3 = 1;
7324 break;
7325
7326 case 131: hash_type = HASH_TYPE_SHA1;
7327 salt_type = SALT_TYPE_EMBEDDED;
7328 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7329 opts_type = OPTS_TYPE_PT_GENERATE_BE
7330 | OPTS_TYPE_PT_UNICODE
7331 | OPTS_TYPE_PT_UPPER
7332 | OPTS_TYPE_ST_ADD80
7333 | OPTS_TYPE_ST_ADDBITS15
7334 | OPTS_TYPE_ST_HEX;
7335 kern_type = KERN_TYPE_SHA1_PWUSLT;
7336 dgst_size = DGST_SIZE_4_5;
7337 parse_func = mssql2000_parse_hash;
7338 sort_by_digest = sort_by_digest_4_5;
7339 opti_type = OPTI_TYPE_ZERO_BYTE
7340 | OPTI_TYPE_PRECOMPUTE_INIT
7341 | OPTI_TYPE_PRECOMPUTE_MERKLE
7342 | OPTI_TYPE_EARLY_SKIP
7343 | OPTI_TYPE_NOT_ITERATED
7344 | OPTI_TYPE_APPENDED_SALT
7345 | OPTI_TYPE_RAW_HASH;
7346 dgst_pos0 = 3;
7347 dgst_pos1 = 4;
7348 dgst_pos2 = 2;
7349 dgst_pos3 = 1;
7350 break;
7351
7352 case 132: hash_type = HASH_TYPE_SHA1;
7353 salt_type = SALT_TYPE_EMBEDDED;
7354 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7355 opts_type = OPTS_TYPE_PT_GENERATE_BE
7356 | OPTS_TYPE_PT_UNICODE
7357 | OPTS_TYPE_ST_ADD80
7358 | OPTS_TYPE_ST_ADDBITS15
7359 | OPTS_TYPE_ST_HEX;
7360 kern_type = KERN_TYPE_SHA1_PWUSLT;
7361 dgst_size = DGST_SIZE_4_5;
7362 parse_func = mssql2005_parse_hash;
7363 sort_by_digest = sort_by_digest_4_5;
7364 opti_type = OPTI_TYPE_ZERO_BYTE
7365 | OPTI_TYPE_PRECOMPUTE_INIT
7366 | OPTI_TYPE_PRECOMPUTE_MERKLE
7367 | OPTI_TYPE_EARLY_SKIP
7368 | OPTI_TYPE_NOT_ITERATED
7369 | OPTI_TYPE_APPENDED_SALT
7370 | OPTI_TYPE_RAW_HASH;
7371 dgst_pos0 = 3;
7372 dgst_pos1 = 4;
7373 dgst_pos2 = 2;
7374 dgst_pos3 = 1;
7375 break;
7376
7377 case 133: hash_type = HASH_TYPE_SHA1;
7378 salt_type = SALT_TYPE_EMBEDDED;
7379 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7380 opts_type = OPTS_TYPE_PT_GENERATE_BE
7381 | OPTS_TYPE_PT_UNICODE
7382 | OPTS_TYPE_ST_ADD80
7383 | OPTS_TYPE_ST_ADDBITS15;
7384 kern_type = KERN_TYPE_SHA1_PWUSLT;
7385 dgst_size = DGST_SIZE_4_5;
7386 parse_func = peoplesoft_parse_hash;
7387 sort_by_digest = sort_by_digest_4_5;
7388 opti_type = OPTI_TYPE_ZERO_BYTE
7389 | OPTI_TYPE_PRECOMPUTE_INIT
7390 | OPTI_TYPE_PRECOMPUTE_MERKLE
7391 | OPTI_TYPE_EARLY_SKIP
7392 | OPTI_TYPE_NOT_ITERATED
7393 | OPTI_TYPE_APPENDED_SALT
7394 | OPTI_TYPE_RAW_HASH;
7395 dgst_pos0 = 3;
7396 dgst_pos1 = 4;
7397 dgst_pos2 = 2;
7398 dgst_pos3 = 1;
7399 break;
7400
7401 case 140: hash_type = HASH_TYPE_SHA1;
7402 salt_type = SALT_TYPE_INTERN;
7403 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7404 opts_type = OPTS_TYPE_PT_GENERATE_BE
7405 | OPTS_TYPE_PT_ADD80
7406 | OPTS_TYPE_PT_ADDBITS15
7407 | OPTS_TYPE_PT_UNICODE;
7408 kern_type = KERN_TYPE_SHA1_SLTPWU;
7409 dgst_size = DGST_SIZE_4_5;
7410 parse_func = sha1s_parse_hash;
7411 sort_by_digest = sort_by_digest_4_5;
7412 opti_type = OPTI_TYPE_ZERO_BYTE
7413 | OPTI_TYPE_PRECOMPUTE_INIT
7414 | OPTI_TYPE_PRECOMPUTE_MERKLE
7415 | OPTI_TYPE_EARLY_SKIP
7416 | OPTI_TYPE_NOT_ITERATED
7417 | OPTI_TYPE_PREPENDED_SALT
7418 | OPTI_TYPE_RAW_HASH;
7419 dgst_pos0 = 3;
7420 dgst_pos1 = 4;
7421 dgst_pos2 = 2;
7422 dgst_pos3 = 1;
7423 break;
7424
7425 case 141: hash_type = HASH_TYPE_SHA1;
7426 salt_type = SALT_TYPE_EMBEDDED;
7427 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7428 opts_type = OPTS_TYPE_PT_GENERATE_BE
7429 | OPTS_TYPE_PT_ADD80
7430 | OPTS_TYPE_PT_ADDBITS15
7431 | OPTS_TYPE_PT_UNICODE
7432 | OPTS_TYPE_ST_BASE64;
7433 kern_type = KERN_TYPE_SHA1_SLTPWU;
7434 dgst_size = DGST_SIZE_4_5;
7435 parse_func = episerver_parse_hash;
7436 sort_by_digest = sort_by_digest_4_5;
7437 opti_type = OPTI_TYPE_ZERO_BYTE
7438 | OPTI_TYPE_PRECOMPUTE_INIT
7439 | OPTI_TYPE_PRECOMPUTE_MERKLE
7440 | OPTI_TYPE_EARLY_SKIP
7441 | OPTI_TYPE_NOT_ITERATED
7442 | OPTI_TYPE_PREPENDED_SALT
7443 | OPTI_TYPE_RAW_HASH;
7444 dgst_pos0 = 3;
7445 dgst_pos1 = 4;
7446 dgst_pos2 = 2;
7447 dgst_pos3 = 1;
7448 break;
7449
7450 case 150: hash_type = HASH_TYPE_SHA1;
7451 salt_type = SALT_TYPE_INTERN;
7452 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7453 opts_type = OPTS_TYPE_PT_GENERATE_BE
7454 | OPTS_TYPE_ST_ADD80
7455 | OPTS_TYPE_ST_ADDBITS15;
7456 kern_type = KERN_TYPE_HMACSHA1_PW;
7457 dgst_size = DGST_SIZE_4_5;
7458 parse_func = hmacsha1_parse_hash;
7459 sort_by_digest = sort_by_digest_4_5;
7460 opti_type = OPTI_TYPE_ZERO_BYTE
7461 | OPTI_TYPE_NOT_ITERATED;
7462 dgst_pos0 = 3;
7463 dgst_pos1 = 4;
7464 dgst_pos2 = 2;
7465 dgst_pos3 = 1;
7466 break;
7467
7468 case 160: hash_type = HASH_TYPE_SHA1;
7469 salt_type = SALT_TYPE_INTERN;
7470 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7471 opts_type = OPTS_TYPE_PT_GENERATE_BE
7472 | OPTS_TYPE_PT_ADD80
7473 | OPTS_TYPE_PT_ADDBITS15;
7474 kern_type = KERN_TYPE_HMACSHA1_SLT;
7475 dgst_size = DGST_SIZE_4_5;
7476 parse_func = hmacsha1_parse_hash;
7477 sort_by_digest = sort_by_digest_4_5;
7478 opti_type = OPTI_TYPE_ZERO_BYTE
7479 | OPTI_TYPE_NOT_ITERATED;
7480 dgst_pos0 = 3;
7481 dgst_pos1 = 4;
7482 dgst_pos2 = 2;
7483 dgst_pos3 = 1;
7484 break;
7485
7486 case 190: hash_type = HASH_TYPE_SHA1;
7487 salt_type = SALT_TYPE_NONE;
7488 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7489 opts_type = OPTS_TYPE_PT_GENERATE_BE
7490 | OPTS_TYPE_PT_ADD80
7491 | OPTS_TYPE_PT_ADDBITS15;
7492 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7493 dgst_size = DGST_SIZE_4_5;
7494 parse_func = sha1linkedin_parse_hash;
7495 sort_by_digest = sort_by_digest_4_5;
7496 opti_type = OPTI_TYPE_ZERO_BYTE
7497 | OPTI_TYPE_PRECOMPUTE_INIT
7498 | OPTI_TYPE_EARLY_SKIP
7499 | OPTI_TYPE_NOT_ITERATED
7500 | OPTI_TYPE_NOT_SALTED;
7501 dgst_pos0 = 0;
7502 dgst_pos1 = 4;
7503 dgst_pos2 = 3;
7504 dgst_pos3 = 2;
7505 break;
7506
7507 case 200: hash_type = HASH_TYPE_MYSQL;
7508 salt_type = SALT_TYPE_NONE;
7509 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7510 opts_type = 0;
7511 kern_type = KERN_TYPE_MYSQL;
7512 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7513 parse_func = mysql323_parse_hash;
7514 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7515 opti_type = OPTI_TYPE_ZERO_BYTE;
7516 dgst_pos0 = 0;
7517 dgst_pos1 = 1;
7518 dgst_pos2 = 2;
7519 dgst_pos3 = 3;
7520 break;
7521
7522 case 300: hash_type = HASH_TYPE_SHA1;
7523 salt_type = SALT_TYPE_NONE;
7524 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7525 opts_type = OPTS_TYPE_PT_GENERATE_BE
7526 | OPTS_TYPE_PT_ADD80
7527 | OPTS_TYPE_PT_ADDBITS15;
7528 kern_type = KERN_TYPE_MYSQL41;
7529 dgst_size = DGST_SIZE_4_5;
7530 parse_func = sha1_parse_hash;
7531 sort_by_digest = sort_by_digest_4_5;
7532 opti_type = OPTI_TYPE_ZERO_BYTE
7533 | OPTI_TYPE_PRECOMPUTE_INIT
7534 | OPTI_TYPE_PRECOMPUTE_MERKLE
7535 | OPTI_TYPE_EARLY_SKIP
7536 | OPTI_TYPE_NOT_ITERATED
7537 | OPTI_TYPE_NOT_SALTED;
7538 dgst_pos0 = 3;
7539 dgst_pos1 = 4;
7540 dgst_pos2 = 2;
7541 dgst_pos3 = 1;
7542 break;
7543
7544 case 400: hash_type = HASH_TYPE_MD5;
7545 salt_type = SALT_TYPE_EMBEDDED;
7546 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7547 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7548 kern_type = KERN_TYPE_PHPASS;
7549 dgst_size = DGST_SIZE_4_4;
7550 parse_func = phpass_parse_hash;
7551 sort_by_digest = sort_by_digest_4_4;
7552 opti_type = OPTI_TYPE_ZERO_BYTE
7553 | OPTI_TYPE_SLOW_HASH_SIMD;
7554 dgst_pos0 = 0;
7555 dgst_pos1 = 1;
7556 dgst_pos2 = 2;
7557 dgst_pos3 = 3;
7558 break;
7559
7560 case 500: hash_type = HASH_TYPE_MD5;
7561 salt_type = SALT_TYPE_EMBEDDED;
7562 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7563 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7564 kern_type = KERN_TYPE_MD5CRYPT;
7565 dgst_size = DGST_SIZE_4_4;
7566 parse_func = md5crypt_parse_hash;
7567 sort_by_digest = sort_by_digest_4_4;
7568 opti_type = OPTI_TYPE_ZERO_BYTE;
7569 dgst_pos0 = 0;
7570 dgst_pos1 = 1;
7571 dgst_pos2 = 2;
7572 dgst_pos3 = 3;
7573 break;
7574
7575 case 501: hash_type = HASH_TYPE_MD5;
7576 salt_type = SALT_TYPE_EMBEDDED;
7577 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7578 opts_type = OPTS_TYPE_PT_GENERATE_LE
7579 | OPTS_TYPE_HASH_COPY;
7580 kern_type = KERN_TYPE_MD5CRYPT;
7581 dgst_size = DGST_SIZE_4_4;
7582 parse_func = juniper_parse_hash;
7583 sort_by_digest = sort_by_digest_4_4;
7584 opti_type = OPTI_TYPE_ZERO_BYTE;
7585 dgst_pos0 = 0;
7586 dgst_pos1 = 1;
7587 dgst_pos2 = 2;
7588 dgst_pos3 = 3;
7589 break;
7590
7591 case 900: hash_type = HASH_TYPE_MD4;
7592 salt_type = SALT_TYPE_NONE;
7593 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7594 opts_type = OPTS_TYPE_PT_GENERATE_LE
7595 | OPTS_TYPE_PT_ADD80
7596 | OPTS_TYPE_PT_ADDBITS14;
7597 kern_type = KERN_TYPE_MD4;
7598 dgst_size = DGST_SIZE_4_4;
7599 parse_func = md4_parse_hash;
7600 sort_by_digest = sort_by_digest_4_4;
7601 opti_type = OPTI_TYPE_ZERO_BYTE
7602 | OPTI_TYPE_PRECOMPUTE_INIT
7603 | OPTI_TYPE_PRECOMPUTE_MERKLE
7604 | OPTI_TYPE_MEET_IN_MIDDLE
7605 | OPTI_TYPE_EARLY_SKIP
7606 | OPTI_TYPE_NOT_ITERATED
7607 | OPTI_TYPE_NOT_SALTED
7608 | OPTI_TYPE_RAW_HASH;
7609 dgst_pos0 = 0;
7610 dgst_pos1 = 3;
7611 dgst_pos2 = 2;
7612 dgst_pos3 = 1;
7613 break;
7614
7615 case 1000: hash_type = HASH_TYPE_MD4;
7616 salt_type = SALT_TYPE_NONE;
7617 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7618 opts_type = OPTS_TYPE_PT_GENERATE_LE
7619 | OPTS_TYPE_PT_ADD80
7620 | OPTS_TYPE_PT_ADDBITS14
7621 | OPTS_TYPE_PT_UNICODE;
7622 kern_type = KERN_TYPE_MD4_PWU;
7623 dgst_size = DGST_SIZE_4_4;
7624 parse_func = md4_parse_hash;
7625 sort_by_digest = sort_by_digest_4_4;
7626 opti_type = OPTI_TYPE_ZERO_BYTE
7627 | OPTI_TYPE_PRECOMPUTE_INIT
7628 | OPTI_TYPE_PRECOMPUTE_MERKLE
7629 | OPTI_TYPE_MEET_IN_MIDDLE
7630 | OPTI_TYPE_EARLY_SKIP
7631 | OPTI_TYPE_NOT_ITERATED
7632 | OPTI_TYPE_NOT_SALTED
7633 | OPTI_TYPE_RAW_HASH;
7634 dgst_pos0 = 0;
7635 dgst_pos1 = 3;
7636 dgst_pos2 = 2;
7637 dgst_pos3 = 1;
7638 break;
7639
7640 case 1100: hash_type = HASH_TYPE_MD4;
7641 salt_type = SALT_TYPE_INTERN;
7642 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7643 opts_type = OPTS_TYPE_PT_GENERATE_LE
7644 | OPTS_TYPE_PT_ADD80
7645 | OPTS_TYPE_PT_ADDBITS14
7646 | OPTS_TYPE_PT_UNICODE
7647 | OPTS_TYPE_ST_ADD80
7648 | OPTS_TYPE_ST_UNICODE
7649 | OPTS_TYPE_ST_LOWER;
7650 kern_type = KERN_TYPE_MD44_PWUSLT;
7651 dgst_size = DGST_SIZE_4_4;
7652 parse_func = dcc_parse_hash;
7653 sort_by_digest = sort_by_digest_4_4;
7654 opti_type = OPTI_TYPE_ZERO_BYTE
7655 | OPTI_TYPE_PRECOMPUTE_INIT
7656 | OPTI_TYPE_PRECOMPUTE_MERKLE
7657 | OPTI_TYPE_EARLY_SKIP
7658 | OPTI_TYPE_NOT_ITERATED;
7659 dgst_pos0 = 0;
7660 dgst_pos1 = 3;
7661 dgst_pos2 = 2;
7662 dgst_pos3 = 1;
7663 break;
7664
7665 case 1400: hash_type = HASH_TYPE_SHA256;
7666 salt_type = SALT_TYPE_NONE;
7667 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7668 opts_type = OPTS_TYPE_PT_GENERATE_BE
7669 | OPTS_TYPE_PT_ADD80
7670 | OPTS_TYPE_PT_ADDBITS15;
7671 kern_type = KERN_TYPE_SHA256;
7672 dgst_size = DGST_SIZE_4_8;
7673 parse_func = sha256_parse_hash;
7674 sort_by_digest = sort_by_digest_4_8;
7675 opti_type = OPTI_TYPE_ZERO_BYTE
7676 | OPTI_TYPE_PRECOMPUTE_INIT
7677 | OPTI_TYPE_PRECOMPUTE_MERKLE
7678 | OPTI_TYPE_EARLY_SKIP
7679 | OPTI_TYPE_NOT_ITERATED
7680 | OPTI_TYPE_NOT_SALTED
7681 | OPTI_TYPE_RAW_HASH;
7682 dgst_pos0 = 3;
7683 dgst_pos1 = 7;
7684 dgst_pos2 = 2;
7685 dgst_pos3 = 6;
7686 break;
7687
7688 case 1410: hash_type = HASH_TYPE_SHA256;
7689 salt_type = SALT_TYPE_INTERN;
7690 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7691 opts_type = OPTS_TYPE_PT_GENERATE_BE
7692 | OPTS_TYPE_ST_ADD80
7693 | OPTS_TYPE_ST_ADDBITS15;
7694 kern_type = KERN_TYPE_SHA256_PWSLT;
7695 dgst_size = DGST_SIZE_4_8;
7696 parse_func = sha256s_parse_hash;
7697 sort_by_digest = sort_by_digest_4_8;
7698 opti_type = OPTI_TYPE_ZERO_BYTE
7699 | OPTI_TYPE_PRECOMPUTE_INIT
7700 | OPTI_TYPE_PRECOMPUTE_MERKLE
7701 | OPTI_TYPE_EARLY_SKIP
7702 | OPTI_TYPE_NOT_ITERATED
7703 | OPTI_TYPE_APPENDED_SALT
7704 | OPTI_TYPE_RAW_HASH;
7705 dgst_pos0 = 3;
7706 dgst_pos1 = 7;
7707 dgst_pos2 = 2;
7708 dgst_pos3 = 6;
7709 break;
7710
7711 case 1420: hash_type = HASH_TYPE_SHA256;
7712 salt_type = SALT_TYPE_INTERN;
7713 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7714 opts_type = OPTS_TYPE_PT_GENERATE_BE
7715 | OPTS_TYPE_PT_ADD80
7716 | OPTS_TYPE_PT_ADDBITS15;
7717 kern_type = KERN_TYPE_SHA256_SLTPW;
7718 dgst_size = DGST_SIZE_4_8;
7719 parse_func = sha256s_parse_hash;
7720 sort_by_digest = sort_by_digest_4_8;
7721 opti_type = OPTI_TYPE_ZERO_BYTE
7722 | OPTI_TYPE_PRECOMPUTE_INIT
7723 | OPTI_TYPE_PRECOMPUTE_MERKLE
7724 | OPTI_TYPE_EARLY_SKIP
7725 | OPTI_TYPE_NOT_ITERATED
7726 | OPTI_TYPE_PREPENDED_SALT
7727 | OPTI_TYPE_RAW_HASH;
7728 dgst_pos0 = 3;
7729 dgst_pos1 = 7;
7730 dgst_pos2 = 2;
7731 dgst_pos3 = 6;
7732 break;
7733
7734 case 1421: hash_type = HASH_TYPE_SHA256;
7735 salt_type = SALT_TYPE_EMBEDDED;
7736 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7737 opts_type = OPTS_TYPE_PT_GENERATE_BE
7738 | OPTS_TYPE_PT_ADD80
7739 | OPTS_TYPE_PT_ADDBITS15;
7740 kern_type = KERN_TYPE_SHA256_SLTPW;
7741 dgst_size = DGST_SIZE_4_8;
7742 parse_func = hmailserver_parse_hash;
7743 sort_by_digest = sort_by_digest_4_8;
7744 opti_type = OPTI_TYPE_ZERO_BYTE
7745 | OPTI_TYPE_PRECOMPUTE_INIT
7746 | OPTI_TYPE_PRECOMPUTE_MERKLE
7747 | OPTI_TYPE_EARLY_SKIP
7748 | OPTI_TYPE_NOT_ITERATED
7749 | OPTI_TYPE_PREPENDED_SALT
7750 | OPTI_TYPE_RAW_HASH;
7751 dgst_pos0 = 3;
7752 dgst_pos1 = 7;
7753 dgst_pos2 = 2;
7754 dgst_pos3 = 6;
7755 break;
7756
7757 case 1430: hash_type = HASH_TYPE_SHA256;
7758 salt_type = SALT_TYPE_INTERN;
7759 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7760 opts_type = OPTS_TYPE_PT_GENERATE_BE
7761 | OPTS_TYPE_PT_UNICODE
7762 | OPTS_TYPE_ST_ADD80
7763 | OPTS_TYPE_ST_ADDBITS15;
7764 kern_type = KERN_TYPE_SHA256_PWUSLT;
7765 dgst_size = DGST_SIZE_4_8;
7766 parse_func = sha256s_parse_hash;
7767 sort_by_digest = sort_by_digest_4_8;
7768 opti_type = OPTI_TYPE_ZERO_BYTE
7769 | OPTI_TYPE_PRECOMPUTE_INIT
7770 | OPTI_TYPE_PRECOMPUTE_MERKLE
7771 | OPTI_TYPE_EARLY_SKIP
7772 | OPTI_TYPE_NOT_ITERATED
7773 | OPTI_TYPE_APPENDED_SALT
7774 | OPTI_TYPE_RAW_HASH;
7775 dgst_pos0 = 3;
7776 dgst_pos1 = 7;
7777 dgst_pos2 = 2;
7778 dgst_pos3 = 6;
7779 break;
7780
7781 case 1440: hash_type = HASH_TYPE_SHA256;
7782 salt_type = SALT_TYPE_INTERN;
7783 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7784 opts_type = OPTS_TYPE_PT_GENERATE_BE
7785 | OPTS_TYPE_PT_ADD80
7786 | OPTS_TYPE_PT_ADDBITS15
7787 | OPTS_TYPE_PT_UNICODE;
7788 kern_type = KERN_TYPE_SHA256_SLTPWU;
7789 dgst_size = DGST_SIZE_4_8;
7790 parse_func = sha256s_parse_hash;
7791 sort_by_digest = sort_by_digest_4_8;
7792 opti_type = OPTI_TYPE_ZERO_BYTE
7793 | OPTI_TYPE_PRECOMPUTE_INIT
7794 | OPTI_TYPE_PRECOMPUTE_MERKLE
7795 | OPTI_TYPE_EARLY_SKIP
7796 | OPTI_TYPE_NOT_ITERATED
7797 | OPTI_TYPE_PREPENDED_SALT
7798 | OPTI_TYPE_RAW_HASH;
7799 dgst_pos0 = 3;
7800 dgst_pos1 = 7;
7801 dgst_pos2 = 2;
7802 dgst_pos3 = 6;
7803 break;
7804
7805 case 1441: hash_type = HASH_TYPE_SHA256;
7806 salt_type = SALT_TYPE_EMBEDDED;
7807 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7808 opts_type = OPTS_TYPE_PT_GENERATE_BE
7809 | OPTS_TYPE_PT_ADD80
7810 | OPTS_TYPE_PT_ADDBITS15
7811 | OPTS_TYPE_PT_UNICODE
7812 | OPTS_TYPE_ST_BASE64;
7813 kern_type = KERN_TYPE_SHA256_SLTPWU;
7814 dgst_size = DGST_SIZE_4_8;
7815 parse_func = episerver4_parse_hash;
7816 sort_by_digest = sort_by_digest_4_8;
7817 opti_type = OPTI_TYPE_ZERO_BYTE
7818 | OPTI_TYPE_PRECOMPUTE_INIT
7819 | OPTI_TYPE_PRECOMPUTE_MERKLE
7820 | OPTI_TYPE_EARLY_SKIP
7821 | OPTI_TYPE_NOT_ITERATED
7822 | OPTI_TYPE_PREPENDED_SALT
7823 | OPTI_TYPE_RAW_HASH;
7824 dgst_pos0 = 3;
7825 dgst_pos1 = 7;
7826 dgst_pos2 = 2;
7827 dgst_pos3 = 6;
7828 break;
7829
7830 case 1450: hash_type = HASH_TYPE_SHA256;
7831 salt_type = SALT_TYPE_INTERN;
7832 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7833 opts_type = OPTS_TYPE_PT_GENERATE_BE
7834 | OPTS_TYPE_ST_ADD80;
7835 kern_type = KERN_TYPE_HMACSHA256_PW;
7836 dgst_size = DGST_SIZE_4_8;
7837 parse_func = hmacsha256_parse_hash;
7838 sort_by_digest = sort_by_digest_4_8;
7839 opti_type = OPTI_TYPE_ZERO_BYTE
7840 | OPTI_TYPE_NOT_ITERATED;
7841 dgst_pos0 = 3;
7842 dgst_pos1 = 7;
7843 dgst_pos2 = 2;
7844 dgst_pos3 = 6;
7845 break;
7846
7847 case 1460: hash_type = HASH_TYPE_SHA256;
7848 salt_type = SALT_TYPE_INTERN;
7849 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7850 opts_type = OPTS_TYPE_PT_GENERATE_BE
7851 | OPTS_TYPE_PT_ADD80
7852 | OPTS_TYPE_PT_ADDBITS15;
7853 kern_type = KERN_TYPE_HMACSHA256_SLT;
7854 dgst_size = DGST_SIZE_4_8;
7855 parse_func = hmacsha256_parse_hash;
7856 sort_by_digest = sort_by_digest_4_8;
7857 opti_type = OPTI_TYPE_ZERO_BYTE
7858 | OPTI_TYPE_NOT_ITERATED;
7859 dgst_pos0 = 3;
7860 dgst_pos1 = 7;
7861 dgst_pos2 = 2;
7862 dgst_pos3 = 6;
7863 break;
7864
7865 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7866 salt_type = SALT_TYPE_EMBEDDED;
7867 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7868 opts_type = OPTS_TYPE_PT_GENERATE_LE
7869 | OPTS_TYPE_PT_BITSLICE;
7870 kern_type = KERN_TYPE_DESCRYPT;
7871 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7872 parse_func = descrypt_parse_hash;
7873 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7874 opti_type = OPTI_TYPE_ZERO_BYTE
7875 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7876 dgst_pos0 = 0;
7877 dgst_pos1 = 1;
7878 dgst_pos2 = 2;
7879 dgst_pos3 = 3;
7880 break;
7881
7882 case 1600: hash_type = HASH_TYPE_MD5;
7883 salt_type = SALT_TYPE_EMBEDDED;
7884 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7885 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7886 kern_type = KERN_TYPE_APR1CRYPT;
7887 dgst_size = DGST_SIZE_4_4;
7888 parse_func = md5apr1_parse_hash;
7889 sort_by_digest = sort_by_digest_4_4;
7890 opti_type = OPTI_TYPE_ZERO_BYTE;
7891 dgst_pos0 = 0;
7892 dgst_pos1 = 1;
7893 dgst_pos2 = 2;
7894 dgst_pos3 = 3;
7895 break;
7896
7897 case 1700: hash_type = HASH_TYPE_SHA512;
7898 salt_type = SALT_TYPE_NONE;
7899 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7900 opts_type = OPTS_TYPE_PT_GENERATE_BE
7901 | OPTS_TYPE_PT_ADD80
7902 | OPTS_TYPE_PT_ADDBITS15;
7903 kern_type = KERN_TYPE_SHA512;
7904 dgst_size = DGST_SIZE_8_8;
7905 parse_func = sha512_parse_hash;
7906 sort_by_digest = sort_by_digest_8_8;
7907 opti_type = OPTI_TYPE_ZERO_BYTE
7908 | OPTI_TYPE_PRECOMPUTE_INIT
7909 | OPTI_TYPE_PRECOMPUTE_MERKLE
7910 | OPTI_TYPE_EARLY_SKIP
7911 | OPTI_TYPE_NOT_ITERATED
7912 | OPTI_TYPE_NOT_SALTED
7913 | OPTI_TYPE_USES_BITS_64
7914 | OPTI_TYPE_RAW_HASH;
7915 dgst_pos0 = 14;
7916 dgst_pos1 = 15;
7917 dgst_pos2 = 6;
7918 dgst_pos3 = 7;
7919 break;
7920
7921 case 1710: hash_type = HASH_TYPE_SHA512;
7922 salt_type = SALT_TYPE_INTERN;
7923 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7924 opts_type = OPTS_TYPE_PT_GENERATE_BE
7925 | OPTS_TYPE_ST_ADD80
7926 | OPTS_TYPE_ST_ADDBITS15;
7927 kern_type = KERN_TYPE_SHA512_PWSLT;
7928 dgst_size = DGST_SIZE_8_8;
7929 parse_func = sha512s_parse_hash;
7930 sort_by_digest = sort_by_digest_8_8;
7931 opti_type = OPTI_TYPE_ZERO_BYTE
7932 | OPTI_TYPE_PRECOMPUTE_INIT
7933 | OPTI_TYPE_PRECOMPUTE_MERKLE
7934 | OPTI_TYPE_EARLY_SKIP
7935 | OPTI_TYPE_NOT_ITERATED
7936 | OPTI_TYPE_APPENDED_SALT
7937 | OPTI_TYPE_USES_BITS_64
7938 | OPTI_TYPE_RAW_HASH;
7939 dgst_pos0 = 14;
7940 dgst_pos1 = 15;
7941 dgst_pos2 = 6;
7942 dgst_pos3 = 7;
7943 break;
7944
7945 case 1711: hash_type = HASH_TYPE_SHA512;
7946 salt_type = SALT_TYPE_EMBEDDED;
7947 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7948 opts_type = OPTS_TYPE_PT_GENERATE_BE
7949 | OPTS_TYPE_ST_ADD80
7950 | OPTS_TYPE_ST_ADDBITS15;
7951 kern_type = KERN_TYPE_SHA512_PWSLT;
7952 dgst_size = DGST_SIZE_8_8;
7953 parse_func = sha512b64s_parse_hash;
7954 sort_by_digest = sort_by_digest_8_8;
7955 opti_type = OPTI_TYPE_ZERO_BYTE
7956 | OPTI_TYPE_PRECOMPUTE_INIT
7957 | OPTI_TYPE_PRECOMPUTE_MERKLE
7958 | OPTI_TYPE_EARLY_SKIP
7959 | OPTI_TYPE_NOT_ITERATED
7960 | OPTI_TYPE_APPENDED_SALT
7961 | OPTI_TYPE_USES_BITS_64
7962 | OPTI_TYPE_RAW_HASH;
7963 dgst_pos0 = 14;
7964 dgst_pos1 = 15;
7965 dgst_pos2 = 6;
7966 dgst_pos3 = 7;
7967 break;
7968
7969 case 1720: hash_type = HASH_TYPE_SHA512;
7970 salt_type = SALT_TYPE_INTERN;
7971 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7972 opts_type = OPTS_TYPE_PT_GENERATE_BE
7973 | OPTS_TYPE_PT_ADD80
7974 | OPTS_TYPE_PT_ADDBITS15;
7975 kern_type = KERN_TYPE_SHA512_SLTPW;
7976 dgst_size = DGST_SIZE_8_8;
7977 parse_func = sha512s_parse_hash;
7978 sort_by_digest = sort_by_digest_8_8;
7979 opti_type = OPTI_TYPE_ZERO_BYTE
7980 | OPTI_TYPE_PRECOMPUTE_INIT
7981 | OPTI_TYPE_PRECOMPUTE_MERKLE
7982 | OPTI_TYPE_EARLY_SKIP
7983 | OPTI_TYPE_NOT_ITERATED
7984 | OPTI_TYPE_PREPENDED_SALT
7985 | OPTI_TYPE_USES_BITS_64
7986 | OPTI_TYPE_RAW_HASH;
7987 dgst_pos0 = 14;
7988 dgst_pos1 = 15;
7989 dgst_pos2 = 6;
7990 dgst_pos3 = 7;
7991 break;
7992
7993 case 1722: hash_type = HASH_TYPE_SHA512;
7994 salt_type = SALT_TYPE_EMBEDDED;
7995 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7996 opts_type = OPTS_TYPE_PT_GENERATE_BE
7997 | OPTS_TYPE_PT_ADD80
7998 | OPTS_TYPE_PT_ADDBITS15
7999 | OPTS_TYPE_ST_HEX;
8000 kern_type = KERN_TYPE_SHA512_SLTPW;
8001 dgst_size = DGST_SIZE_8_8;
8002 parse_func = osx512_parse_hash;
8003 sort_by_digest = sort_by_digest_8_8;
8004 opti_type = OPTI_TYPE_ZERO_BYTE
8005 | OPTI_TYPE_PRECOMPUTE_INIT
8006 | OPTI_TYPE_PRECOMPUTE_MERKLE
8007 | OPTI_TYPE_EARLY_SKIP
8008 | OPTI_TYPE_NOT_ITERATED
8009 | OPTI_TYPE_PREPENDED_SALT
8010 | OPTI_TYPE_USES_BITS_64
8011 | OPTI_TYPE_RAW_HASH;
8012 dgst_pos0 = 14;
8013 dgst_pos1 = 15;
8014 dgst_pos2 = 6;
8015 dgst_pos3 = 7;
8016 break;
8017
8018 case 1730: hash_type = HASH_TYPE_SHA512;
8019 salt_type = SALT_TYPE_INTERN;
8020 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8021 opts_type = OPTS_TYPE_PT_GENERATE_BE
8022 | OPTS_TYPE_PT_UNICODE
8023 | OPTS_TYPE_ST_ADD80
8024 | OPTS_TYPE_ST_ADDBITS15;
8025 kern_type = KERN_TYPE_SHA512_PWSLTU;
8026 dgst_size = DGST_SIZE_8_8;
8027 parse_func = sha512s_parse_hash;
8028 sort_by_digest = sort_by_digest_8_8;
8029 opti_type = OPTI_TYPE_ZERO_BYTE
8030 | OPTI_TYPE_PRECOMPUTE_INIT
8031 | OPTI_TYPE_PRECOMPUTE_MERKLE
8032 | OPTI_TYPE_EARLY_SKIP
8033 | OPTI_TYPE_NOT_ITERATED
8034 | OPTI_TYPE_APPENDED_SALT
8035 | OPTI_TYPE_USES_BITS_64
8036 | OPTI_TYPE_RAW_HASH;
8037 dgst_pos0 = 14;
8038 dgst_pos1 = 15;
8039 dgst_pos2 = 6;
8040 dgst_pos3 = 7;
8041 break;
8042
8043 case 1731: hash_type = HASH_TYPE_SHA512;
8044 salt_type = SALT_TYPE_EMBEDDED;
8045 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8046 opts_type = OPTS_TYPE_PT_GENERATE_BE
8047 | OPTS_TYPE_PT_UNICODE
8048 | OPTS_TYPE_ST_ADD80
8049 | OPTS_TYPE_ST_ADDBITS15
8050 | OPTS_TYPE_ST_HEX;
8051 kern_type = KERN_TYPE_SHA512_PWSLTU;
8052 dgst_size = DGST_SIZE_8_8;
8053 parse_func = mssql2012_parse_hash;
8054 sort_by_digest = sort_by_digest_8_8;
8055 opti_type = OPTI_TYPE_ZERO_BYTE
8056 | OPTI_TYPE_PRECOMPUTE_INIT
8057 | OPTI_TYPE_PRECOMPUTE_MERKLE
8058 | OPTI_TYPE_EARLY_SKIP
8059 | OPTI_TYPE_NOT_ITERATED
8060 | OPTI_TYPE_APPENDED_SALT
8061 | OPTI_TYPE_USES_BITS_64
8062 | OPTI_TYPE_RAW_HASH;
8063 dgst_pos0 = 14;
8064 dgst_pos1 = 15;
8065 dgst_pos2 = 6;
8066 dgst_pos3 = 7;
8067 break;
8068
8069 case 1740: hash_type = HASH_TYPE_SHA512;
8070 salt_type = SALT_TYPE_INTERN;
8071 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8072 opts_type = OPTS_TYPE_PT_GENERATE_BE
8073 | OPTS_TYPE_PT_ADD80
8074 | OPTS_TYPE_PT_ADDBITS15
8075 | OPTS_TYPE_PT_UNICODE;
8076 kern_type = KERN_TYPE_SHA512_SLTPWU;
8077 dgst_size = DGST_SIZE_8_8;
8078 parse_func = sha512s_parse_hash;
8079 sort_by_digest = sort_by_digest_8_8;
8080 opti_type = OPTI_TYPE_ZERO_BYTE
8081 | OPTI_TYPE_PRECOMPUTE_INIT
8082 | OPTI_TYPE_PRECOMPUTE_MERKLE
8083 | OPTI_TYPE_EARLY_SKIP
8084 | OPTI_TYPE_NOT_ITERATED
8085 | OPTI_TYPE_PREPENDED_SALT
8086 | OPTI_TYPE_USES_BITS_64
8087 | OPTI_TYPE_RAW_HASH;
8088 dgst_pos0 = 14;
8089 dgst_pos1 = 15;
8090 dgst_pos2 = 6;
8091 dgst_pos3 = 7;
8092 break;
8093
8094 case 1750: hash_type = HASH_TYPE_SHA512;
8095 salt_type = SALT_TYPE_INTERN;
8096 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8097 opts_type = OPTS_TYPE_PT_GENERATE_BE
8098 | OPTS_TYPE_ST_ADD80;
8099 kern_type = KERN_TYPE_HMACSHA512_PW;
8100 dgst_size = DGST_SIZE_8_8;
8101 parse_func = hmacsha512_parse_hash;
8102 sort_by_digest = sort_by_digest_8_8;
8103 opti_type = OPTI_TYPE_ZERO_BYTE
8104 | OPTI_TYPE_USES_BITS_64
8105 | OPTI_TYPE_NOT_ITERATED;
8106 dgst_pos0 = 14;
8107 dgst_pos1 = 15;
8108 dgst_pos2 = 6;
8109 dgst_pos3 = 7;
8110 break;
8111
8112 case 1760: hash_type = HASH_TYPE_SHA512;
8113 salt_type = SALT_TYPE_INTERN;
8114 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8115 opts_type = OPTS_TYPE_PT_GENERATE_BE
8116 | OPTS_TYPE_PT_ADD80
8117 | OPTS_TYPE_PT_ADDBITS15;
8118 kern_type = KERN_TYPE_HMACSHA512_SLT;
8119 dgst_size = DGST_SIZE_8_8;
8120 parse_func = hmacsha512_parse_hash;
8121 sort_by_digest = sort_by_digest_8_8;
8122 opti_type = OPTI_TYPE_ZERO_BYTE
8123 | OPTI_TYPE_USES_BITS_64
8124 | OPTI_TYPE_NOT_ITERATED;
8125 dgst_pos0 = 14;
8126 dgst_pos1 = 15;
8127 dgst_pos2 = 6;
8128 dgst_pos3 = 7;
8129 break;
8130
8131 case 1800: hash_type = HASH_TYPE_SHA512;
8132 salt_type = SALT_TYPE_EMBEDDED;
8133 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8134 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8135 kern_type = KERN_TYPE_SHA512CRYPT;
8136 dgst_size = DGST_SIZE_8_8;
8137 parse_func = sha512crypt_parse_hash;
8138 sort_by_digest = sort_by_digest_8_8;
8139 opti_type = OPTI_TYPE_ZERO_BYTE
8140 | OPTI_TYPE_USES_BITS_64;
8141 dgst_pos0 = 0;
8142 dgst_pos1 = 1;
8143 dgst_pos2 = 2;
8144 dgst_pos3 = 3;
8145 break;
8146
8147 case 2100: hash_type = HASH_TYPE_DCC2;
8148 salt_type = SALT_TYPE_EMBEDDED;
8149 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8150 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8151 | OPTS_TYPE_ST_LOWER
8152 | OPTS_TYPE_ST_UNICODE;
8153 kern_type = KERN_TYPE_DCC2;
8154 dgst_size = DGST_SIZE_4_4;
8155 parse_func = dcc2_parse_hash;
8156 sort_by_digest = sort_by_digest_4_4;
8157 opti_type = OPTI_TYPE_ZERO_BYTE
8158 | OPTI_TYPE_SLOW_HASH_SIMD;
8159 dgst_pos0 = 0;
8160 dgst_pos1 = 1;
8161 dgst_pos2 = 2;
8162 dgst_pos3 = 3;
8163 break;
8164
8165 case 2400: hash_type = HASH_TYPE_MD5;
8166 salt_type = SALT_TYPE_NONE;
8167 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8168 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8169 kern_type = KERN_TYPE_MD5PIX;
8170 dgst_size = DGST_SIZE_4_4;
8171 parse_func = md5pix_parse_hash;
8172 sort_by_digest = sort_by_digest_4_4;
8173 opti_type = OPTI_TYPE_ZERO_BYTE
8174 | OPTI_TYPE_PRECOMPUTE_INIT
8175 | OPTI_TYPE_PRECOMPUTE_MERKLE
8176 | OPTI_TYPE_EARLY_SKIP
8177 | OPTI_TYPE_NOT_ITERATED
8178 | OPTI_TYPE_NOT_SALTED;
8179 dgst_pos0 = 0;
8180 dgst_pos1 = 3;
8181 dgst_pos2 = 2;
8182 dgst_pos3 = 1;
8183 break;
8184
8185 case 2410: hash_type = HASH_TYPE_MD5;
8186 salt_type = SALT_TYPE_INTERN;
8187 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8188 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8189 kern_type = KERN_TYPE_MD5ASA;
8190 dgst_size = DGST_SIZE_4_4;
8191 parse_func = md5asa_parse_hash;
8192 sort_by_digest = sort_by_digest_4_4;
8193 opti_type = OPTI_TYPE_ZERO_BYTE
8194 | OPTI_TYPE_PRECOMPUTE_INIT
8195 | OPTI_TYPE_PRECOMPUTE_MERKLE
8196 | OPTI_TYPE_EARLY_SKIP
8197 | OPTI_TYPE_NOT_ITERATED;
8198 dgst_pos0 = 0;
8199 dgst_pos1 = 3;
8200 dgst_pos2 = 2;
8201 dgst_pos3 = 1;
8202 break;
8203
8204 case 2500: hash_type = HASH_TYPE_WPA;
8205 salt_type = SALT_TYPE_EMBEDDED;
8206 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8207 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8208 kern_type = KERN_TYPE_WPA;
8209 dgst_size = DGST_SIZE_4_4;
8210 parse_func = wpa_parse_hash;
8211 sort_by_digest = sort_by_digest_4_4;
8212 opti_type = OPTI_TYPE_ZERO_BYTE
8213 | OPTI_TYPE_SLOW_HASH_SIMD;
8214 dgst_pos0 = 0;
8215 dgst_pos1 = 1;
8216 dgst_pos2 = 2;
8217 dgst_pos3 = 3;
8218 break;
8219
8220 case 2600: hash_type = HASH_TYPE_MD5;
8221 salt_type = SALT_TYPE_VIRTUAL;
8222 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8223 opts_type = OPTS_TYPE_PT_GENERATE_LE
8224 | OPTS_TYPE_PT_ADD80
8225 | OPTS_TYPE_PT_ADDBITS14
8226 | OPTS_TYPE_ST_ADD80;
8227 kern_type = KERN_TYPE_MD55_PWSLT1;
8228 dgst_size = DGST_SIZE_4_4;
8229 parse_func = md5md5_parse_hash;
8230 sort_by_digest = sort_by_digest_4_4;
8231 opti_type = OPTI_TYPE_ZERO_BYTE
8232 | OPTI_TYPE_PRECOMPUTE_INIT
8233 | OPTI_TYPE_PRECOMPUTE_MERKLE
8234 | OPTI_TYPE_EARLY_SKIP;
8235 dgst_pos0 = 0;
8236 dgst_pos1 = 3;
8237 dgst_pos2 = 2;
8238 dgst_pos3 = 1;
8239 break;
8240
8241 case 2611: hash_type = HASH_TYPE_MD5;
8242 salt_type = SALT_TYPE_INTERN;
8243 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8244 opts_type = OPTS_TYPE_PT_GENERATE_LE
8245 | OPTS_TYPE_PT_ADD80
8246 | OPTS_TYPE_PT_ADDBITS14
8247 | OPTS_TYPE_ST_ADD80;
8248 kern_type = KERN_TYPE_MD55_PWSLT1;
8249 dgst_size = DGST_SIZE_4_4;
8250 parse_func = vb3_parse_hash;
8251 sort_by_digest = sort_by_digest_4_4;
8252 opti_type = OPTI_TYPE_ZERO_BYTE
8253 | OPTI_TYPE_PRECOMPUTE_INIT
8254 | OPTI_TYPE_PRECOMPUTE_MERKLE
8255 | OPTI_TYPE_EARLY_SKIP;
8256 dgst_pos0 = 0;
8257 dgst_pos1 = 3;
8258 dgst_pos2 = 2;
8259 dgst_pos3 = 1;
8260 break;
8261
8262 case 2612: hash_type = HASH_TYPE_MD5;
8263 salt_type = SALT_TYPE_EMBEDDED;
8264 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8265 opts_type = OPTS_TYPE_PT_GENERATE_LE
8266 | OPTS_TYPE_PT_ADD80
8267 | OPTS_TYPE_PT_ADDBITS14
8268 | OPTS_TYPE_ST_ADD80
8269 | OPTS_TYPE_ST_HEX;
8270 kern_type = KERN_TYPE_MD55_PWSLT1;
8271 dgst_size = DGST_SIZE_4_4;
8272 parse_func = phps_parse_hash;
8273 sort_by_digest = sort_by_digest_4_4;
8274 opti_type = OPTI_TYPE_ZERO_BYTE
8275 | OPTI_TYPE_PRECOMPUTE_INIT
8276 | OPTI_TYPE_PRECOMPUTE_MERKLE
8277 | OPTI_TYPE_EARLY_SKIP;
8278 dgst_pos0 = 0;
8279 dgst_pos1 = 3;
8280 dgst_pos2 = 2;
8281 dgst_pos3 = 1;
8282 break;
8283
8284 case 2711: hash_type = HASH_TYPE_MD5;
8285 salt_type = SALT_TYPE_INTERN;
8286 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8287 opts_type = OPTS_TYPE_PT_GENERATE_LE
8288 | OPTS_TYPE_PT_ADD80
8289 | OPTS_TYPE_PT_ADDBITS14
8290 | OPTS_TYPE_ST_ADD80;
8291 kern_type = KERN_TYPE_MD55_PWSLT2;
8292 dgst_size = DGST_SIZE_4_4;
8293 parse_func = vb30_parse_hash;
8294 sort_by_digest = sort_by_digest_4_4;
8295 opti_type = OPTI_TYPE_ZERO_BYTE
8296 | OPTI_TYPE_PRECOMPUTE_INIT
8297 | OPTI_TYPE_EARLY_SKIP;
8298 dgst_pos0 = 0;
8299 dgst_pos1 = 3;
8300 dgst_pos2 = 2;
8301 dgst_pos3 = 1;
8302 break;
8303
8304 case 2811: hash_type = HASH_TYPE_MD5;
8305 salt_type = SALT_TYPE_INTERN;
8306 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8307 opts_type = OPTS_TYPE_PT_GENERATE_LE
8308 | OPTS_TYPE_PT_ADD80
8309 | OPTS_TYPE_PT_ADDBITS14;
8310 kern_type = KERN_TYPE_MD55_SLTPW;
8311 dgst_size = DGST_SIZE_4_4;
8312 parse_func = ipb2_parse_hash;
8313 sort_by_digest = sort_by_digest_4_4;
8314 opti_type = OPTI_TYPE_ZERO_BYTE
8315 | OPTI_TYPE_PRECOMPUTE_INIT
8316 | OPTI_TYPE_EARLY_SKIP;
8317 dgst_pos0 = 0;
8318 dgst_pos1 = 3;
8319 dgst_pos2 = 2;
8320 dgst_pos3 = 1;
8321 break;
8322
8323 case 3000: hash_type = HASH_TYPE_LM;
8324 salt_type = SALT_TYPE_NONE;
8325 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8326 opts_type = OPTS_TYPE_PT_GENERATE_LE
8327 | OPTS_TYPE_PT_UPPER
8328 | OPTS_TYPE_PT_BITSLICE;
8329 kern_type = KERN_TYPE_LM;
8330 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8331 parse_func = lm_parse_hash;
8332 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8333 opti_type = OPTI_TYPE_ZERO_BYTE
8334 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8335 dgst_pos0 = 0;
8336 dgst_pos1 = 1;
8337 dgst_pos2 = 2;
8338 dgst_pos3 = 3;
8339 break;
8340
8341 case 3100: hash_type = HASH_TYPE_ORACLEH;
8342 salt_type = SALT_TYPE_INTERN;
8343 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8344 opts_type = OPTS_TYPE_PT_GENERATE_LE
8345 | OPTS_TYPE_PT_UPPER
8346 | OPTS_TYPE_ST_UPPER;
8347 kern_type = KERN_TYPE_ORACLEH;
8348 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8349 parse_func = oracleh_parse_hash;
8350 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8351 opti_type = OPTI_TYPE_ZERO_BYTE;
8352 dgst_pos0 = 0;
8353 dgst_pos1 = 1;
8354 dgst_pos2 = 2;
8355 dgst_pos3 = 3;
8356 break;
8357
8358 case 3200: hash_type = HASH_TYPE_BCRYPT;
8359 salt_type = SALT_TYPE_EMBEDDED;
8360 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8361 opts_type = OPTS_TYPE_PT_GENERATE_LE
8362 | OPTS_TYPE_ST_GENERATE_LE;
8363 kern_type = KERN_TYPE_BCRYPT;
8364 dgst_size = DGST_SIZE_4_6;
8365 parse_func = bcrypt_parse_hash;
8366 sort_by_digest = sort_by_digest_4_6;
8367 opti_type = OPTI_TYPE_ZERO_BYTE;
8368 dgst_pos0 = 0;
8369 dgst_pos1 = 1;
8370 dgst_pos2 = 2;
8371 dgst_pos3 = 3;
8372 break;
8373
8374 case 3710: hash_type = HASH_TYPE_MD5;
8375 salt_type = SALT_TYPE_INTERN;
8376 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8377 opts_type = OPTS_TYPE_PT_GENERATE_LE
8378 | OPTS_TYPE_PT_ADD80
8379 | OPTS_TYPE_PT_ADDBITS14;
8380 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8381 dgst_size = DGST_SIZE_4_4;
8382 parse_func = md5s_parse_hash;
8383 sort_by_digest = sort_by_digest_4_4;
8384 opti_type = OPTI_TYPE_ZERO_BYTE
8385 | OPTI_TYPE_PRECOMPUTE_INIT
8386 | OPTI_TYPE_PRECOMPUTE_MERKLE
8387 | OPTI_TYPE_EARLY_SKIP;
8388 dgst_pos0 = 0;
8389 dgst_pos1 = 3;
8390 dgst_pos2 = 2;
8391 dgst_pos3 = 1;
8392 break;
8393
8394 case 3711: hash_type = HASH_TYPE_MD5;
8395 salt_type = SALT_TYPE_EMBEDDED;
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 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8401 dgst_size = DGST_SIZE_4_4;
8402 parse_func = mediawiki_b_parse_hash;
8403 sort_by_digest = sort_by_digest_4_4;
8404 opti_type = OPTI_TYPE_ZERO_BYTE
8405 | OPTI_TYPE_PRECOMPUTE_INIT
8406 | OPTI_TYPE_PRECOMPUTE_MERKLE
8407 | OPTI_TYPE_EARLY_SKIP;
8408 dgst_pos0 = 0;
8409 dgst_pos1 = 3;
8410 dgst_pos2 = 2;
8411 dgst_pos3 = 1;
8412 break;
8413
8414 case 3800: hash_type = HASH_TYPE_MD5;
8415 salt_type = SALT_TYPE_INTERN;
8416 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8417 opts_type = OPTS_TYPE_PT_GENERATE_LE
8418 | OPTS_TYPE_ST_ADDBITS14;
8419 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8420 dgst_size = DGST_SIZE_4_4;
8421 parse_func = md5s_parse_hash;
8422 sort_by_digest = sort_by_digest_4_4;
8423 opti_type = OPTI_TYPE_ZERO_BYTE
8424 | OPTI_TYPE_PRECOMPUTE_INIT
8425 | OPTI_TYPE_PRECOMPUTE_MERKLE
8426 | OPTI_TYPE_EARLY_SKIP
8427 | OPTI_TYPE_NOT_ITERATED
8428 | OPTI_TYPE_RAW_HASH;
8429 dgst_pos0 = 0;
8430 dgst_pos1 = 3;
8431 dgst_pos2 = 2;
8432 dgst_pos3 = 1;
8433 break;
8434
8435 case 4300: hash_type = HASH_TYPE_MD5;
8436 salt_type = SALT_TYPE_VIRTUAL;
8437 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8438 opts_type = OPTS_TYPE_PT_GENERATE_LE
8439 | OPTS_TYPE_PT_ADD80
8440 | OPTS_TYPE_PT_ADDBITS14
8441 | OPTS_TYPE_ST_ADD80;
8442 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8443 dgst_size = DGST_SIZE_4_4;
8444 parse_func = md5md5_parse_hash;
8445 sort_by_digest = sort_by_digest_4_4;
8446 opti_type = OPTI_TYPE_ZERO_BYTE
8447 | OPTI_TYPE_PRECOMPUTE_INIT
8448 | OPTI_TYPE_PRECOMPUTE_MERKLE
8449 | OPTI_TYPE_EARLY_SKIP;
8450 dgst_pos0 = 0;
8451 dgst_pos1 = 3;
8452 dgst_pos2 = 2;
8453 dgst_pos3 = 1;
8454 break;
8455
8456
8457 case 4400: hash_type = HASH_TYPE_MD5;
8458 salt_type = SALT_TYPE_NONE;
8459 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8460 opts_type = OPTS_TYPE_PT_GENERATE_BE
8461 | OPTS_TYPE_PT_ADD80
8462 | OPTS_TYPE_PT_ADDBITS15;
8463 kern_type = KERN_TYPE_MD5_SHA1;
8464 dgst_size = DGST_SIZE_4_4;
8465 parse_func = md5_parse_hash;
8466 sort_by_digest = sort_by_digest_4_4;
8467 opti_type = OPTI_TYPE_ZERO_BYTE
8468 | OPTI_TYPE_PRECOMPUTE_INIT
8469 | OPTI_TYPE_PRECOMPUTE_MERKLE
8470 | OPTI_TYPE_EARLY_SKIP
8471 | OPTI_TYPE_NOT_ITERATED
8472 | OPTI_TYPE_NOT_SALTED
8473 | OPTI_TYPE_RAW_HASH;
8474 dgst_pos0 = 0;
8475 dgst_pos1 = 3;
8476 dgst_pos2 = 2;
8477 dgst_pos3 = 1;
8478 break;
8479
8480 case 4500: hash_type = HASH_TYPE_SHA1;
8481 salt_type = SALT_TYPE_NONE;
8482 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8483 opts_type = OPTS_TYPE_PT_GENERATE_BE
8484 | OPTS_TYPE_PT_ADD80
8485 | OPTS_TYPE_PT_ADDBITS15;
8486 kern_type = KERN_TYPE_SHA11;
8487 dgst_size = DGST_SIZE_4_5;
8488 parse_func = sha1_parse_hash;
8489 sort_by_digest = sort_by_digest_4_5;
8490 opti_type = OPTI_TYPE_ZERO_BYTE
8491 | OPTI_TYPE_PRECOMPUTE_INIT
8492 | OPTI_TYPE_PRECOMPUTE_MERKLE
8493 | OPTI_TYPE_EARLY_SKIP
8494 | OPTI_TYPE_NOT_SALTED;
8495 dgst_pos0 = 3;
8496 dgst_pos1 = 4;
8497 dgst_pos2 = 2;
8498 dgst_pos3 = 1;
8499 break;
8500
8501 case 4700: hash_type = HASH_TYPE_SHA1;
8502 salt_type = SALT_TYPE_NONE;
8503 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8504 opts_type = OPTS_TYPE_PT_GENERATE_LE
8505 | OPTS_TYPE_PT_ADD80
8506 | OPTS_TYPE_PT_ADDBITS14;
8507 kern_type = KERN_TYPE_SHA1_MD5;
8508 dgst_size = DGST_SIZE_4_5;
8509 parse_func = sha1_parse_hash;
8510 sort_by_digest = sort_by_digest_4_5;
8511 opti_type = OPTI_TYPE_ZERO_BYTE
8512 | OPTI_TYPE_PRECOMPUTE_INIT
8513 | OPTI_TYPE_PRECOMPUTE_MERKLE
8514 | OPTI_TYPE_EARLY_SKIP
8515 | OPTI_TYPE_NOT_ITERATED
8516 | OPTI_TYPE_NOT_SALTED
8517 | OPTI_TYPE_RAW_HASH;
8518 dgst_pos0 = 3;
8519 dgst_pos1 = 4;
8520 dgst_pos2 = 2;
8521 dgst_pos3 = 1;
8522 break;
8523
8524 case 4800: hash_type = HASH_TYPE_MD5;
8525 salt_type = SALT_TYPE_EMBEDDED;
8526 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8527 opts_type = OPTS_TYPE_PT_GENERATE_LE
8528 | OPTS_TYPE_PT_ADDBITS14;
8529 kern_type = KERN_TYPE_MD5_CHAP;
8530 dgst_size = DGST_SIZE_4_4;
8531 parse_func = chap_parse_hash;
8532 sort_by_digest = sort_by_digest_4_4;
8533 opti_type = OPTI_TYPE_ZERO_BYTE
8534 | OPTI_TYPE_PRECOMPUTE_INIT
8535 | OPTI_TYPE_PRECOMPUTE_MERKLE
8536 | OPTI_TYPE_MEET_IN_MIDDLE
8537 | OPTI_TYPE_EARLY_SKIP
8538 | OPTI_TYPE_NOT_ITERATED
8539 | OPTI_TYPE_RAW_HASH;
8540 dgst_pos0 = 0;
8541 dgst_pos1 = 3;
8542 dgst_pos2 = 2;
8543 dgst_pos3 = 1;
8544 break;
8545
8546 case 4900: hash_type = HASH_TYPE_SHA1;
8547 salt_type = SALT_TYPE_INTERN;
8548 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8549 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8550 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8551 dgst_size = DGST_SIZE_4_5;
8552 parse_func = sha1s_parse_hash;
8553 sort_by_digest = sort_by_digest_4_5;
8554 opti_type = OPTI_TYPE_ZERO_BYTE
8555 | OPTI_TYPE_PRECOMPUTE_INIT
8556 | OPTI_TYPE_PRECOMPUTE_MERKLE
8557 | OPTI_TYPE_EARLY_SKIP;
8558 dgst_pos0 = 3;
8559 dgst_pos1 = 4;
8560 dgst_pos2 = 2;
8561 dgst_pos3 = 1;
8562 break;
8563
8564 case 5000: hash_type = HASH_TYPE_KECCAK;
8565 salt_type = SALT_TYPE_EMBEDDED;
8566 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8567 opts_type = OPTS_TYPE_PT_GENERATE_LE
8568 | OPTS_TYPE_PT_ADD01;
8569 kern_type = KERN_TYPE_KECCAK;
8570 dgst_size = DGST_SIZE_8_25;
8571 parse_func = keccak_parse_hash;
8572 sort_by_digest = sort_by_digest_8_25;
8573 opti_type = OPTI_TYPE_ZERO_BYTE
8574 | OPTI_TYPE_USES_BITS_64
8575 | OPTI_TYPE_RAW_HASH;
8576 dgst_pos0 = 2;
8577 dgst_pos1 = 3;
8578 dgst_pos2 = 4;
8579 dgst_pos3 = 5;
8580 break;
8581
8582 case 5100: hash_type = HASH_TYPE_MD5H;
8583 salt_type = SALT_TYPE_NONE;
8584 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8585 opts_type = OPTS_TYPE_PT_GENERATE_LE
8586 | OPTS_TYPE_PT_ADD80
8587 | OPTS_TYPE_PT_ADDBITS14;
8588 kern_type = KERN_TYPE_MD5H;
8589 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8590 parse_func = md5half_parse_hash;
8591 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8592 opti_type = OPTI_TYPE_ZERO_BYTE
8593 | OPTI_TYPE_RAW_HASH;
8594 dgst_pos0 = 0;
8595 dgst_pos1 = 1;
8596 dgst_pos2 = 2;
8597 dgst_pos3 = 3;
8598 break;
8599
8600 case 5200: hash_type = HASH_TYPE_SHA256;
8601 salt_type = SALT_TYPE_EMBEDDED;
8602 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8603 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8604 kern_type = KERN_TYPE_PSAFE3;
8605 dgst_size = DGST_SIZE_4_8;
8606 parse_func = psafe3_parse_hash;
8607 sort_by_digest = sort_by_digest_4_8;
8608 opti_type = OPTI_TYPE_ZERO_BYTE;
8609 dgst_pos0 = 0;
8610 dgst_pos1 = 1;
8611 dgst_pos2 = 2;
8612 dgst_pos3 = 3;
8613 break;
8614
8615 case 5300: hash_type = HASH_TYPE_MD5;
8616 salt_type = SALT_TYPE_EMBEDDED;
8617 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8618 opts_type = OPTS_TYPE_PT_GENERATE_LE
8619 | OPTS_TYPE_ST_ADD80;
8620 kern_type = KERN_TYPE_IKEPSK_MD5;
8621 dgst_size = DGST_SIZE_4_4;
8622 parse_func = ikepsk_md5_parse_hash;
8623 sort_by_digest = sort_by_digest_4_4;
8624 opti_type = OPTI_TYPE_ZERO_BYTE;
8625 dgst_pos0 = 0;
8626 dgst_pos1 = 3;
8627 dgst_pos2 = 2;
8628 dgst_pos3 = 1;
8629 break;
8630
8631 case 5400: hash_type = HASH_TYPE_SHA1;
8632 salt_type = SALT_TYPE_EMBEDDED;
8633 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8634 opts_type = OPTS_TYPE_PT_GENERATE_BE
8635 | OPTS_TYPE_ST_ADD80;
8636 kern_type = KERN_TYPE_IKEPSK_SHA1;
8637 dgst_size = DGST_SIZE_4_5;
8638 parse_func = ikepsk_sha1_parse_hash;
8639 sort_by_digest = sort_by_digest_4_5;
8640 opti_type = OPTI_TYPE_ZERO_BYTE;
8641 dgst_pos0 = 3;
8642 dgst_pos1 = 4;
8643 dgst_pos2 = 2;
8644 dgst_pos3 = 1;
8645 break;
8646
8647 case 5500: hash_type = HASH_TYPE_NETNTLM;
8648 salt_type = SALT_TYPE_EMBEDDED;
8649 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8650 opts_type = OPTS_TYPE_PT_GENERATE_LE
8651 | OPTS_TYPE_PT_ADD80
8652 | OPTS_TYPE_PT_ADDBITS14
8653 | OPTS_TYPE_PT_UNICODE
8654 | OPTS_TYPE_ST_HEX;
8655 kern_type = KERN_TYPE_NETNTLMv1;
8656 dgst_size = DGST_SIZE_4_4;
8657 parse_func = netntlmv1_parse_hash;
8658 sort_by_digest = sort_by_digest_4_4;
8659 opti_type = OPTI_TYPE_ZERO_BYTE
8660 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8661 dgst_pos0 = 0;
8662 dgst_pos1 = 1;
8663 dgst_pos2 = 2;
8664 dgst_pos3 = 3;
8665 break;
8666
8667 case 5600: hash_type = HASH_TYPE_MD5;
8668 salt_type = SALT_TYPE_EMBEDDED;
8669 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8670 opts_type = OPTS_TYPE_PT_GENERATE_LE
8671 | OPTS_TYPE_PT_ADD80
8672 | OPTS_TYPE_PT_ADDBITS14
8673 | OPTS_TYPE_PT_UNICODE;
8674 kern_type = KERN_TYPE_NETNTLMv2;
8675 dgst_size = DGST_SIZE_4_4;
8676 parse_func = netntlmv2_parse_hash;
8677 sort_by_digest = sort_by_digest_4_4;
8678 opti_type = OPTI_TYPE_ZERO_BYTE;
8679 dgst_pos0 = 0;
8680 dgst_pos1 = 3;
8681 dgst_pos2 = 2;
8682 dgst_pos3 = 1;
8683 break;
8684
8685 case 5700: hash_type = HASH_TYPE_SHA256;
8686 salt_type = SALT_TYPE_NONE;
8687 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8688 opts_type = OPTS_TYPE_PT_GENERATE_BE
8689 | OPTS_TYPE_PT_ADD80
8690 | OPTS_TYPE_PT_ADDBITS15;
8691 kern_type = KERN_TYPE_SHA256;
8692 dgst_size = DGST_SIZE_4_8;
8693 parse_func = cisco4_parse_hash;
8694 sort_by_digest = sort_by_digest_4_8;
8695 opti_type = OPTI_TYPE_ZERO_BYTE
8696 | OPTI_TYPE_PRECOMPUTE_INIT
8697 | OPTI_TYPE_PRECOMPUTE_MERKLE
8698 | OPTI_TYPE_EARLY_SKIP
8699 | OPTI_TYPE_NOT_ITERATED
8700 | OPTI_TYPE_NOT_SALTED
8701 | OPTI_TYPE_RAW_HASH;
8702 dgst_pos0 = 3;
8703 dgst_pos1 = 7;
8704 dgst_pos2 = 2;
8705 dgst_pos3 = 6;
8706 break;
8707
8708 case 5800: hash_type = HASH_TYPE_SHA1;
8709 salt_type = SALT_TYPE_INTERN;
8710 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8711 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8712 | OPTS_TYPE_ST_ADD80;
8713 kern_type = KERN_TYPE_ANDROIDPIN;
8714 dgst_size = DGST_SIZE_4_5;
8715 parse_func = androidpin_parse_hash;
8716 sort_by_digest = sort_by_digest_4_5;
8717 opti_type = OPTI_TYPE_ZERO_BYTE;
8718 dgst_pos0 = 0;
8719 dgst_pos1 = 1;
8720 dgst_pos2 = 2;
8721 dgst_pos3 = 3;
8722 break;
8723
8724 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8725 salt_type = SALT_TYPE_NONE;
8726 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8727 opts_type = OPTS_TYPE_PT_GENERATE_LE
8728 | OPTS_TYPE_PT_ADD80;
8729 kern_type = KERN_TYPE_RIPEMD160;
8730 dgst_size = DGST_SIZE_4_5;
8731 parse_func = ripemd160_parse_hash;
8732 sort_by_digest = sort_by_digest_4_5;
8733 opti_type = OPTI_TYPE_ZERO_BYTE;
8734 dgst_pos0 = 0;
8735 dgst_pos1 = 1;
8736 dgst_pos2 = 2;
8737 dgst_pos3 = 3;
8738 break;
8739
8740 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8741 salt_type = SALT_TYPE_NONE;
8742 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8743 opts_type = OPTS_TYPE_PT_GENERATE_BE
8744 | OPTS_TYPE_PT_ADD80;
8745 kern_type = KERN_TYPE_WHIRLPOOL;
8746 dgst_size = DGST_SIZE_4_16;
8747 parse_func = whirlpool_parse_hash;
8748 sort_by_digest = sort_by_digest_4_16;
8749 opti_type = OPTI_TYPE_ZERO_BYTE;
8750 dgst_pos0 = 0;
8751 dgst_pos1 = 1;
8752 dgst_pos2 = 2;
8753 dgst_pos3 = 3;
8754 break;
8755
8756 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8757 salt_type = SALT_TYPE_EMBEDDED;
8758 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8759 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8760 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8761 dgst_size = DGST_SIZE_4_5;
8762 parse_func = truecrypt_parse_hash_2k;
8763 sort_by_digest = sort_by_digest_4_5;
8764 opti_type = OPTI_TYPE_ZERO_BYTE;
8765 dgst_pos0 = 0;
8766 dgst_pos1 = 1;
8767 dgst_pos2 = 2;
8768 dgst_pos3 = 3;
8769 break;
8770
8771 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8772 salt_type = SALT_TYPE_EMBEDDED;
8773 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8774 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8775 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8776 dgst_size = DGST_SIZE_4_5;
8777 parse_func = truecrypt_parse_hash_2k;
8778 sort_by_digest = sort_by_digest_4_5;
8779 opti_type = OPTI_TYPE_ZERO_BYTE;
8780 dgst_pos0 = 0;
8781 dgst_pos1 = 1;
8782 dgst_pos2 = 2;
8783 dgst_pos3 = 3;
8784 break;
8785
8786 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8787 salt_type = SALT_TYPE_EMBEDDED;
8788 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8789 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8790 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8791 dgst_size = DGST_SIZE_4_5;
8792 parse_func = truecrypt_parse_hash_2k;
8793 sort_by_digest = sort_by_digest_4_5;
8794 opti_type = OPTI_TYPE_ZERO_BYTE;
8795 dgst_pos0 = 0;
8796 dgst_pos1 = 1;
8797 dgst_pos2 = 2;
8798 dgst_pos3 = 3;
8799 break;
8800
8801 case 6221: hash_type = HASH_TYPE_SHA512;
8802 salt_type = SALT_TYPE_EMBEDDED;
8803 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8804 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8805 kern_type = KERN_TYPE_TCSHA512_XTS512;
8806 dgst_size = DGST_SIZE_8_8;
8807 parse_func = truecrypt_parse_hash_1k;
8808 sort_by_digest = sort_by_digest_8_8;
8809 opti_type = OPTI_TYPE_ZERO_BYTE
8810 | OPTI_TYPE_USES_BITS_64;
8811 dgst_pos0 = 0;
8812 dgst_pos1 = 1;
8813 dgst_pos2 = 2;
8814 dgst_pos3 = 3;
8815 break;
8816
8817 case 6222: hash_type = HASH_TYPE_SHA512;
8818 salt_type = SALT_TYPE_EMBEDDED;
8819 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8820 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8821 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8822 dgst_size = DGST_SIZE_8_8;
8823 parse_func = truecrypt_parse_hash_1k;
8824 sort_by_digest = sort_by_digest_8_8;
8825 opti_type = OPTI_TYPE_ZERO_BYTE
8826 | OPTI_TYPE_USES_BITS_64;
8827 dgst_pos0 = 0;
8828 dgst_pos1 = 1;
8829 dgst_pos2 = 2;
8830 dgst_pos3 = 3;
8831 break;
8832
8833 case 6223: hash_type = HASH_TYPE_SHA512;
8834 salt_type = SALT_TYPE_EMBEDDED;
8835 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8836 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8837 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8838 dgst_size = DGST_SIZE_8_8;
8839 parse_func = truecrypt_parse_hash_1k;
8840 sort_by_digest = sort_by_digest_8_8;
8841 opti_type = OPTI_TYPE_ZERO_BYTE
8842 | OPTI_TYPE_USES_BITS_64;
8843 dgst_pos0 = 0;
8844 dgst_pos1 = 1;
8845 dgst_pos2 = 2;
8846 dgst_pos3 = 3;
8847 break;
8848
8849 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8850 salt_type = SALT_TYPE_EMBEDDED;
8851 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8852 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8853 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8854 dgst_size = DGST_SIZE_4_8;
8855 parse_func = truecrypt_parse_hash_1k;
8856 sort_by_digest = sort_by_digest_4_8;
8857 opti_type = OPTI_TYPE_ZERO_BYTE;
8858 dgst_pos0 = 0;
8859 dgst_pos1 = 1;
8860 dgst_pos2 = 2;
8861 dgst_pos3 = 3;
8862 break;
8863
8864 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8865 salt_type = SALT_TYPE_EMBEDDED;
8866 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8867 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8868 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8869 dgst_size = DGST_SIZE_4_8;
8870 parse_func = truecrypt_parse_hash_1k;
8871 sort_by_digest = sort_by_digest_4_8;
8872 opti_type = OPTI_TYPE_ZERO_BYTE;
8873 dgst_pos0 = 0;
8874 dgst_pos1 = 1;
8875 dgst_pos2 = 2;
8876 dgst_pos3 = 3;
8877 break;
8878
8879 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8880 salt_type = SALT_TYPE_EMBEDDED;
8881 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8882 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8883 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8884 dgst_size = DGST_SIZE_4_8;
8885 parse_func = truecrypt_parse_hash_1k;
8886 sort_by_digest = sort_by_digest_4_8;
8887 opti_type = OPTI_TYPE_ZERO_BYTE;
8888 dgst_pos0 = 0;
8889 dgst_pos1 = 1;
8890 dgst_pos2 = 2;
8891 dgst_pos3 = 3;
8892 break;
8893
8894 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8895 salt_type = SALT_TYPE_EMBEDDED;
8896 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8897 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8898 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8899 dgst_size = DGST_SIZE_4_5;
8900 parse_func = truecrypt_parse_hash_1k;
8901 sort_by_digest = sort_by_digest_4_5;
8902 opti_type = OPTI_TYPE_ZERO_BYTE;
8903 dgst_pos0 = 0;
8904 dgst_pos1 = 1;
8905 dgst_pos2 = 2;
8906 dgst_pos3 = 3;
8907 break;
8908
8909 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8910 salt_type = SALT_TYPE_EMBEDDED;
8911 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8912 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8913 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8914 dgst_size = DGST_SIZE_4_5;
8915 parse_func = truecrypt_parse_hash_1k;
8916 sort_by_digest = sort_by_digest_4_5;
8917 opti_type = OPTI_TYPE_ZERO_BYTE;
8918 dgst_pos0 = 0;
8919 dgst_pos1 = 1;
8920 dgst_pos2 = 2;
8921 dgst_pos3 = 3;
8922 break;
8923
8924 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8925 salt_type = SALT_TYPE_EMBEDDED;
8926 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8927 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8928 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8929 dgst_size = DGST_SIZE_4_5;
8930 parse_func = truecrypt_parse_hash_1k;
8931 sort_by_digest = sort_by_digest_4_5;
8932 opti_type = OPTI_TYPE_ZERO_BYTE;
8933 dgst_pos0 = 0;
8934 dgst_pos1 = 1;
8935 dgst_pos2 = 2;
8936 dgst_pos3 = 3;
8937 break;
8938
8939 case 6300: hash_type = HASH_TYPE_MD5;
8940 salt_type = SALT_TYPE_EMBEDDED;
8941 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8942 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8943 kern_type = KERN_TYPE_MD5AIX;
8944 dgst_size = DGST_SIZE_4_4;
8945 parse_func = md5aix_parse_hash;
8946 sort_by_digest = sort_by_digest_4_4;
8947 opti_type = OPTI_TYPE_ZERO_BYTE;
8948 dgst_pos0 = 0;
8949 dgst_pos1 = 1;
8950 dgst_pos2 = 2;
8951 dgst_pos3 = 3;
8952 break;
8953
8954 case 6400: hash_type = HASH_TYPE_SHA256;
8955 salt_type = SALT_TYPE_EMBEDDED;
8956 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8957 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8958 kern_type = KERN_TYPE_SHA256AIX;
8959 dgst_size = DGST_SIZE_4_8;
8960 parse_func = sha256aix_parse_hash;
8961 sort_by_digest = sort_by_digest_4_8;
8962 opti_type = OPTI_TYPE_ZERO_BYTE;
8963 dgst_pos0 = 0;
8964 dgst_pos1 = 1;
8965 dgst_pos2 = 2;
8966 dgst_pos3 = 3;
8967 break;
8968
8969 case 6500: hash_type = HASH_TYPE_SHA512;
8970 salt_type = SALT_TYPE_EMBEDDED;
8971 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8972 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8973 kern_type = KERN_TYPE_SHA512AIX;
8974 dgst_size = DGST_SIZE_8_8;
8975 parse_func = sha512aix_parse_hash;
8976 sort_by_digest = sort_by_digest_8_8;
8977 opti_type = OPTI_TYPE_ZERO_BYTE
8978 | OPTI_TYPE_USES_BITS_64;
8979 dgst_pos0 = 0;
8980 dgst_pos1 = 1;
8981 dgst_pos2 = 2;
8982 dgst_pos3 = 3;
8983 break;
8984
8985 case 6600: hash_type = HASH_TYPE_AES;
8986 salt_type = SALT_TYPE_EMBEDDED;
8987 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8988 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8989 kern_type = KERN_TYPE_AGILEKEY;
8990 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8991 parse_func = agilekey_parse_hash;
8992 sort_by_digest = sort_by_digest_4_5;
8993 opti_type = OPTI_TYPE_ZERO_BYTE;
8994 dgst_pos0 = 0;
8995 dgst_pos1 = 1;
8996 dgst_pos2 = 2;
8997 dgst_pos3 = 3;
8998 break;
8999
9000 case 6700: hash_type = HASH_TYPE_SHA1;
9001 salt_type = SALT_TYPE_EMBEDDED;
9002 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9003 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9004 kern_type = KERN_TYPE_SHA1AIX;
9005 dgst_size = DGST_SIZE_4_5;
9006 parse_func = sha1aix_parse_hash;
9007 sort_by_digest = sort_by_digest_4_5;
9008 opti_type = OPTI_TYPE_ZERO_BYTE;
9009 dgst_pos0 = 0;
9010 dgst_pos1 = 1;
9011 dgst_pos2 = 2;
9012 dgst_pos3 = 3;
9013 break;
9014
9015 case 6800: hash_type = HASH_TYPE_AES;
9016 salt_type = SALT_TYPE_EMBEDDED;
9017 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9018 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9019 kern_type = KERN_TYPE_LASTPASS;
9020 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9021 parse_func = lastpass_parse_hash;
9022 sort_by_digest = sort_by_digest_4_8;
9023 opti_type = OPTI_TYPE_ZERO_BYTE;
9024 dgst_pos0 = 0;
9025 dgst_pos1 = 1;
9026 dgst_pos2 = 2;
9027 dgst_pos3 = 3;
9028 break;
9029
9030 case 6900: hash_type = HASH_TYPE_GOST;
9031 salt_type = SALT_TYPE_NONE;
9032 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9033 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9034 kern_type = KERN_TYPE_GOST;
9035 dgst_size = DGST_SIZE_4_8;
9036 parse_func = gost_parse_hash;
9037 sort_by_digest = sort_by_digest_4_8;
9038 opti_type = OPTI_TYPE_ZERO_BYTE;
9039 dgst_pos0 = 0;
9040 dgst_pos1 = 1;
9041 dgst_pos2 = 2;
9042 dgst_pos3 = 3;
9043 break;
9044
9045 case 7100: hash_type = HASH_TYPE_SHA512;
9046 salt_type = SALT_TYPE_EMBEDDED;
9047 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9048 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9049 kern_type = KERN_TYPE_PBKDF2_SHA512;
9050 dgst_size = DGST_SIZE_8_16;
9051 parse_func = sha512osx_parse_hash;
9052 sort_by_digest = sort_by_digest_8_16;
9053 opti_type = OPTI_TYPE_ZERO_BYTE
9054 | OPTI_TYPE_USES_BITS_64
9055 | OPTI_TYPE_SLOW_HASH_SIMD;
9056 dgst_pos0 = 0;
9057 dgst_pos1 = 1;
9058 dgst_pos2 = 2;
9059 dgst_pos3 = 3;
9060 break;
9061
9062 case 7200: hash_type = HASH_TYPE_SHA512;
9063 salt_type = SALT_TYPE_EMBEDDED;
9064 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9065 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9066 kern_type = KERN_TYPE_PBKDF2_SHA512;
9067 dgst_size = DGST_SIZE_8_16;
9068 parse_func = sha512grub_parse_hash;
9069 sort_by_digest = sort_by_digest_8_16;
9070 opti_type = OPTI_TYPE_ZERO_BYTE
9071 | OPTI_TYPE_USES_BITS_64
9072 | OPTI_TYPE_SLOW_HASH_SIMD;
9073 dgst_pos0 = 0;
9074 dgst_pos1 = 1;
9075 dgst_pos2 = 2;
9076 dgst_pos3 = 3;
9077 break;
9078
9079 case 7300: hash_type = HASH_TYPE_SHA1;
9080 salt_type = SALT_TYPE_EMBEDDED;
9081 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9082 opts_type = OPTS_TYPE_PT_GENERATE_BE
9083 | OPTS_TYPE_ST_ADD80
9084 | OPTS_TYPE_ST_ADDBITS15;
9085 kern_type = KERN_TYPE_RAKP;
9086 dgst_size = DGST_SIZE_4_5;
9087 parse_func = rakp_parse_hash;
9088 sort_by_digest = sort_by_digest_4_5;
9089 opti_type = OPTI_TYPE_ZERO_BYTE
9090 | OPTI_TYPE_NOT_ITERATED;
9091 dgst_pos0 = 3;
9092 dgst_pos1 = 4;
9093 dgst_pos2 = 2;
9094 dgst_pos3 = 1;
9095 break;
9096
9097 case 7400: hash_type = HASH_TYPE_SHA256;
9098 salt_type = SALT_TYPE_EMBEDDED;
9099 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9100 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9101 kern_type = KERN_TYPE_SHA256CRYPT;
9102 dgst_size = DGST_SIZE_4_8;
9103 parse_func = sha256crypt_parse_hash;
9104 sort_by_digest = sort_by_digest_4_8;
9105 opti_type = OPTI_TYPE_ZERO_BYTE;
9106 dgst_pos0 = 0;
9107 dgst_pos1 = 1;
9108 dgst_pos2 = 2;
9109 dgst_pos3 = 3;
9110 break;
9111
9112 case 7500: hash_type = HASH_TYPE_KRB5PA;
9113 salt_type = SALT_TYPE_EMBEDDED;
9114 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9115 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9116 kern_type = KERN_TYPE_KRB5PA;
9117 dgst_size = DGST_SIZE_4_4;
9118 parse_func = krb5pa_parse_hash;
9119 sort_by_digest = sort_by_digest_4_4;
9120 opti_type = OPTI_TYPE_ZERO_BYTE
9121 | OPTI_TYPE_NOT_ITERATED;
9122 dgst_pos0 = 0;
9123 dgst_pos1 = 1;
9124 dgst_pos2 = 2;
9125 dgst_pos3 = 3;
9126 break;
9127
9128 case 7600: hash_type = HASH_TYPE_SHA1;
9129 salt_type = SALT_TYPE_INTERN;
9130 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9131 opts_type = OPTS_TYPE_PT_GENERATE_BE
9132 | OPTS_TYPE_PT_ADD80
9133 | OPTS_TYPE_PT_ADDBITS15;
9134 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9135 dgst_size = DGST_SIZE_4_5;
9136 parse_func = redmine_parse_hash;
9137 sort_by_digest = sort_by_digest_4_5;
9138 opti_type = OPTI_TYPE_ZERO_BYTE
9139 | OPTI_TYPE_PRECOMPUTE_INIT
9140 | OPTI_TYPE_EARLY_SKIP
9141 | OPTI_TYPE_NOT_ITERATED
9142 | OPTI_TYPE_PREPENDED_SALT;
9143 dgst_pos0 = 3;
9144 dgst_pos1 = 4;
9145 dgst_pos2 = 2;
9146 dgst_pos3 = 1;
9147 break;
9148
9149 case 7700: hash_type = HASH_TYPE_SAPB;
9150 salt_type = SALT_TYPE_EMBEDDED;
9151 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9152 opts_type = OPTS_TYPE_PT_GENERATE_LE
9153 | OPTS_TYPE_PT_UPPER
9154 | OPTS_TYPE_ST_UPPER;
9155 kern_type = KERN_TYPE_SAPB;
9156 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9157 parse_func = sapb_parse_hash;
9158 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9159 opti_type = OPTI_TYPE_ZERO_BYTE
9160 | OPTI_TYPE_PRECOMPUTE_INIT
9161 | OPTI_TYPE_NOT_ITERATED;
9162 dgst_pos0 = 0;
9163 dgst_pos1 = 1;
9164 dgst_pos2 = 2;
9165 dgst_pos3 = 3;
9166 break;
9167
9168 case 7800: hash_type = HASH_TYPE_SAPG;
9169 salt_type = SALT_TYPE_EMBEDDED;
9170 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9171 opts_type = OPTS_TYPE_PT_GENERATE_BE
9172 | OPTS_TYPE_ST_ADD80
9173 | OPTS_TYPE_ST_UPPER;
9174 kern_type = KERN_TYPE_SAPG;
9175 dgst_size = DGST_SIZE_4_5;
9176 parse_func = sapg_parse_hash;
9177 sort_by_digest = sort_by_digest_4_5;
9178 opti_type = OPTI_TYPE_ZERO_BYTE
9179 | OPTI_TYPE_PRECOMPUTE_INIT
9180 | OPTI_TYPE_NOT_ITERATED;
9181 dgst_pos0 = 3;
9182 dgst_pos1 = 4;
9183 dgst_pos2 = 2;
9184 dgst_pos3 = 1;
9185 break;
9186
9187 case 7900: hash_type = HASH_TYPE_SHA512;
9188 salt_type = SALT_TYPE_EMBEDDED;
9189 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9190 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9191 kern_type = KERN_TYPE_DRUPAL7;
9192 dgst_size = DGST_SIZE_8_8;
9193 parse_func = drupal7_parse_hash;
9194 sort_by_digest = sort_by_digest_8_8;
9195 opti_type = OPTI_TYPE_ZERO_BYTE
9196 | OPTI_TYPE_USES_BITS_64;
9197 dgst_pos0 = 0;
9198 dgst_pos1 = 1;
9199 dgst_pos2 = 2;
9200 dgst_pos3 = 3;
9201 break;
9202
9203 case 8000: hash_type = HASH_TYPE_SHA256;
9204 salt_type = SALT_TYPE_EMBEDDED;
9205 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9206 opts_type = OPTS_TYPE_PT_GENERATE_BE
9207 | OPTS_TYPE_PT_UNICODE
9208 | OPTS_TYPE_ST_ADD80
9209 | OPTS_TYPE_ST_HEX;
9210 kern_type = KERN_TYPE_SYBASEASE;
9211 dgst_size = DGST_SIZE_4_8;
9212 parse_func = sybasease_parse_hash;
9213 sort_by_digest = sort_by_digest_4_8;
9214 opti_type = OPTI_TYPE_ZERO_BYTE
9215 | OPTI_TYPE_PRECOMPUTE_INIT
9216 | OPTI_TYPE_EARLY_SKIP
9217 | OPTI_TYPE_NOT_ITERATED
9218 | OPTI_TYPE_RAW_HASH;
9219 dgst_pos0 = 3;
9220 dgst_pos1 = 7;
9221 dgst_pos2 = 2;
9222 dgst_pos3 = 6;
9223 break;
9224
9225 case 8100: hash_type = HASH_TYPE_SHA1;
9226 salt_type = SALT_TYPE_EMBEDDED;
9227 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9228 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9229 kern_type = KERN_TYPE_NETSCALER;
9230 dgst_size = DGST_SIZE_4_5;
9231 parse_func = netscaler_parse_hash;
9232 sort_by_digest = sort_by_digest_4_5;
9233 opti_type = OPTI_TYPE_ZERO_BYTE
9234 | OPTI_TYPE_PRECOMPUTE_INIT
9235 | OPTI_TYPE_PRECOMPUTE_MERKLE
9236 | OPTI_TYPE_EARLY_SKIP
9237 | OPTI_TYPE_NOT_ITERATED
9238 | OPTI_TYPE_PREPENDED_SALT
9239 | OPTI_TYPE_RAW_HASH;
9240 dgst_pos0 = 3;
9241 dgst_pos1 = 4;
9242 dgst_pos2 = 2;
9243 dgst_pos3 = 1;
9244 break;
9245
9246 case 8200: hash_type = HASH_TYPE_SHA256;
9247 salt_type = SALT_TYPE_EMBEDDED;
9248 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9249 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9250 kern_type = KERN_TYPE_CLOUDKEY;
9251 dgst_size = DGST_SIZE_4_8;
9252 parse_func = cloudkey_parse_hash;
9253 sort_by_digest = sort_by_digest_4_8;
9254 opti_type = OPTI_TYPE_ZERO_BYTE;
9255 dgst_pos0 = 0;
9256 dgst_pos1 = 1;
9257 dgst_pos2 = 2;
9258 dgst_pos3 = 3;
9259 break;
9260
9261 case 8300: hash_type = HASH_TYPE_SHA1;
9262 salt_type = SALT_TYPE_EMBEDDED;
9263 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9264 opts_type = OPTS_TYPE_PT_GENERATE_BE
9265 | OPTS_TYPE_ST_HEX
9266 | OPTS_TYPE_ST_ADD80;
9267 kern_type = KERN_TYPE_NSEC3;
9268 dgst_size = DGST_SIZE_4_5;
9269 parse_func = nsec3_parse_hash;
9270 sort_by_digest = sort_by_digest_4_5;
9271 opti_type = OPTI_TYPE_ZERO_BYTE;
9272 dgst_pos0 = 3;
9273 dgst_pos1 = 4;
9274 dgst_pos2 = 2;
9275 dgst_pos3 = 1;
9276 break;
9277
9278 case 8400: hash_type = HASH_TYPE_SHA1;
9279 salt_type = SALT_TYPE_INTERN;
9280 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9281 opts_type = OPTS_TYPE_PT_GENERATE_BE
9282 | OPTS_TYPE_PT_ADD80
9283 | OPTS_TYPE_PT_ADDBITS15;
9284 kern_type = KERN_TYPE_WBB3;
9285 dgst_size = DGST_SIZE_4_5;
9286 parse_func = wbb3_parse_hash;
9287 sort_by_digest = sort_by_digest_4_5;
9288 opti_type = OPTI_TYPE_ZERO_BYTE
9289 | OPTI_TYPE_PRECOMPUTE_INIT
9290 | OPTI_TYPE_NOT_ITERATED;
9291 dgst_pos0 = 3;
9292 dgst_pos1 = 4;
9293 dgst_pos2 = 2;
9294 dgst_pos3 = 1;
9295 break;
9296
9297 case 8500: hash_type = HASH_TYPE_DESRACF;
9298 salt_type = SALT_TYPE_EMBEDDED;
9299 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9300 opts_type = OPTS_TYPE_PT_GENERATE_LE
9301 | OPTS_TYPE_ST_UPPER;
9302 kern_type = KERN_TYPE_RACF;
9303 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9304 parse_func = racf_parse_hash;
9305 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9306 opti_type = OPTI_TYPE_ZERO_BYTE
9307 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9308 dgst_pos0 = 0;
9309 dgst_pos1 = 1;
9310 dgst_pos2 = 2;
9311 dgst_pos3 = 3;
9312 break;
9313
9314 case 8600: hash_type = HASH_TYPE_LOTUS5;
9315 salt_type = SALT_TYPE_NONE;
9316 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9317 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9318 kern_type = KERN_TYPE_LOTUS5;
9319 dgst_size = DGST_SIZE_4_4;
9320 parse_func = lotus5_parse_hash;
9321 sort_by_digest = sort_by_digest_4_4;
9322 opti_type = OPTI_TYPE_EARLY_SKIP
9323 | OPTI_TYPE_NOT_ITERATED
9324 | OPTI_TYPE_NOT_SALTED
9325 | OPTI_TYPE_RAW_HASH;
9326 dgst_pos0 = 0;
9327 dgst_pos1 = 1;
9328 dgst_pos2 = 2;
9329 dgst_pos3 = 3;
9330 break;
9331
9332 case 8700: hash_type = HASH_TYPE_LOTUS6;
9333 salt_type = SALT_TYPE_EMBEDDED;
9334 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9335 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9336 kern_type = KERN_TYPE_LOTUS6;
9337 dgst_size = DGST_SIZE_4_4;
9338 parse_func = lotus6_parse_hash;
9339 sort_by_digest = sort_by_digest_4_4;
9340 opti_type = OPTI_TYPE_EARLY_SKIP
9341 | OPTI_TYPE_NOT_ITERATED
9342 | OPTI_TYPE_RAW_HASH;
9343 dgst_pos0 = 0;
9344 dgst_pos1 = 1;
9345 dgst_pos2 = 2;
9346 dgst_pos3 = 3;
9347 break;
9348
9349 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9350 salt_type = SALT_TYPE_EMBEDDED;
9351 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9352 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9353 kern_type = KERN_TYPE_ANDROIDFDE;
9354 dgst_size = DGST_SIZE_4_4;
9355 parse_func = androidfde_parse_hash;
9356 sort_by_digest = sort_by_digest_4_4;
9357 opti_type = OPTI_TYPE_ZERO_BYTE;
9358 dgst_pos0 = 0;
9359 dgst_pos1 = 1;
9360 dgst_pos2 = 2;
9361 dgst_pos3 = 3;
9362 break;
9363
9364 case 8900: hash_type = HASH_TYPE_SCRYPT;
9365 salt_type = SALT_TYPE_EMBEDDED;
9366 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9367 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9368 kern_type = KERN_TYPE_SCRYPT;
9369 dgst_size = DGST_SIZE_4_8;
9370 parse_func = scrypt_parse_hash;
9371 sort_by_digest = sort_by_digest_4_8;
9372 opti_type = OPTI_TYPE_ZERO_BYTE;
9373 dgst_pos0 = 0;
9374 dgst_pos1 = 1;
9375 dgst_pos2 = 2;
9376 dgst_pos3 = 3;
9377 break;
9378
9379 case 9000: hash_type = HASH_TYPE_SHA1;
9380 salt_type = SALT_TYPE_EMBEDDED;
9381 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9382 opts_type = OPTS_TYPE_PT_GENERATE_LE
9383 | OPTS_TYPE_ST_GENERATE_LE;
9384 kern_type = KERN_TYPE_PSAFE2;
9385 dgst_size = DGST_SIZE_4_5;
9386 parse_func = psafe2_parse_hash;
9387 sort_by_digest = sort_by_digest_4_5;
9388 opti_type = OPTI_TYPE_ZERO_BYTE;
9389 dgst_pos0 = 0;
9390 dgst_pos1 = 1;
9391 dgst_pos2 = 2;
9392 dgst_pos3 = 3;
9393 break;
9394
9395 case 9100: hash_type = HASH_TYPE_LOTUS8;
9396 salt_type = SALT_TYPE_EMBEDDED;
9397 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9398 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9399 kern_type = KERN_TYPE_LOTUS8;
9400 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9401 parse_func = lotus8_parse_hash;
9402 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9403 opti_type = OPTI_TYPE_ZERO_BYTE;
9404 dgst_pos0 = 0;
9405 dgst_pos1 = 1;
9406 dgst_pos2 = 2;
9407 dgst_pos3 = 3;
9408 break;
9409
9410 case 9200: hash_type = HASH_TYPE_SHA256;
9411 salt_type = SALT_TYPE_EMBEDDED;
9412 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9413 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9414 kern_type = KERN_TYPE_PBKDF2_SHA256;
9415 dgst_size = DGST_SIZE_4_32;
9416 parse_func = cisco8_parse_hash;
9417 sort_by_digest = sort_by_digest_4_32;
9418 opti_type = OPTI_TYPE_ZERO_BYTE
9419 | OPTI_TYPE_SLOW_HASH_SIMD;
9420 dgst_pos0 = 0;
9421 dgst_pos1 = 1;
9422 dgst_pos2 = 2;
9423 dgst_pos3 = 3;
9424 break;
9425
9426 case 9300: hash_type = HASH_TYPE_SCRYPT;
9427 salt_type = SALT_TYPE_EMBEDDED;
9428 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9429 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9430 kern_type = KERN_TYPE_SCRYPT;
9431 dgst_size = DGST_SIZE_4_8;
9432 parse_func = cisco9_parse_hash;
9433 sort_by_digest = sort_by_digest_4_8;
9434 opti_type = OPTI_TYPE_ZERO_BYTE;
9435 dgst_pos0 = 0;
9436 dgst_pos1 = 1;
9437 dgst_pos2 = 2;
9438 dgst_pos3 = 3;
9439 break;
9440
9441 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9442 salt_type = SALT_TYPE_EMBEDDED;
9443 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9444 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9445 kern_type = KERN_TYPE_OFFICE2007;
9446 dgst_size = DGST_SIZE_4_4;
9447 parse_func = office2007_parse_hash;
9448 sort_by_digest = sort_by_digest_4_4;
9449 opti_type = OPTI_TYPE_ZERO_BYTE;
9450 dgst_pos0 = 0;
9451 dgst_pos1 = 1;
9452 dgst_pos2 = 2;
9453 dgst_pos3 = 3;
9454 break;
9455
9456 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9457 salt_type = SALT_TYPE_EMBEDDED;
9458 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9459 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9460 kern_type = KERN_TYPE_OFFICE2010;
9461 dgst_size = DGST_SIZE_4_4;
9462 parse_func = office2010_parse_hash;
9463 sort_by_digest = sort_by_digest_4_4;
9464 opti_type = OPTI_TYPE_ZERO_BYTE;
9465 dgst_pos0 = 0;
9466 dgst_pos1 = 1;
9467 dgst_pos2 = 2;
9468 dgst_pos3 = 3;
9469 break;
9470
9471 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9472 salt_type = SALT_TYPE_EMBEDDED;
9473 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9474 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9475 kern_type = KERN_TYPE_OFFICE2013;
9476 dgst_size = DGST_SIZE_4_4;
9477 parse_func = office2013_parse_hash;
9478 sort_by_digest = sort_by_digest_4_4;
9479 opti_type = OPTI_TYPE_ZERO_BYTE;
9480 dgst_pos0 = 0;
9481 dgst_pos1 = 1;
9482 dgst_pos2 = 2;
9483 dgst_pos3 = 3;
9484 break;
9485
9486 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9487 salt_type = SALT_TYPE_EMBEDDED;
9488 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9489 opts_type = OPTS_TYPE_PT_GENERATE_LE
9490 | OPTS_TYPE_PT_ADD80
9491 | OPTS_TYPE_PT_UNICODE;
9492 kern_type = KERN_TYPE_OLDOFFICE01;
9493 dgst_size = DGST_SIZE_4_4;
9494 parse_func = oldoffice01_parse_hash;
9495 sort_by_digest = sort_by_digest_4_4;
9496 opti_type = OPTI_TYPE_ZERO_BYTE
9497 | OPTI_TYPE_PRECOMPUTE_INIT
9498 | OPTI_TYPE_NOT_ITERATED;
9499 dgst_pos0 = 0;
9500 dgst_pos1 = 1;
9501 dgst_pos2 = 2;
9502 dgst_pos3 = 3;
9503 break;
9504
9505 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9506 salt_type = SALT_TYPE_EMBEDDED;
9507 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9508 opts_type = OPTS_TYPE_PT_GENERATE_LE
9509 | OPTS_TYPE_PT_ADD80;
9510 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9511 dgst_size = DGST_SIZE_4_4;
9512 parse_func = oldoffice01cm1_parse_hash;
9513 sort_by_digest = sort_by_digest_4_4;
9514 opti_type = OPTI_TYPE_ZERO_BYTE
9515 | OPTI_TYPE_PRECOMPUTE_INIT
9516 | OPTI_TYPE_NOT_ITERATED;
9517 dgst_pos0 = 0;
9518 dgst_pos1 = 1;
9519 dgst_pos2 = 2;
9520 dgst_pos3 = 3;
9521 break;
9522
9523 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9524 salt_type = SALT_TYPE_EMBEDDED;
9525 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9526 opts_type = OPTS_TYPE_PT_GENERATE_LE
9527 | OPTS_TYPE_PT_ADD80
9528 | OPTS_TYPE_PT_UNICODE
9529 | OPTS_TYPE_PT_NEVERCRACK;
9530 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9531 dgst_size = DGST_SIZE_4_4;
9532 parse_func = oldoffice01cm2_parse_hash;
9533 sort_by_digest = sort_by_digest_4_4;
9534 opti_type = OPTI_TYPE_ZERO_BYTE
9535 | OPTI_TYPE_PRECOMPUTE_INIT
9536 | OPTI_TYPE_NOT_ITERATED;
9537 dgst_pos0 = 0;
9538 dgst_pos1 = 1;
9539 dgst_pos2 = 2;
9540 dgst_pos3 = 3;
9541 break;
9542
9543 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9544 salt_type = SALT_TYPE_EMBEDDED;
9545 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9546 opts_type = OPTS_TYPE_PT_GENERATE_BE
9547 | OPTS_TYPE_PT_ADD80
9548 | OPTS_TYPE_PT_UNICODE;
9549 kern_type = KERN_TYPE_OLDOFFICE34;
9550 dgst_size = DGST_SIZE_4_4;
9551 parse_func = oldoffice34_parse_hash;
9552 sort_by_digest = sort_by_digest_4_4;
9553 opti_type = OPTI_TYPE_ZERO_BYTE
9554 | OPTI_TYPE_PRECOMPUTE_INIT
9555 | OPTI_TYPE_NOT_ITERATED;
9556 dgst_pos0 = 0;
9557 dgst_pos1 = 1;
9558 dgst_pos2 = 2;
9559 dgst_pos3 = 3;
9560 break;
9561
9562 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9563 salt_type = SALT_TYPE_EMBEDDED;
9564 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9565 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9566 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9567 dgst_size = DGST_SIZE_4_4;
9568 parse_func = oldoffice34cm1_parse_hash;
9569 sort_by_digest = sort_by_digest_4_4;
9570 opti_type = OPTI_TYPE_ZERO_BYTE
9571 | OPTI_TYPE_PRECOMPUTE_INIT
9572 | OPTI_TYPE_NOT_ITERATED;
9573 dgst_pos0 = 0;
9574 dgst_pos1 = 1;
9575 dgst_pos2 = 2;
9576 dgst_pos3 = 3;
9577 break;
9578
9579 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9580 salt_type = SALT_TYPE_EMBEDDED;
9581 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9582 opts_type = OPTS_TYPE_PT_GENERATE_BE
9583 | OPTS_TYPE_PT_ADD80
9584 | OPTS_TYPE_PT_UNICODE
9585 | OPTS_TYPE_PT_NEVERCRACK;
9586 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9587 dgst_size = DGST_SIZE_4_4;
9588 parse_func = oldoffice34cm2_parse_hash;
9589 sort_by_digest = sort_by_digest_4_4;
9590 opti_type = OPTI_TYPE_ZERO_BYTE
9591 | OPTI_TYPE_PRECOMPUTE_INIT
9592 | OPTI_TYPE_NOT_ITERATED;
9593 dgst_pos0 = 0;
9594 dgst_pos1 = 1;
9595 dgst_pos2 = 2;
9596 dgst_pos3 = 3;
9597 break;
9598
9599 case 9900: hash_type = HASH_TYPE_MD5;
9600 salt_type = SALT_TYPE_NONE;
9601 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9602 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9603 kern_type = KERN_TYPE_RADMIN2;
9604 dgst_size = DGST_SIZE_4_4;
9605 parse_func = radmin2_parse_hash;
9606 sort_by_digest = sort_by_digest_4_4;
9607 opti_type = OPTI_TYPE_ZERO_BYTE
9608 | OPTI_TYPE_PRECOMPUTE_INIT
9609 | OPTI_TYPE_EARLY_SKIP
9610 | OPTI_TYPE_NOT_ITERATED
9611 | OPTI_TYPE_NOT_SALTED;
9612 dgst_pos0 = 0;
9613 dgst_pos1 = 3;
9614 dgst_pos2 = 2;
9615 dgst_pos3 = 1;
9616 break;
9617
9618 case 10000: hash_type = HASH_TYPE_SHA256;
9619 salt_type = SALT_TYPE_EMBEDDED;
9620 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9621 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9622 kern_type = KERN_TYPE_PBKDF2_SHA256;
9623 dgst_size = DGST_SIZE_4_32;
9624 parse_func = djangopbkdf2_parse_hash;
9625 sort_by_digest = sort_by_digest_4_32;
9626 opti_type = OPTI_TYPE_ZERO_BYTE
9627 | OPTI_TYPE_SLOW_HASH_SIMD;
9628 dgst_pos0 = 0;
9629 dgst_pos1 = 1;
9630 dgst_pos2 = 2;
9631 dgst_pos3 = 3;
9632 break;
9633
9634 case 10100: hash_type = HASH_TYPE_SIPHASH;
9635 salt_type = SALT_TYPE_EMBEDDED;
9636 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9637 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9638 kern_type = KERN_TYPE_SIPHASH;
9639 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9640 parse_func = siphash_parse_hash;
9641 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9642 opti_type = OPTI_TYPE_ZERO_BYTE
9643 | OPTI_TYPE_NOT_ITERATED
9644 | OPTI_TYPE_RAW_HASH;
9645 dgst_pos0 = 0;
9646 dgst_pos1 = 1;
9647 dgst_pos2 = 2;
9648 dgst_pos3 = 3;
9649 break;
9650
9651 case 10200: hash_type = HASH_TYPE_MD5;
9652 salt_type = SALT_TYPE_EMBEDDED;
9653 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9654 opts_type = OPTS_TYPE_PT_GENERATE_LE
9655 | OPTS_TYPE_ST_ADD80
9656 | OPTS_TYPE_ST_ADDBITS14;
9657 kern_type = KERN_TYPE_HMACMD5_PW;
9658 dgst_size = DGST_SIZE_4_4;
9659 parse_func = crammd5_parse_hash;
9660 sort_by_digest = sort_by_digest_4_4;
9661 opti_type = OPTI_TYPE_ZERO_BYTE
9662 | OPTI_TYPE_NOT_ITERATED;
9663 dgst_pos0 = 0;
9664 dgst_pos1 = 3;
9665 dgst_pos2 = 2;
9666 dgst_pos3 = 1;
9667 break;
9668
9669 case 10300: hash_type = HASH_TYPE_SHA1;
9670 salt_type = SALT_TYPE_EMBEDDED;
9671 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9672 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9673 kern_type = KERN_TYPE_SAPH_SHA1;
9674 dgst_size = DGST_SIZE_4_5;
9675 parse_func = saph_sha1_parse_hash;
9676 sort_by_digest = sort_by_digest_4_5;
9677 opti_type = OPTI_TYPE_ZERO_BYTE;
9678 dgst_pos0 = 0;
9679 dgst_pos1 = 1;
9680 dgst_pos2 = 2;
9681 dgst_pos3 = 3;
9682 break;
9683
9684 case 10400: hash_type = HASH_TYPE_PDFU16;
9685 salt_type = SALT_TYPE_EMBEDDED;
9686 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9687 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9688 kern_type = KERN_TYPE_PDF11;
9689 dgst_size = DGST_SIZE_4_4;
9690 parse_func = pdf11_parse_hash;
9691 sort_by_digest = sort_by_digest_4_4;
9692 opti_type = OPTI_TYPE_ZERO_BYTE
9693 | OPTI_TYPE_NOT_ITERATED;
9694 dgst_pos0 = 0;
9695 dgst_pos1 = 1;
9696 dgst_pos2 = 2;
9697 dgst_pos3 = 3;
9698 break;
9699
9700 case 10410: hash_type = HASH_TYPE_PDFU16;
9701 salt_type = SALT_TYPE_EMBEDDED;
9702 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9703 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9704 kern_type = KERN_TYPE_PDF11CM1;
9705 dgst_size = DGST_SIZE_4_4;
9706 parse_func = pdf11cm1_parse_hash;
9707 sort_by_digest = sort_by_digest_4_4;
9708 opti_type = OPTI_TYPE_ZERO_BYTE
9709 | OPTI_TYPE_NOT_ITERATED;
9710 dgst_pos0 = 0;
9711 dgst_pos1 = 1;
9712 dgst_pos2 = 2;
9713 dgst_pos3 = 3;
9714 break;
9715
9716 case 10420: hash_type = HASH_TYPE_PDFU16;
9717 salt_type = SALT_TYPE_EMBEDDED;
9718 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9719 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9720 kern_type = KERN_TYPE_PDF11CM2;
9721 dgst_size = DGST_SIZE_4_4;
9722 parse_func = pdf11cm2_parse_hash;
9723 sort_by_digest = sort_by_digest_4_4;
9724 opti_type = OPTI_TYPE_ZERO_BYTE
9725 | OPTI_TYPE_NOT_ITERATED;
9726 dgst_pos0 = 0;
9727 dgst_pos1 = 1;
9728 dgst_pos2 = 2;
9729 dgst_pos3 = 3;
9730 break;
9731
9732 case 10500: hash_type = HASH_TYPE_PDFU16;
9733 salt_type = SALT_TYPE_EMBEDDED;
9734 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9735 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9736 kern_type = KERN_TYPE_PDF14;
9737 dgst_size = DGST_SIZE_4_4;
9738 parse_func = pdf14_parse_hash;
9739 sort_by_digest = sort_by_digest_4_4;
9740 opti_type = OPTI_TYPE_ZERO_BYTE
9741 | OPTI_TYPE_NOT_ITERATED;
9742 dgst_pos0 = 0;
9743 dgst_pos1 = 1;
9744 dgst_pos2 = 2;
9745 dgst_pos3 = 3;
9746 break;
9747
9748 case 10600: hash_type = HASH_TYPE_SHA256;
9749 salt_type = SALT_TYPE_EMBEDDED;
9750 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9751 opts_type = OPTS_TYPE_PT_GENERATE_BE
9752 | OPTS_TYPE_ST_ADD80
9753 | OPTS_TYPE_ST_ADDBITS15
9754 | OPTS_TYPE_HASH_COPY;
9755 kern_type = KERN_TYPE_SHA256_PWSLT;
9756 dgst_size = DGST_SIZE_4_8;
9757 parse_func = pdf17l3_parse_hash;
9758 sort_by_digest = sort_by_digest_4_8;
9759 opti_type = OPTI_TYPE_ZERO_BYTE
9760 | OPTI_TYPE_PRECOMPUTE_INIT
9761 | OPTI_TYPE_PRECOMPUTE_MERKLE
9762 | OPTI_TYPE_EARLY_SKIP
9763 | OPTI_TYPE_NOT_ITERATED
9764 | OPTI_TYPE_APPENDED_SALT
9765 | OPTI_TYPE_RAW_HASH;
9766 dgst_pos0 = 3;
9767 dgst_pos1 = 7;
9768 dgst_pos2 = 2;
9769 dgst_pos3 = 6;
9770 break;
9771
9772 case 10700: hash_type = HASH_TYPE_PDFU32;
9773 salt_type = SALT_TYPE_EMBEDDED;
9774 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9775 opts_type = OPTS_TYPE_PT_GENERATE_LE
9776 | OPTS_TYPE_HASH_COPY;
9777 kern_type = KERN_TYPE_PDF17L8;
9778 dgst_size = DGST_SIZE_4_8;
9779 parse_func = pdf17l8_parse_hash;
9780 sort_by_digest = sort_by_digest_4_8;
9781 opti_type = OPTI_TYPE_ZERO_BYTE
9782 | OPTI_TYPE_NOT_ITERATED;
9783 dgst_pos0 = 0;
9784 dgst_pos1 = 1;
9785 dgst_pos2 = 2;
9786 dgst_pos3 = 3;
9787 break;
9788
9789 case 10800: hash_type = HASH_TYPE_SHA384;
9790 salt_type = SALT_TYPE_NONE;
9791 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9792 opts_type = OPTS_TYPE_PT_GENERATE_BE
9793 | OPTS_TYPE_PT_ADD80
9794 | OPTS_TYPE_PT_ADDBITS15;
9795 kern_type = KERN_TYPE_SHA384;
9796 dgst_size = DGST_SIZE_8_8;
9797 parse_func = sha384_parse_hash;
9798 sort_by_digest = sort_by_digest_8_8;
9799 opti_type = OPTI_TYPE_ZERO_BYTE
9800 | OPTI_TYPE_PRECOMPUTE_INIT
9801 | OPTI_TYPE_PRECOMPUTE_MERKLE
9802 | OPTI_TYPE_EARLY_SKIP
9803 | OPTI_TYPE_NOT_ITERATED
9804 | OPTI_TYPE_NOT_SALTED
9805 | OPTI_TYPE_USES_BITS_64
9806 | OPTI_TYPE_RAW_HASH;
9807 dgst_pos0 = 6;
9808 dgst_pos1 = 7;
9809 dgst_pos2 = 4;
9810 dgst_pos3 = 5;
9811 break;
9812
9813 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9814 salt_type = SALT_TYPE_EMBEDDED;
9815 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9816 opts_type = OPTS_TYPE_PT_GENERATE_LE
9817 | OPTS_TYPE_ST_BASE64
9818 | OPTS_TYPE_HASH_COPY;
9819 kern_type = KERN_TYPE_PBKDF2_SHA256;
9820 dgst_size = DGST_SIZE_4_32;
9821 parse_func = pbkdf2_sha256_parse_hash;
9822 sort_by_digest = sort_by_digest_4_32;
9823 opti_type = OPTI_TYPE_ZERO_BYTE
9824 | OPTI_TYPE_SLOW_HASH_SIMD;
9825 dgst_pos0 = 0;
9826 dgst_pos1 = 1;
9827 dgst_pos2 = 2;
9828 dgst_pos3 = 3;
9829 break;
9830
9831 case 11000: hash_type = HASH_TYPE_MD5;
9832 salt_type = SALT_TYPE_INTERN;
9833 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9834 opts_type = OPTS_TYPE_PT_GENERATE_LE
9835 | OPTS_TYPE_PT_ADD80;
9836 kern_type = KERN_TYPE_PRESTASHOP;
9837 dgst_size = DGST_SIZE_4_4;
9838 parse_func = prestashop_parse_hash;
9839 sort_by_digest = sort_by_digest_4_4;
9840 opti_type = OPTI_TYPE_ZERO_BYTE
9841 | OPTI_TYPE_PRECOMPUTE_INIT
9842 | OPTI_TYPE_NOT_ITERATED
9843 | OPTI_TYPE_PREPENDED_SALT;
9844 dgst_pos0 = 0;
9845 dgst_pos1 = 3;
9846 dgst_pos2 = 2;
9847 dgst_pos3 = 1;
9848 break;
9849
9850 case 11100: hash_type = HASH_TYPE_MD5;
9851 salt_type = SALT_TYPE_EMBEDDED;
9852 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9853 opts_type = OPTS_TYPE_PT_GENERATE_LE
9854 | OPTS_TYPE_ST_ADD80;
9855 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9856 dgst_size = DGST_SIZE_4_4;
9857 parse_func = postgresql_auth_parse_hash;
9858 sort_by_digest = sort_by_digest_4_4;
9859 opti_type = OPTI_TYPE_ZERO_BYTE
9860 | OPTI_TYPE_PRECOMPUTE_INIT
9861 | OPTI_TYPE_PRECOMPUTE_MERKLE
9862 | OPTI_TYPE_EARLY_SKIP;
9863 dgst_pos0 = 0;
9864 dgst_pos1 = 3;
9865 dgst_pos2 = 2;
9866 dgst_pos3 = 1;
9867 break;
9868
9869 case 11200: hash_type = HASH_TYPE_SHA1;
9870 salt_type = SALT_TYPE_EMBEDDED;
9871 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9872 opts_type = OPTS_TYPE_PT_GENERATE_BE
9873 | OPTS_TYPE_PT_ADD80
9874 | OPTS_TYPE_ST_HEX;
9875 kern_type = KERN_TYPE_MYSQL_AUTH;
9876 dgst_size = DGST_SIZE_4_5;
9877 parse_func = mysql_auth_parse_hash;
9878 sort_by_digest = sort_by_digest_4_5;
9879 opti_type = OPTI_TYPE_ZERO_BYTE
9880 | OPTI_TYPE_EARLY_SKIP;
9881 dgst_pos0 = 3;
9882 dgst_pos1 = 4;
9883 dgst_pos2 = 2;
9884 dgst_pos3 = 1;
9885 break;
9886
9887 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9888 salt_type = SALT_TYPE_EMBEDDED;
9889 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9890 opts_type = OPTS_TYPE_PT_GENERATE_LE
9891 | OPTS_TYPE_ST_HEX
9892 | OPTS_TYPE_ST_ADD80;
9893 kern_type = KERN_TYPE_BITCOIN_WALLET;
9894 dgst_size = DGST_SIZE_4_4;
9895 parse_func = bitcoin_wallet_parse_hash;
9896 sort_by_digest = sort_by_digest_4_4;
9897 opti_type = OPTI_TYPE_ZERO_BYTE;
9898 dgst_pos0 = 0;
9899 dgst_pos1 = 1;
9900 dgst_pos2 = 2;
9901 dgst_pos3 = 3;
9902 break;
9903
9904 case 11400: hash_type = HASH_TYPE_MD5;
9905 salt_type = SALT_TYPE_EMBEDDED;
9906 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9907 opts_type = OPTS_TYPE_PT_GENERATE_LE
9908 | OPTS_TYPE_PT_ADD80
9909 | OPTS_TYPE_HASH_COPY;
9910 kern_type = KERN_TYPE_SIP_AUTH;
9911 dgst_size = DGST_SIZE_4_4;
9912 parse_func = sip_auth_parse_hash;
9913 sort_by_digest = sort_by_digest_4_4;
9914 opti_type = OPTI_TYPE_ZERO_BYTE;
9915 dgst_pos0 = 0;
9916 dgst_pos1 = 3;
9917 dgst_pos2 = 2;
9918 dgst_pos3 = 1;
9919 break;
9920
9921 case 11500: hash_type = HASH_TYPE_CRC32;
9922 salt_type = SALT_TYPE_INTERN;
9923 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9924 opts_type = OPTS_TYPE_PT_GENERATE_LE
9925 | OPTS_TYPE_ST_GENERATE_LE
9926 | OPTS_TYPE_ST_HEX;
9927 kern_type = KERN_TYPE_CRC32;
9928 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9929 parse_func = crc32_parse_hash;
9930 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9931 opti_type = OPTI_TYPE_ZERO_BYTE;
9932 dgst_pos0 = 0;
9933 dgst_pos1 = 1;
9934 dgst_pos2 = 2;
9935 dgst_pos3 = 3;
9936 break;
9937
9938 case 11600: hash_type = HASH_TYPE_AES;
9939 salt_type = SALT_TYPE_EMBEDDED;
9940 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9941 opts_type = OPTS_TYPE_PT_GENERATE_LE
9942 | OPTS_TYPE_PT_NEVERCRACK;
9943 kern_type = KERN_TYPE_SEVEN_ZIP;
9944 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9945 parse_func = seven_zip_parse_hash;
9946 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9947 opti_type = OPTI_TYPE_ZERO_BYTE;
9948 dgst_pos0 = 0;
9949 dgst_pos1 = 1;
9950 dgst_pos2 = 2;
9951 dgst_pos3 = 3;
9952 break;
9953
9954 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9955 salt_type = SALT_TYPE_NONE;
9956 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9957 opts_type = OPTS_TYPE_PT_GENERATE_LE
9958 | OPTS_TYPE_PT_ADD01;
9959 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9960 dgst_size = DGST_SIZE_4_8;
9961 parse_func = gost2012sbog_256_parse_hash;
9962 sort_by_digest = sort_by_digest_4_8;
9963 opti_type = OPTI_TYPE_ZERO_BYTE;
9964 dgst_pos0 = 0;
9965 dgst_pos1 = 1;
9966 dgst_pos2 = 2;
9967 dgst_pos3 = 3;
9968 break;
9969
9970 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9971 salt_type = SALT_TYPE_NONE;
9972 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9973 opts_type = OPTS_TYPE_PT_GENERATE_LE
9974 | OPTS_TYPE_PT_ADD01;
9975 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9976 dgst_size = DGST_SIZE_4_16;
9977 parse_func = gost2012sbog_512_parse_hash;
9978 sort_by_digest = sort_by_digest_4_16;
9979 opti_type = OPTI_TYPE_ZERO_BYTE;
9980 dgst_pos0 = 0;
9981 dgst_pos1 = 1;
9982 dgst_pos2 = 2;
9983 dgst_pos3 = 3;
9984 break;
9985
9986 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9987 salt_type = SALT_TYPE_EMBEDDED;
9988 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9989 opts_type = OPTS_TYPE_PT_GENERATE_LE
9990 | OPTS_TYPE_ST_BASE64
9991 | OPTS_TYPE_HASH_COPY;
9992 kern_type = KERN_TYPE_PBKDF2_MD5;
9993 dgst_size = DGST_SIZE_4_32;
9994 parse_func = pbkdf2_md5_parse_hash;
9995 sort_by_digest = sort_by_digest_4_32;
9996 opti_type = OPTI_TYPE_ZERO_BYTE
9997 | OPTI_TYPE_SLOW_HASH_SIMD;
9998 dgst_pos0 = 0;
9999 dgst_pos1 = 1;
10000 dgst_pos2 = 2;
10001 dgst_pos3 = 3;
10002 break;
10003
10004 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10005 salt_type = SALT_TYPE_EMBEDDED;
10006 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10007 opts_type = OPTS_TYPE_PT_GENERATE_LE
10008 | OPTS_TYPE_ST_BASE64
10009 | OPTS_TYPE_HASH_COPY;
10010 kern_type = KERN_TYPE_PBKDF2_SHA1;
10011 dgst_size = DGST_SIZE_4_32;
10012 parse_func = pbkdf2_sha1_parse_hash;
10013 sort_by_digest = sort_by_digest_4_32;
10014 opti_type = OPTI_TYPE_ZERO_BYTE
10015 | OPTI_TYPE_SLOW_HASH_SIMD;
10016 dgst_pos0 = 0;
10017 dgst_pos1 = 1;
10018 dgst_pos2 = 2;
10019 dgst_pos3 = 3;
10020 break;
10021
10022 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10023 salt_type = SALT_TYPE_EMBEDDED;
10024 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10025 opts_type = OPTS_TYPE_PT_GENERATE_LE
10026 | OPTS_TYPE_ST_BASE64
10027 | OPTS_TYPE_HASH_COPY;
10028 kern_type = KERN_TYPE_PBKDF2_SHA512;
10029 dgst_size = DGST_SIZE_8_16;
10030 parse_func = pbkdf2_sha512_parse_hash;
10031 sort_by_digest = sort_by_digest_8_16;
10032 opti_type = OPTI_TYPE_ZERO_BYTE
10033 | OPTI_TYPE_USES_BITS_64
10034 | OPTI_TYPE_SLOW_HASH_SIMD;
10035 dgst_pos0 = 0;
10036 dgst_pos1 = 1;
10037 dgst_pos2 = 2;
10038 dgst_pos3 = 3;
10039 break;
10040
10041 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10042 salt_type = SALT_TYPE_EMBEDDED;
10043 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10044 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10045 kern_type = KERN_TYPE_ECRYPTFS;
10046 dgst_size = DGST_SIZE_8_8;
10047 parse_func = ecryptfs_parse_hash;
10048 sort_by_digest = sort_by_digest_8_8;
10049 opti_type = OPTI_TYPE_ZERO_BYTE
10050 | OPTI_TYPE_USES_BITS_64;
10051 dgst_pos0 = 0;
10052 dgst_pos1 = 1;
10053 dgst_pos2 = 2;
10054 dgst_pos3 = 3;
10055 break;
10056
10057 case 12300: hash_type = HASH_TYPE_ORACLET;
10058 salt_type = SALT_TYPE_EMBEDDED;
10059 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10060 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10061 kern_type = KERN_TYPE_ORACLET;
10062 dgst_size = DGST_SIZE_8_16;
10063 parse_func = oraclet_parse_hash;
10064 sort_by_digest = sort_by_digest_8_16;
10065 opti_type = OPTI_TYPE_ZERO_BYTE
10066 | OPTI_TYPE_USES_BITS_64;
10067 dgst_pos0 = 0;
10068 dgst_pos1 = 1;
10069 dgst_pos2 = 2;
10070 dgst_pos3 = 3;
10071 break;
10072
10073 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10074 salt_type = SALT_TYPE_EMBEDDED;
10075 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10076 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10077 kern_type = KERN_TYPE_BSDICRYPT;
10078 dgst_size = DGST_SIZE_4_4;
10079 parse_func = bsdicrypt_parse_hash;
10080 sort_by_digest = sort_by_digest_4_4;
10081 opti_type = OPTI_TYPE_ZERO_BYTE
10082 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10083 dgst_pos0 = 0;
10084 dgst_pos1 = 1;
10085 dgst_pos2 = 2;
10086 dgst_pos3 = 3;
10087 break;
10088
10089 case 12500: hash_type = HASH_TYPE_RAR3HP;
10090 salt_type = SALT_TYPE_EMBEDDED;
10091 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10092 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10093 kern_type = KERN_TYPE_RAR3;
10094 dgst_size = DGST_SIZE_4_4;
10095 parse_func = rar3hp_parse_hash;
10096 sort_by_digest = sort_by_digest_4_4;
10097 opti_type = OPTI_TYPE_ZERO_BYTE;
10098 dgst_pos0 = 0;
10099 dgst_pos1 = 1;
10100 dgst_pos2 = 2;
10101 dgst_pos3 = 3;
10102 break;
10103
10104 case 12600: hash_type = HASH_TYPE_SHA256;
10105 salt_type = SALT_TYPE_INTERN;
10106 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10107 opts_type = OPTS_TYPE_PT_GENERATE_BE
10108 | OPTS_TYPE_PT_ADD80;
10109 kern_type = KERN_TYPE_CF10;
10110 dgst_size = DGST_SIZE_4_8;
10111 parse_func = cf10_parse_hash;
10112 sort_by_digest = sort_by_digest_4_8;
10113 opti_type = OPTI_TYPE_ZERO_BYTE
10114 | OPTI_TYPE_PRECOMPUTE_INIT
10115 | OPTI_TYPE_EARLY_SKIP
10116 | OPTI_TYPE_NOT_ITERATED;
10117 dgst_pos0 = 3;
10118 dgst_pos1 = 7;
10119 dgst_pos2 = 2;
10120 dgst_pos3 = 6;
10121 break;
10122
10123 case 12700: hash_type = HASH_TYPE_AES;
10124 salt_type = SALT_TYPE_EMBEDDED;
10125 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10126 opts_type = OPTS_TYPE_PT_GENERATE_LE
10127 | OPTS_TYPE_HASH_COPY;
10128 kern_type = KERN_TYPE_MYWALLET;
10129 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10130 parse_func = mywallet_parse_hash;
10131 sort_by_digest = sort_by_digest_4_5;
10132 opti_type = OPTI_TYPE_ZERO_BYTE;
10133 dgst_pos0 = 0;
10134 dgst_pos1 = 1;
10135 dgst_pos2 = 2;
10136 dgst_pos3 = 3;
10137 break;
10138
10139 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10140 salt_type = SALT_TYPE_EMBEDDED;
10141 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10142 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10143 kern_type = KERN_TYPE_MS_DRSR;
10144 dgst_size = DGST_SIZE_4_8;
10145 parse_func = ms_drsr_parse_hash;
10146 sort_by_digest = sort_by_digest_4_8;
10147 opti_type = OPTI_TYPE_ZERO_BYTE;
10148 dgst_pos0 = 0;
10149 dgst_pos1 = 1;
10150 dgst_pos2 = 2;
10151 dgst_pos3 = 3;
10152 break;
10153
10154 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10155 salt_type = SALT_TYPE_EMBEDDED;
10156 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10157 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10158 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10159 dgst_size = DGST_SIZE_4_8;
10160 parse_func = androidfde_samsung_parse_hash;
10161 sort_by_digest = sort_by_digest_4_8;
10162 opti_type = OPTI_TYPE_ZERO_BYTE;
10163 dgst_pos0 = 0;
10164 dgst_pos1 = 1;
10165 dgst_pos2 = 2;
10166 dgst_pos3 = 3;
10167 break;
10168
10169 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10170 salt_type = SALT_TYPE_EMBEDDED;
10171 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10172 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10173 kern_type = KERN_TYPE_RAR5;
10174 dgst_size = DGST_SIZE_4_4;
10175 parse_func = rar5_parse_hash;
10176 sort_by_digest = sort_by_digest_4_4;
10177 opti_type = OPTI_TYPE_ZERO_BYTE;
10178 dgst_pos0 = 0;
10179 dgst_pos1 = 1;
10180 dgst_pos2 = 2;
10181 dgst_pos3 = 3;
10182 break;
10183
10184 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10185 salt_type = SALT_TYPE_EMBEDDED;
10186 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10187 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10188 kern_type = KERN_TYPE_KRB5TGS;
10189 dgst_size = DGST_SIZE_4_4;
10190 parse_func = krb5tgs_parse_hash;
10191 sort_by_digest = sort_by_digest_4_4;
10192 opti_type = OPTI_TYPE_ZERO_BYTE
10193 | OPTI_TYPE_NOT_ITERATED;
10194 dgst_pos0 = 0;
10195 dgst_pos1 = 1;
10196 dgst_pos2 = 2;
10197 dgst_pos3 = 3;
10198 break;
10199
10200 case 13200: hash_type = HASH_TYPE_AES;
10201 salt_type = SALT_TYPE_EMBEDDED;
10202 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10203 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10204 kern_type = KERN_TYPE_AXCRYPT;
10205 dgst_size = DGST_SIZE_4_4;
10206 parse_func = axcrypt_parse_hash;
10207 sort_by_digest = sort_by_digest_4_4;
10208 opti_type = OPTI_TYPE_ZERO_BYTE;
10209 dgst_pos0 = 0;
10210 dgst_pos1 = 1;
10211 dgst_pos2 = 2;
10212 dgst_pos3 = 3;
10213 break;
10214
10215 case 13300: hash_type = HASH_TYPE_SHA1;
10216 salt_type = SALT_TYPE_NONE;
10217 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10218 opts_type = OPTS_TYPE_PT_GENERATE_BE
10219 | OPTS_TYPE_PT_ADD80
10220 | OPTS_TYPE_PT_ADDBITS15;
10221 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10222 dgst_size = DGST_SIZE_4_5;
10223 parse_func = sha1axcrypt_parse_hash;
10224 sort_by_digest = sort_by_digest_4_5;
10225 opti_type = OPTI_TYPE_ZERO_BYTE
10226 | OPTI_TYPE_PRECOMPUTE_INIT
10227 | OPTI_TYPE_EARLY_SKIP
10228 | OPTI_TYPE_NOT_ITERATED
10229 | OPTI_TYPE_NOT_SALTED;
10230 dgst_pos0 = 0;
10231 dgst_pos1 = 4;
10232 dgst_pos2 = 3;
10233 dgst_pos3 = 2;
10234 break;
10235
10236 case 13400: hash_type = HASH_TYPE_AES;
10237 salt_type = SALT_TYPE_EMBEDDED;
10238 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10239 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10240 kern_type = KERN_TYPE_KEEPASS;
10241 dgst_size = DGST_SIZE_4_4;
10242 parse_func = keepass_parse_hash;
10243 sort_by_digest = sort_by_digest_4_4;
10244 opti_type = OPTI_TYPE_ZERO_BYTE;
10245 dgst_pos0 = 0;
10246 dgst_pos1 = 1;
10247 dgst_pos2 = 2;
10248 dgst_pos3 = 3;
10249 break;
10250
10251 case 13500: hash_type = HASH_TYPE_SHA1;
10252 salt_type = SALT_TYPE_EMBEDDED;
10253 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10254 opts_type = OPTS_TYPE_PT_GENERATE_BE
10255 | OPTS_TYPE_PT_UNICODE
10256 | OPTS_TYPE_PT_ADD80;
10257 kern_type = KERN_TYPE_PSTOKEN;
10258 dgst_size = DGST_SIZE_4_5;
10259 parse_func = pstoken_parse_hash;
10260 sort_by_digest = sort_by_digest_4_5;
10261 opti_type = OPTI_TYPE_ZERO_BYTE
10262 | OPTI_TYPE_PRECOMPUTE_INIT
10263 | OPTI_TYPE_EARLY_SKIP
10264 | OPTI_TYPE_NOT_ITERATED
10265 | OPTI_TYPE_PREPENDED_SALT
10266 | OPTI_TYPE_RAW_HASH;
10267 dgst_pos0 = 3;
10268 dgst_pos1 = 4;
10269 dgst_pos2 = 2;
10270 dgst_pos3 = 1;
10271 break;
10272
10273 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10274 salt_type = SALT_TYPE_EMBEDDED;
10275 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10276 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10277 kern_type = KERN_TYPE_ZIP2;
10278 dgst_size = DGST_SIZE_4_4;
10279 parse_func = zip2_parse_hash;
10280 sort_by_digest = sort_by_digest_4_4;
10281 opti_type = OPTI_TYPE_ZERO_BYTE;
10282 dgst_pos0 = 0;
10283 dgst_pos1 = 1;
10284 dgst_pos2 = 2;
10285 dgst_pos3 = 3;
10286 break;
10287
10288 default: usage_mini_print (PROGNAME); return (-1);
10289 }
10290
10291 /**
10292 * parser
10293 */
10294
10295 data.parse_func = parse_func;
10296
10297 /**
10298 * misc stuff
10299 */
10300
10301 if (hex_salt)
10302 {
10303 if (salt_type == SALT_TYPE_INTERN)
10304 {
10305 opts_type |= OPTS_TYPE_ST_HEX;
10306 }
10307 else
10308 {
10309 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10310
10311 return (-1);
10312 }
10313 }
10314
10315 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10316 | (salt_type == SALT_TYPE_EXTERN)
10317 | (salt_type == SALT_TYPE_EMBEDDED)
10318 | (salt_type == SALT_TYPE_VIRTUAL));
10319
10320 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10321
10322 data.hash_type = hash_type;
10323 data.attack_mode = attack_mode;
10324 data.attack_kern = attack_kern;
10325 data.attack_exec = attack_exec;
10326 data.kern_type = kern_type;
10327 data.opts_type = opts_type;
10328 data.dgst_size = dgst_size;
10329 data.salt_type = salt_type;
10330 data.isSalted = isSalted;
10331 data.sort_by_digest = sort_by_digest;
10332 data.dgst_pos0 = dgst_pos0;
10333 data.dgst_pos1 = dgst_pos1;
10334 data.dgst_pos2 = dgst_pos2;
10335 data.dgst_pos3 = dgst_pos3;
10336
10337 esalt_size = 0;
10338
10339 switch (hash_mode)
10340 {
10341 case 2500: esalt_size = sizeof (wpa_t); break;
10342 case 5300: esalt_size = sizeof (ikepsk_t); break;
10343 case 5400: esalt_size = sizeof (ikepsk_t); break;
10344 case 5500: esalt_size = sizeof (netntlm_t); break;
10345 case 5600: esalt_size = sizeof (netntlm_t); break;
10346 case 6211: esalt_size = sizeof (tc_t); break;
10347 case 6212: esalt_size = sizeof (tc_t); break;
10348 case 6213: esalt_size = sizeof (tc_t); break;
10349 case 6221: esalt_size = sizeof (tc_t); break;
10350 case 6222: esalt_size = sizeof (tc_t); break;
10351 case 6223: esalt_size = sizeof (tc_t); break;
10352 case 6231: esalt_size = sizeof (tc_t); break;
10353 case 6232: esalt_size = sizeof (tc_t); break;
10354 case 6233: esalt_size = sizeof (tc_t); break;
10355 case 6241: esalt_size = sizeof (tc_t); break;
10356 case 6242: esalt_size = sizeof (tc_t); break;
10357 case 6243: esalt_size = sizeof (tc_t); break;
10358 case 6600: esalt_size = sizeof (agilekey_t); break;
10359 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10360 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10361 case 7300: esalt_size = sizeof (rakp_t); break;
10362 case 7500: esalt_size = sizeof (krb5pa_t); break;
10363 case 8200: esalt_size = sizeof (cloudkey_t); break;
10364 case 8800: esalt_size = sizeof (androidfde_t); break;
10365 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10366 case 9400: esalt_size = sizeof (office2007_t); break;
10367 case 9500: esalt_size = sizeof (office2010_t); break;
10368 case 9600: esalt_size = sizeof (office2013_t); break;
10369 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10370 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10371 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10372 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10373 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10374 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10375 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10376 case 10200: esalt_size = sizeof (cram_md5_t); break;
10377 case 10400: esalt_size = sizeof (pdf_t); break;
10378 case 10410: esalt_size = sizeof (pdf_t); break;
10379 case 10420: esalt_size = sizeof (pdf_t); break;
10380 case 10500: esalt_size = sizeof (pdf_t); break;
10381 case 10600: esalt_size = sizeof (pdf_t); break;
10382 case 10700: esalt_size = sizeof (pdf_t); break;
10383 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10384 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10385 case 11400: esalt_size = sizeof (sip_t); break;
10386 case 11600: esalt_size = sizeof (seven_zip_t); break;
10387 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10388 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10389 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10390 case 13000: esalt_size = sizeof (rar5_t); break;
10391 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10392 case 13400: esalt_size = sizeof (keepass_t); break;
10393 case 13500: esalt_size = sizeof (pstoken_t); break;
10394 case 13600: esalt_size = sizeof (zip2_t); break;
10395 }
10396
10397 data.esalt_size = esalt_size;
10398
10399 /**
10400 * choose dictionary parser
10401 */
10402
10403 if (hash_type == HASH_TYPE_LM)
10404 {
10405 get_next_word_func = get_next_word_lm;
10406 }
10407 else if (opts_type & OPTS_TYPE_PT_UPPER)
10408 {
10409 get_next_word_func = get_next_word_uc;
10410 }
10411 else
10412 {
10413 get_next_word_func = get_next_word_std;
10414 }
10415
10416 /**
10417 * dictstat
10418 */
10419
10420 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10421
10422 #ifdef _POSIX
10423 size_t dictstat_nmemb = 0;
10424 #endif
10425
10426 #ifdef _WIN
10427 uint dictstat_nmemb = 0;
10428 #endif
10429
10430 char dictstat[256] = { 0 };
10431
10432 FILE *dictstat_fp = NULL;
10433
10434 if (keyspace == 0)
10435 {
10436 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10437
10438 dictstat_fp = fopen (dictstat, "rb");
10439
10440 if (dictstat_fp)
10441 {
10442 #ifdef _POSIX
10443 struct stat tmpstat;
10444
10445 fstat (fileno (dictstat_fp), &tmpstat);
10446 #endif
10447
10448 #ifdef _WIN
10449 struct stat64 tmpstat;
10450
10451 _fstat64 (fileno (dictstat_fp), &tmpstat);
10452 #endif
10453
10454 if (tmpstat.st_mtime < COMPTIME)
10455 {
10456 /* with v0.15 the format changed so we have to ensure user is using a good version
10457 since there is no version-header in the dictstat file */
10458
10459 fclose (dictstat_fp);
10460
10461 unlink (dictstat);
10462 }
10463 else
10464 {
10465 while (!feof (dictstat_fp))
10466 {
10467 dictstat_t d;
10468
10469 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10470
10471 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10472
10473 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10474 {
10475 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10476
10477 return -1;
10478 }
10479 }
10480
10481 fclose (dictstat_fp);
10482 }
10483 }
10484 }
10485
10486 /**
10487 * potfile
10488 */
10489
10490 char potfile[256] = { 0 };
10491
10492 if (potfile_path == NULL)
10493 {
10494 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10495 }
10496 else
10497 {
10498 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10499 }
10500
10501 data.pot_fp = NULL;
10502
10503 FILE *out_fp = NULL;
10504 FILE *pot_fp = NULL;
10505
10506 if (show == 1 || left == 1)
10507 {
10508 pot_fp = fopen (potfile, "rb");
10509
10510 if (pot_fp == NULL)
10511 {
10512 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10513
10514 return (-1);
10515 }
10516
10517 if (outfile != NULL)
10518 {
10519 if ((out_fp = fopen (outfile, "ab")) == NULL)
10520 {
10521 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10522
10523 fclose (pot_fp);
10524
10525 return (-1);
10526 }
10527 }
10528 else
10529 {
10530 out_fp = stdout;
10531 }
10532 }
10533 else
10534 {
10535 if (potfile_disable == 0)
10536 {
10537 pot_fp = fopen (potfile, "ab");
10538
10539 if (pot_fp == NULL)
10540 {
10541 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10542
10543 return (-1);
10544 }
10545
10546 data.pot_fp = pot_fp;
10547 }
10548 }
10549
10550 pot_t *pot = NULL;
10551
10552 uint pot_cnt = 0;
10553 uint pot_avail = 0;
10554
10555 if (show == 1 || left == 1)
10556 {
10557 SUPPRESS_OUTPUT = 1;
10558
10559 pot_avail = count_lines (pot_fp);
10560
10561 rewind (pot_fp);
10562
10563 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10564
10565 uint pot_hashes_avail = 0;
10566
10567 uint line_num = 0;
10568
10569 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10570
10571 while (!feof (pot_fp))
10572 {
10573 line_num++;
10574
10575 int line_len = fgetl (pot_fp, line_buf);
10576
10577 if (line_len == 0) continue;
10578
10579 char *plain_buf = line_buf + line_len;
10580
10581 pot_t *pot_ptr = &pot[pot_cnt];
10582
10583 hash_t *hashes_buf = &pot_ptr->hash;
10584
10585 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10586 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10587
10588 if (pot_cnt == pot_hashes_avail)
10589 {
10590 uint pos = 0;
10591
10592 for (pos = 0; pos < INCR_POT; pos++)
10593 {
10594 if ((pot_cnt + pos) >= pot_avail) break;
10595
10596 pot_t *tmp_pot = &pot[pot_cnt + pos];
10597
10598 hash_t *tmp_hash = &tmp_pot->hash;
10599
10600 tmp_hash->digest = mymalloc (dgst_size);
10601
10602 if (isSalted)
10603 {
10604 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10605 }
10606
10607 if (esalt_size)
10608 {
10609 tmp_hash->esalt = mymalloc (esalt_size);
10610 }
10611
10612 pot_hashes_avail++;
10613 }
10614 }
10615
10616 int plain_len = 0;
10617
10618 int parser_status;
10619
10620 int iter = MAX_CUT_TRIES;
10621
10622 do
10623 {
10624 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10625 {
10626 if (line_buf[i] == ':')
10627 {
10628 line_len--;
10629
10630 break;
10631 }
10632 }
10633
10634 if (data.hash_mode != 2500)
10635 {
10636 parser_status = parse_func (line_buf, line_len, hashes_buf);
10637 }
10638 else
10639 {
10640 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10641
10642 if (line_len > max_salt_size)
10643 {
10644 parser_status = PARSER_GLOBAL_LENGTH;
10645 }
10646 else
10647 {
10648 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10649
10650 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10651
10652 hashes_buf->salt->salt_len = line_len;
10653
10654 parser_status = PARSER_OK;
10655 }
10656 }
10657
10658 // if NOT parsed without error, we add the ":" to the plain
10659
10660 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10661 {
10662 plain_len++;
10663 plain_buf--;
10664 }
10665
10666 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10667
10668 if (parser_status < PARSER_GLOBAL_ZERO)
10669 {
10670 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10671
10672 continue;
10673 }
10674
10675 if (plain_len >= 255) continue;
10676
10677 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10678
10679 pot_ptr->plain_len = plain_len;
10680
10681 pot_cnt++;
10682 }
10683
10684 myfree (line_buf);
10685
10686 fclose (pot_fp);
10687
10688 SUPPRESS_OUTPUT = 0;
10689
10690 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10691 }
10692
10693 /**
10694 * word len
10695 */
10696
10697 uint pw_min = PW_MIN;
10698 uint pw_max = PW_MAX;
10699
10700 switch (hash_mode)
10701 {
10702 case 125: if (pw_max > 32) pw_max = 32;
10703 break;
10704 case 400: if (pw_max > 40) pw_max = 40;
10705 break;
10706 case 500: if (pw_max > 16) pw_max = 16;
10707 break;
10708 case 1500: if (pw_max > 8) pw_max = 8;
10709 break;
10710 case 1600: if (pw_max > 16) pw_max = 16;
10711 break;
10712 case 1800: if (pw_max > 16) pw_max = 16;
10713 break;
10714 case 2100: if (pw_max > 16) pw_max = 16;
10715 break;
10716 case 2500: if (pw_min < 8) pw_min = 8;
10717 break;
10718 case 3000: if (pw_max > 7) pw_max = 7;
10719 break;
10720 case 5200: if (pw_max > 24) pw_max = 24;
10721 break;
10722 case 5800: if (pw_max > 16) pw_max = 16;
10723 break;
10724 case 6300: if (pw_max > 16) pw_max = 16;
10725 break;
10726 case 7400: if (pw_max > 16) pw_max = 16;
10727 break;
10728 case 7900: if (pw_max > 48) pw_max = 48;
10729 break;
10730 case 8500: if (pw_max > 8) pw_max = 8;
10731 break;
10732 case 8600: if (pw_max > 16) pw_max = 16;
10733 break;
10734 case 9710: pw_min = 5;
10735 pw_max = 5;
10736 break;
10737 case 9810: pw_min = 5;
10738 pw_max = 5;
10739 break;
10740 case 10410: pw_min = 5;
10741 pw_max = 5;
10742 break;
10743 case 10300: if (pw_max < 3) pw_min = 3;
10744 if (pw_max > 40) pw_max = 40;
10745 break;
10746 case 10500: if (pw_max < 3) pw_min = 3;
10747 if (pw_max > 40) pw_max = 40;
10748 break;
10749 case 10700: if (pw_max > 16) pw_max = 16;
10750 break;
10751 case 11300: if (pw_max > 40) pw_max = 40;
10752 break;
10753 case 11600: if (pw_max > 32) pw_max = 32;
10754 break;
10755 case 12500: if (pw_max > 20) pw_max = 20;
10756 break;
10757 case 12800: if (pw_max > 24) pw_max = 24;
10758 break;
10759 }
10760
10761 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10762 {
10763 switch (attack_kern)
10764 {
10765 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10766 break;
10767 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10768 break;
10769 }
10770 }
10771
10772 /**
10773 * charsets : keep them together for more easy maintainnce
10774 */
10775
10776 cs_t mp_sys[6] = { { { 0 }, 0 } };
10777 cs_t mp_usr[4] = { { { 0 }, 0 } };
10778
10779 mp_setup_sys (mp_sys);
10780
10781 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10782 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10783 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10784 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10785
10786 /**
10787 * load hashes, part I: find input mode, count hashes
10788 */
10789
10790 uint hashlist_mode = 0;
10791 uint hashlist_format = HLFMT_HASHCAT;
10792
10793 uint hashes_avail = 0;
10794
10795 if (benchmark == 0)
10796 {
10797 struct stat f;
10798
10799 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10800
10801 if ((hash_mode == 2500) ||
10802 (hash_mode == 5200) ||
10803 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10804 (hash_mode == 9000))
10805 {
10806 hashlist_mode = HL_MODE_ARG;
10807
10808 char *hashfile = myargv[optind];
10809
10810 data.hashfile = hashfile;
10811
10812 logfile_top_var_string ("target", hashfile);
10813 }
10814
10815 if (hashlist_mode == HL_MODE_ARG)
10816 {
10817 if (hash_mode == 2500)
10818 {
10819 struct stat st;
10820
10821 if (stat (data.hashfile, &st) == -1)
10822 {
10823 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10824
10825 return (-1);
10826 }
10827
10828 hashes_avail = st.st_size / sizeof (hccap_t);
10829 }
10830 else
10831 {
10832 hashes_avail = 1;
10833 }
10834 }
10835 else if (hashlist_mode == HL_MODE_FILE)
10836 {
10837 char *hashfile = myargv[optind];
10838
10839 data.hashfile = hashfile;
10840
10841 logfile_top_var_string ("target", hashfile);
10842
10843 FILE *fp = NULL;
10844
10845 if ((fp = fopen (hashfile, "rb")) == NULL)
10846 {
10847 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10848
10849 return (-1);
10850 }
10851
10852 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10853
10854 hashes_avail = count_lines (fp);
10855
10856 rewind (fp);
10857
10858 if (hashes_avail == 0)
10859 {
10860 log_error ("ERROR: hashfile is empty or corrupt");
10861
10862 fclose (fp);
10863
10864 return (-1);
10865 }
10866
10867 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10868
10869 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10870 {
10871 log_error ("ERROR: remove not supported in native hashfile-format mode");
10872
10873 fclose (fp);
10874
10875 return (-1);
10876 }
10877
10878 fclose (fp);
10879 }
10880 }
10881 else
10882 {
10883 hashlist_mode = HL_MODE_ARG;
10884
10885 hashes_avail = 1;
10886 }
10887
10888 if (hash_mode == 3000) hashes_avail *= 2;
10889
10890 data.hashlist_mode = hashlist_mode;
10891 data.hashlist_format = hashlist_format;
10892
10893 logfile_top_uint (hashlist_mode);
10894 logfile_top_uint (hashlist_format);
10895
10896 /**
10897 * load hashes, part II: allocate required memory, set pointers
10898 */
10899
10900 hash_t *hashes_buf = NULL;
10901 void *digests_buf = NULL;
10902 salt_t *salts_buf = NULL;
10903 void *esalts_buf = NULL;
10904
10905 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10906
10907 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10908
10909 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10910 {
10911 u32 hash_pos;
10912
10913 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10914 {
10915 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10916
10917 hashes_buf[hash_pos].hash_info = hash_info;
10918
10919 if (username && (remove || show || left))
10920 {
10921 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10922 }
10923
10924 if (benchmark)
10925 {
10926 hash_info->orighash = (char *) mymalloc (256);
10927 }
10928 }
10929 }
10930
10931 if (isSalted)
10932 {
10933 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10934
10935 if (esalt_size)
10936 {
10937 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10938 }
10939 }
10940 else
10941 {
10942 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10943 }
10944
10945 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10946 {
10947 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10948
10949 if (isSalted)
10950 {
10951 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10952
10953 if (esalt_size)
10954 {
10955 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10956 }
10957 }
10958 else
10959 {
10960 hashes_buf[hash_pos].salt = &salts_buf[0];
10961 }
10962 }
10963
10964 /**
10965 * load hashes, part III: parse hashes or generate them if benchmark
10966 */
10967
10968 uint hashes_cnt = 0;
10969
10970 if (benchmark == 0)
10971 {
10972 if (keyspace == 1)
10973 {
10974 // useless to read hash file for keyspace, cheat a little bit w/ optind
10975 }
10976 else if (hashes_avail == 0)
10977 {
10978 }
10979 else if (hashlist_mode == HL_MODE_ARG)
10980 {
10981 char *input_buf = myargv[optind];
10982
10983 uint input_len = strlen (input_buf);
10984
10985 logfile_top_var_string ("target", input_buf);
10986
10987 char *hash_buf = NULL;
10988 int hash_len = 0;
10989
10990 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10991
10992 bool hash_fmt_error = 0;
10993
10994 if (hash_len < 1) hash_fmt_error = 1;
10995 if (hash_buf == NULL) hash_fmt_error = 1;
10996
10997 if (hash_fmt_error)
10998 {
10999 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11000 }
11001 else
11002 {
11003 if (opts_type & OPTS_TYPE_HASH_COPY)
11004 {
11005 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11006
11007 hash_info_tmp->orighash = mystrdup (hash_buf);
11008 }
11009
11010 if (isSalted)
11011 {
11012 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11013 }
11014
11015 int parser_status = PARSER_OK;
11016
11017 if (hash_mode == 2500)
11018 {
11019 if (hash_len == 0)
11020 {
11021 log_error ("ERROR: hccap file not specified");
11022
11023 return (-1);
11024 }
11025
11026 hashlist_mode = HL_MODE_FILE;
11027
11028 data.hashlist_mode = hashlist_mode;
11029
11030 FILE *fp = fopen (hash_buf, "rb");
11031
11032 if (fp == NULL)
11033 {
11034 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11035
11036 return (-1);
11037 }
11038
11039 if (hashes_avail < 1)
11040 {
11041 log_error ("ERROR: hccap file is empty or corrupt");
11042
11043 fclose (fp);
11044
11045 return (-1);
11046 }
11047
11048 uint hccap_size = sizeof (hccap_t);
11049
11050 char *in = (char *) mymalloc (hccap_size);
11051
11052 while (!feof (fp))
11053 {
11054 int n = fread (in, hccap_size, 1, fp);
11055
11056 if (n != 1)
11057 {
11058 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11059
11060 break;
11061 }
11062
11063 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11064
11065 if (parser_status != PARSER_OK)
11066 {
11067 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11068
11069 continue;
11070 }
11071
11072 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11073
11074 if ((show == 1) || (left == 1))
11075 {
11076 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11077
11078 char *salt_ptr = (char *) tmp_salt->salt_buf;
11079
11080 int cur_pos = tmp_salt->salt_len;
11081 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11082
11083 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11084
11085 // do the appending task
11086
11087 snprintf (salt_ptr + cur_pos,
11088 rem_len,
11089 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11090 wpa->orig_mac1[0],
11091 wpa->orig_mac1[1],
11092 wpa->orig_mac1[2],
11093 wpa->orig_mac1[3],
11094 wpa->orig_mac1[4],
11095 wpa->orig_mac1[5],
11096 wpa->orig_mac2[0],
11097 wpa->orig_mac2[1],
11098 wpa->orig_mac2[2],
11099 wpa->orig_mac2[3],
11100 wpa->orig_mac2[4],
11101 wpa->orig_mac2[5]);
11102
11103 // memset () the remaining part of the salt
11104
11105 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11106 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11107
11108 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11109
11110 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11111 }
11112
11113 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);
11114 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);
11115
11116 hashes_cnt++;
11117 }
11118
11119 fclose (fp);
11120
11121 myfree (in);
11122 }
11123 else if (hash_mode == 3000)
11124 {
11125 if (hash_len == 32)
11126 {
11127 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11128
11129 hash_t *lm_hash_left = NULL;
11130
11131 if (parser_status == PARSER_OK)
11132 {
11133 lm_hash_left = &hashes_buf[hashes_cnt];
11134
11135 hashes_cnt++;
11136 }
11137 else
11138 {
11139 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11140 }
11141
11142 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11143
11144 hash_t *lm_hash_right = NULL;
11145
11146 if (parser_status == PARSER_OK)
11147 {
11148 lm_hash_right = &hashes_buf[hashes_cnt];
11149
11150 hashes_cnt++;
11151 }
11152 else
11153 {
11154 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11155 }
11156
11157 // show / left
11158
11159 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11160 {
11161 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);
11162 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);
11163 }
11164 }
11165 else
11166 {
11167 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11168
11169 if (parser_status == PARSER_OK)
11170 {
11171 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11172 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11173 }
11174
11175 if (parser_status == PARSER_OK)
11176 {
11177 hashes_cnt++;
11178 }
11179 else
11180 {
11181 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11182 }
11183 }
11184 }
11185 else
11186 {
11187 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11188
11189 if (parser_status == PARSER_OK)
11190 {
11191 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11192 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11193 }
11194
11195 if (parser_status == PARSER_OK)
11196 {
11197 hashes_cnt++;
11198 }
11199 else
11200 {
11201 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11202 }
11203 }
11204 }
11205 }
11206 else if (hashlist_mode == HL_MODE_FILE)
11207 {
11208 char *hashfile = data.hashfile;
11209
11210 FILE *fp;
11211
11212 if ((fp = fopen (hashfile, "rb")) == NULL)
11213 {
11214 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11215
11216 return (-1);
11217 }
11218
11219 uint line_num = 0;
11220
11221 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11222
11223 while (!feof (fp))
11224 {
11225 line_num++;
11226
11227 int line_len = fgetl (fp, line_buf);
11228
11229 if (line_len == 0) continue;
11230
11231 char *hash_buf = NULL;
11232 int hash_len = 0;
11233
11234 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11235
11236 bool hash_fmt_error = 0;
11237
11238 if (hash_len < 1) hash_fmt_error = 1;
11239 if (hash_buf == NULL) hash_fmt_error = 1;
11240
11241 if (hash_fmt_error)
11242 {
11243 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11244
11245 continue;
11246 }
11247
11248 if (username)
11249 {
11250 char *user_buf = NULL;
11251 int user_len = 0;
11252
11253 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11254
11255 if (remove || show)
11256 {
11257 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11258
11259 *user = (user_t *) mymalloc (sizeof (user_t));
11260
11261 user_t *user_ptr = *user;
11262
11263 if (user_buf != NULL)
11264 {
11265 user_ptr->user_name = mystrdup (user_buf);
11266 }
11267 else
11268 {
11269 user_ptr->user_name = mystrdup ("");
11270 }
11271
11272 user_ptr->user_len = user_len;
11273 }
11274 }
11275
11276 if (opts_type & OPTS_TYPE_HASH_COPY)
11277 {
11278 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11279
11280 hash_info_tmp->orighash = mystrdup (hash_buf);
11281 }
11282
11283 if (isSalted)
11284 {
11285 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11286 }
11287
11288 if (hash_mode == 3000)
11289 {
11290 if (hash_len == 32)
11291 {
11292 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11293
11294 if (parser_status < PARSER_GLOBAL_ZERO)
11295 {
11296 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11297
11298 continue;
11299 }
11300
11301 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11302
11303 hashes_cnt++;
11304
11305 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11306
11307 if (parser_status < PARSER_GLOBAL_ZERO)
11308 {
11309 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11310
11311 continue;
11312 }
11313
11314 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11315
11316 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);
11317
11318 hashes_cnt++;
11319
11320 // show / left
11321
11322 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);
11323 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);
11324 }
11325 else
11326 {
11327 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11328
11329 if (parser_status < PARSER_GLOBAL_ZERO)
11330 {
11331 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11332
11333 continue;
11334 }
11335
11336 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);
11337
11338 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11339 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11340
11341 hashes_cnt++;
11342 }
11343 }
11344 else
11345 {
11346 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11347
11348 if (parser_status < PARSER_GLOBAL_ZERO)
11349 {
11350 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11351
11352 continue;
11353 }
11354
11355 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);
11356
11357 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11358 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11359
11360 hashes_cnt++;
11361 }
11362 }
11363
11364 myfree (line_buf);
11365
11366 fclose (fp);
11367
11368 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11369
11370 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11371 }
11372 }
11373 else
11374 {
11375 if (isSalted)
11376 {
11377 hashes_buf[0].salt->salt_len = 8;
11378
11379 // special salt handling
11380
11381 switch (hash_mode)
11382 {
11383 case 1500: hashes_buf[0].salt->salt_len = 2;
11384 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11385 break;
11386 case 1731: hashes_buf[0].salt->salt_len = 4;
11387 break;
11388 case 2410: hashes_buf[0].salt->salt_len = 4;
11389 break;
11390 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11391 break;
11392 case 3100: hashes_buf[0].salt->salt_len = 1;
11393 break;
11394 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11395 break;
11396 case 5800: hashes_buf[0].salt->salt_len = 16;
11397 break;
11398 case 6800: hashes_buf[0].salt->salt_len = 32;
11399 break;
11400 case 8400: hashes_buf[0].salt->salt_len = 40;
11401 break;
11402 case 8800: hashes_buf[0].salt->salt_len = 16;
11403 break;
11404 case 8900: hashes_buf[0].salt->salt_len = 16;
11405 hashes_buf[0].salt->scrypt_N = 1024;
11406 hashes_buf[0].salt->scrypt_r = 1;
11407 hashes_buf[0].salt->scrypt_p = 1;
11408 break;
11409 case 9100: hashes_buf[0].salt->salt_len = 16;
11410 break;
11411 case 9300: hashes_buf[0].salt->salt_len = 14;
11412 hashes_buf[0].salt->scrypt_N = 16384;
11413 hashes_buf[0].salt->scrypt_r = 1;
11414 hashes_buf[0].salt->scrypt_p = 1;
11415 break;
11416 case 9400: hashes_buf[0].salt->salt_len = 16;
11417 break;
11418 case 9500: hashes_buf[0].salt->salt_len = 16;
11419 break;
11420 case 9600: hashes_buf[0].salt->salt_len = 16;
11421 break;
11422 case 9700: hashes_buf[0].salt->salt_len = 16;
11423 break;
11424 case 9710: hashes_buf[0].salt->salt_len = 16;
11425 break;
11426 case 9720: hashes_buf[0].salt->salt_len = 16;
11427 break;
11428 case 9800: hashes_buf[0].salt->salt_len = 16;
11429 break;
11430 case 9810: hashes_buf[0].salt->salt_len = 16;
11431 break;
11432 case 9820: hashes_buf[0].salt->salt_len = 16;
11433 break;
11434 case 10300: hashes_buf[0].salt->salt_len = 12;
11435 break;
11436 case 11500: hashes_buf[0].salt->salt_len = 4;
11437 break;
11438 case 11600: hashes_buf[0].salt->salt_len = 4;
11439 break;
11440 case 12400: hashes_buf[0].salt->salt_len = 4;
11441 break;
11442 case 12500: hashes_buf[0].salt->salt_len = 8;
11443 break;
11444 case 12600: hashes_buf[0].salt->salt_len = 64;
11445 break;
11446 }
11447
11448 // special esalt handling
11449
11450 switch (hash_mode)
11451 {
11452 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11453 break;
11454 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11455 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11456 break;
11457 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11458 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11459 break;
11460 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11461 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11462 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11463 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11464 break;
11465 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11466 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11467 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11468 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11469 break;
11470 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11471 break;
11472 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11473 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11474 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11475 break;
11476 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11477 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11478 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11479 break;
11480 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11481 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11482 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11483 break;
11484 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11485 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11486 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11487 break;
11488 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11489 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11490 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11491 break;
11492 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11493 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11494 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11495 break;
11496 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11497 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11498 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11499 break;
11500 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11501 break;
11502 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
11503 break;
11504 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
11505 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
11506 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
11507 break;
11508 }
11509 }
11510
11511 // set hashfile
11512
11513 switch (hash_mode)
11514 {
11515 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11516 break;
11517 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11518 break;
11519 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11520 break;
11521 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11522 break;
11523 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11524 break;
11525 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11526 break;
11527 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11528 break;
11529 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11530 break;
11531 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11532 break;
11533 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11534 break;
11535 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11536 break;
11537 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11538 break;
11539 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11540 break;
11541 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11542 break;
11543 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11544 break;
11545 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11546 break;
11547 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11548 break;
11549 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11550 break;
11551 }
11552
11553 // set default iterations
11554
11555 switch (hash_mode)
11556 {
11557 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11558 break;
11559 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11560 break;
11561 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11562 break;
11563 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11564 break;
11565 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11566 break;
11567 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11568 break;
11569 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11570 break;
11571 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11572 break;
11573 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11574 break;
11575 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11576 break;
11577 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11578 break;
11579 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11580 break;
11581 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11582 break;
11583 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11584 break;
11585 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11586 break;
11587 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11588 break;
11589 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11590 break;
11591 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11592 break;
11593 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11594 break;
11595 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11596 break;
11597 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11598 break;
11599 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11600 break;
11601 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11602 break;
11603 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11604 break;
11605 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11606 break;
11607 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11608 break;
11609 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11610 break;
11611 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11612 break;
11613 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11614 break;
11615 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11616 break;
11617 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11618 break;
11619 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11620 break;
11621 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11622 break;
11623 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11624 break;
11625 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11626 break;
11627 case 8900: hashes_buf[0].salt->salt_iter = 1;
11628 break;
11629 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11630 break;
11631 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11632 break;
11633 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11634 break;
11635 case 9300: hashes_buf[0].salt->salt_iter = 1;
11636 break;
11637 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11638 break;
11639 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11640 break;
11641 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11642 break;
11643 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11644 break;
11645 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11646 break;
11647 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11648 break;
11649 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11650 break;
11651 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11652 break;
11653 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11654 break;
11655 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11656 break;
11657 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11658 break;
11659 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11660 break;
11661 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11662 break;
11663 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11664 break;
11665 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11666 break;
11667 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11668 break;
11669 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11670 break;
11671 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11672 break;
11673 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11674 break;
11675 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11676 break;
11677 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11678 break;
11679 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
11680 break;
11681 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
11682 break;
11683 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
11684 break;
11685 }
11686
11687 hashes_cnt = 1;
11688 }
11689
11690 if (show == 1 || left == 1)
11691 {
11692 for (uint i = 0; i < pot_cnt; i++)
11693 {
11694 pot_t *pot_ptr = &pot[i];
11695
11696 hash_t *hashes_buf = &pot_ptr->hash;
11697
11698 local_free (hashes_buf->digest);
11699
11700 if (isSalted)
11701 {
11702 local_free (hashes_buf->salt);
11703 }
11704 }
11705
11706 local_free (pot);
11707
11708 if (data.quiet == 0) log_info_nn ("");
11709
11710 return (0);
11711 }
11712
11713 if (keyspace == 0)
11714 {
11715 if (hashes_cnt == 0)
11716 {
11717 log_error ("ERROR: No hashes loaded");
11718
11719 return (-1);
11720 }
11721 }
11722
11723 /**
11724 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11725 */
11726
11727 if (data.outfile != NULL)
11728 {
11729 if (data.hashfile != NULL)
11730 {
11731 #ifdef _POSIX
11732 struct stat tmpstat_outfile;
11733 struct stat tmpstat_hashfile;
11734 #endif
11735
11736 #ifdef _WIN
11737 struct stat64 tmpstat_outfile;
11738 struct stat64 tmpstat_hashfile;
11739 #endif
11740
11741 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11742
11743 if (tmp_outfile_fp)
11744 {
11745 #ifdef _POSIX
11746 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11747 #endif
11748
11749 #ifdef _WIN
11750 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11751 #endif
11752
11753 fclose (tmp_outfile_fp);
11754 }
11755
11756 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11757
11758 if (tmp_hashfile_fp)
11759 {
11760 #ifdef _POSIX
11761 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11762 #endif
11763
11764 #ifdef _WIN
11765 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11766 #endif
11767
11768 fclose (tmp_hashfile_fp);
11769 }
11770
11771 if (tmp_outfile_fp && tmp_outfile_fp)
11772 {
11773 tmpstat_outfile.st_mode = 0;
11774 tmpstat_outfile.st_nlink = 0;
11775 tmpstat_outfile.st_uid = 0;
11776 tmpstat_outfile.st_gid = 0;
11777 tmpstat_outfile.st_rdev = 0;
11778 tmpstat_outfile.st_atime = 0;
11779
11780 tmpstat_hashfile.st_mode = 0;
11781 tmpstat_hashfile.st_nlink = 0;
11782 tmpstat_hashfile.st_uid = 0;
11783 tmpstat_hashfile.st_gid = 0;
11784 tmpstat_hashfile.st_rdev = 0;
11785 tmpstat_hashfile.st_atime = 0;
11786
11787 #ifdef _POSIX
11788 tmpstat_outfile.st_blksize = 0;
11789 tmpstat_outfile.st_blocks = 0;
11790
11791 tmpstat_hashfile.st_blksize = 0;
11792 tmpstat_hashfile.st_blocks = 0;
11793 #endif
11794
11795 #ifdef _POSIX
11796 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11797 {
11798 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11799
11800 return (-1);
11801 }
11802 #endif
11803
11804 #ifdef _WIN
11805 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11806 {
11807 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11808
11809 return (-1);
11810 }
11811 #endif
11812 }
11813 }
11814 }
11815
11816 /**
11817 * Remove duplicates
11818 */
11819
11820 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11821
11822 if (isSalted)
11823 {
11824 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11825 }
11826 else
11827 {
11828 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11829 }
11830
11831 uint hashes_cnt_orig = hashes_cnt;
11832
11833 hashes_cnt = 1;
11834
11835 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11836 {
11837 if (isSalted)
11838 {
11839 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11840 {
11841 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11842 }
11843 }
11844 else
11845 {
11846 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11847 }
11848
11849 if (hashes_pos > hashes_cnt)
11850 {
11851 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11852 }
11853
11854 hashes_cnt++;
11855 }
11856
11857 /**
11858 * Potfile removes
11859 */
11860
11861 uint potfile_remove_cracks = 0;
11862
11863 if (potfile_disable == 0)
11864 {
11865 hash_t hash_buf;
11866
11867 hash_buf.digest = mymalloc (dgst_size);
11868 hash_buf.salt = NULL;
11869 hash_buf.esalt = NULL;
11870 hash_buf.hash_info = NULL;
11871 hash_buf.cracked = 0;
11872
11873 if (isSalted)
11874 {
11875 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11876 }
11877
11878 if (esalt_size)
11879 {
11880 hash_buf.esalt = mymalloc (esalt_size);
11881 }
11882
11883 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11884
11885 // no solution for these special hash types (for instane because they use hashfile in output etc)
11886 if ((hash_mode != 5200) &&
11887 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11888 (hash_mode != 9000))
11889 {
11890 FILE *fp = fopen (potfile, "rb");
11891
11892 if (fp != NULL)
11893 {
11894 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11895
11896 // to be safe work with a copy (because of line_len loop, i etc)
11897 // moved up here because it's easier to handle continue case
11898 // it's just 64kb
11899
11900 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
11901
11902 while (!feof (fp))
11903 {
11904 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
11905
11906 if (ptr == NULL) break;
11907
11908 int line_len = strlen (line_buf);
11909
11910 if (line_len == 0) continue;
11911
11912 int iter = MAX_CUT_TRIES;
11913
11914 for (int i = line_len - 1; i && iter; i--, line_len--)
11915 {
11916 if (line_buf[i] != ':') continue;
11917
11918 if (isSalted)
11919 {
11920 memset (hash_buf.salt, 0, sizeof (salt_t));
11921 }
11922
11923 hash_t *found = NULL;
11924
11925 if (hash_mode == 6800)
11926 {
11927 if (i < 64) // 64 = 16 * uint in salt_buf[]
11928 {
11929 // manipulate salt_buf
11930 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11931
11932 hash_buf.salt->salt_len = i;
11933
11934 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11935 }
11936 }
11937 else if (hash_mode == 2500)
11938 {
11939 if (i < 64) // 64 = 16 * uint in salt_buf[]
11940 {
11941 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11942 // manipulate salt_buf
11943
11944 memcpy (line_buf_cpy, line_buf, i);
11945
11946 char *mac2_pos = strrchr (line_buf_cpy, ':');
11947
11948 if (mac2_pos == NULL) continue;
11949
11950 mac2_pos[0] = 0;
11951 mac2_pos++;
11952
11953 if (strlen (mac2_pos) != 12) continue;
11954
11955 char *mac1_pos = strrchr (line_buf_cpy, ':');
11956
11957 if (mac1_pos == NULL) continue;
11958
11959 mac1_pos[0] = 0;
11960 mac1_pos++;
11961
11962 if (strlen (mac1_pos) != 12) continue;
11963
11964 uint essid_length = mac1_pos - line_buf_cpy - 1;
11965
11966 // here we need the ESSID
11967 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11968
11969 hash_buf.salt->salt_len = essid_length;
11970
11971 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11972
11973 if (found)
11974 {
11975 wpa_t *wpa = (wpa_t *) found->esalt;
11976
11977 // compare hex string(s) vs binary MAC address(es)
11978
11979 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11980 {
11981 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11982 {
11983 found = NULL;
11984
11985 break;
11986 }
11987 }
11988
11989 // early skip ;)
11990 if (!found) continue;
11991
11992 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11993 {
11994 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11995 {
11996 found = NULL;
11997
11998 break;
11999 }
12000 }
12001 }
12002 }
12003 }
12004 else
12005 {
12006 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12007
12008 if (parser_status == PARSER_OK)
12009 {
12010 if (isSalted)
12011 {
12012 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12013 }
12014 else
12015 {
12016 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12017 }
12018 }
12019 }
12020
12021 if (found == NULL) continue;
12022
12023 if (!found->cracked) potfile_remove_cracks++;
12024
12025 found->cracked = 1;
12026
12027 if (found) break;
12028
12029 iter--;
12030 }
12031 }
12032
12033 myfree (line_buf_cpy);
12034
12035 myfree (line_buf);
12036
12037 fclose (fp);
12038 }
12039 }
12040
12041 if (esalt_size)
12042 {
12043 local_free (hash_buf.esalt);
12044 }
12045
12046 if (isSalted)
12047 {
12048 local_free (hash_buf.salt);
12049 }
12050
12051 local_free (hash_buf.digest);
12052 }
12053
12054 /**
12055 * Now generate all the buffers required for later
12056 */
12057
12058 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12059
12060 salt_t *salts_buf_new = NULL;
12061 void *esalts_buf_new = NULL;
12062
12063 if (isSalted)
12064 {
12065 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12066
12067 if (esalt_size)
12068 {
12069 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12070 }
12071 }
12072 else
12073 {
12074 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12075 }
12076
12077 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12078
12079 uint digests_cnt = hashes_cnt;
12080 uint digests_done = 0;
12081
12082 size_t size_digests = digests_cnt * dgst_size;
12083 size_t size_shown = digests_cnt * sizeof (uint);
12084
12085 uint *digests_shown = (uint *) mymalloc (size_shown);
12086 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12087
12088 uint salts_cnt = 0;
12089 uint salts_done = 0;
12090
12091 hashinfo_t **hash_info = NULL;
12092
12093 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12094 {
12095 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12096
12097 if (username && (remove || show))
12098 {
12099 uint user_pos;
12100
12101 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12102 {
12103 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12104
12105 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12106 }
12107 }
12108 }
12109
12110 uint *salts_shown = (uint *) mymalloc (size_shown);
12111
12112 salt_t *salt_buf;
12113
12114 {
12115 // copied from inner loop
12116
12117 salt_buf = &salts_buf_new[salts_cnt];
12118
12119 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12120
12121 if (esalt_size)
12122 {
12123 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12124 }
12125
12126 salt_buf->digests_cnt = 0;
12127 salt_buf->digests_done = 0;
12128 salt_buf->digests_offset = 0;
12129
12130 salts_cnt++;
12131 }
12132
12133 if (hashes_buf[0].cracked == 1)
12134 {
12135 digests_shown[0] = 1;
12136
12137 digests_done++;
12138
12139 salt_buf->digests_done++;
12140 }
12141
12142 salt_buf->digests_cnt++;
12143
12144 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12145
12146 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12147 {
12148 hash_info[0] = hashes_buf[0].hash_info;
12149 }
12150
12151 // copy from inner loop
12152
12153 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12154 {
12155 if (isSalted)
12156 {
12157 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12158 {
12159 salt_buf = &salts_buf_new[salts_cnt];
12160
12161 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12162
12163 if (esalt_size)
12164 {
12165 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12166 }
12167
12168 salt_buf->digests_cnt = 0;
12169 salt_buf->digests_done = 0;
12170 salt_buf->digests_offset = hashes_pos;
12171
12172 salts_cnt++;
12173 }
12174 }
12175
12176 if (hashes_buf[hashes_pos].cracked == 1)
12177 {
12178 digests_shown[hashes_pos] = 1;
12179
12180 digests_done++;
12181
12182 salt_buf->digests_done++;
12183 }
12184
12185 salt_buf->digests_cnt++;
12186
12187 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12188
12189 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12190 {
12191 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12192 }
12193 }
12194
12195 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12196 {
12197 salt_t *salt_buf = &salts_buf_new[salt_pos];
12198
12199 if (salt_buf->digests_done == salt_buf->digests_cnt)
12200 {
12201 salts_shown[salt_pos] = 1;
12202
12203 salts_done++;
12204 }
12205
12206 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12207 }
12208
12209 local_free (digests_buf);
12210 local_free (salts_buf);
12211 local_free (esalts_buf);
12212
12213 digests_buf = digests_buf_new;
12214 salts_buf = salts_buf_new;
12215 esalts_buf = esalts_buf_new;
12216
12217 local_free (hashes_buf);
12218
12219 /**
12220 * special modification not set from parser
12221 */
12222
12223 switch (hash_mode)
12224 {
12225 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12226 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12227 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12228 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12229 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12230 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12231 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12232 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12233 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12234 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12235 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12236 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12237 }
12238
12239 if (truecrypt_keyfiles)
12240 {
12241 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12242
12243 char *keyfiles = strdup (truecrypt_keyfiles);
12244
12245 char *keyfile = strtok (keyfiles, ",");
12246
12247 do
12248 {
12249 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12250
12251 } while ((keyfile = strtok (NULL, ",")) != NULL);
12252
12253 free (keyfiles);
12254 }
12255
12256 data.digests_cnt = digests_cnt;
12257 data.digests_done = digests_done;
12258 data.digests_buf = digests_buf;
12259 data.digests_shown = digests_shown;
12260 data.digests_shown_tmp = digests_shown_tmp;
12261
12262 data.salts_cnt = salts_cnt;
12263 data.salts_done = salts_done;
12264 data.salts_buf = salts_buf;
12265 data.salts_shown = salts_shown;
12266
12267 data.esalts_buf = esalts_buf;
12268 data.hash_info = hash_info;
12269
12270 /**
12271 * Automatic Optimizers
12272 */
12273
12274 if (salts_cnt == 1)
12275 opti_type |= OPTI_TYPE_SINGLE_SALT;
12276
12277 if (digests_cnt == 1)
12278 opti_type |= OPTI_TYPE_SINGLE_HASH;
12279
12280 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12281 opti_type |= OPTI_TYPE_NOT_ITERATED;
12282
12283 if (attack_mode == ATTACK_MODE_BF)
12284 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12285
12286 data.opti_type = opti_type;
12287
12288 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12289 {
12290 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12291 {
12292 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12293 {
12294 if (opts_type & OPTS_TYPE_ST_ADD80)
12295 {
12296 opts_type &= ~OPTS_TYPE_ST_ADD80;
12297 opts_type |= OPTS_TYPE_PT_ADD80;
12298 }
12299
12300 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12301 {
12302 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12303 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12304 }
12305
12306 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12307 {
12308 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12309 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12310 }
12311 }
12312 }
12313 }
12314
12315 /**
12316 * Some algorithm, like descrypt, can benefit from JIT compilation
12317 */
12318
12319 int force_jit_compilation = -1;
12320
12321 if (hash_mode == 8900)
12322 {
12323 force_jit_compilation = 8900;
12324 }
12325 else if (hash_mode == 9300)
12326 {
12327 force_jit_compilation = 8900;
12328 }
12329 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12330 {
12331 force_jit_compilation = 1500;
12332 }
12333
12334 /**
12335 * generate bitmap tables
12336 */
12337
12338 const uint bitmap_shift1 = 5;
12339 const uint bitmap_shift2 = 13;
12340
12341 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12342
12343 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12344 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12345 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12346 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12347 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12348 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12349 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12350 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12351
12352 uint bitmap_bits;
12353 uint bitmap_nums;
12354 uint bitmap_mask;
12355 uint bitmap_size;
12356
12357 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12358 {
12359 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12360
12361 bitmap_nums = 1 << bitmap_bits;
12362
12363 bitmap_mask = bitmap_nums - 1;
12364
12365 bitmap_size = bitmap_nums * sizeof (uint);
12366
12367 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12368
12369 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;
12370 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;
12371
12372 break;
12373 }
12374
12375 bitmap_nums = 1 << bitmap_bits;
12376
12377 bitmap_mask = bitmap_nums - 1;
12378
12379 bitmap_size = bitmap_nums * sizeof (uint);
12380
12381 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);
12382 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);
12383
12384 /**
12385 * prepare quick rule
12386 */
12387
12388 data.rule_buf_l = rule_buf_l;
12389 data.rule_buf_r = rule_buf_r;
12390
12391 int rule_len_l = (int) strlen (rule_buf_l);
12392 int rule_len_r = (int) strlen (rule_buf_r);
12393
12394 data.rule_len_l = rule_len_l;
12395 data.rule_len_r = rule_len_r;
12396
12397 /**
12398 * load rules
12399 */
12400
12401 uint *all_kernel_rules_cnt = NULL;
12402
12403 kernel_rule_t **all_kernel_rules_buf = NULL;
12404
12405 if (rp_files_cnt)
12406 {
12407 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12408
12409 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12410 }
12411
12412 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12413
12414 int rule_len = 0;
12415
12416 for (uint i = 0; i < rp_files_cnt; i++)
12417 {
12418 uint kernel_rules_avail = 0;
12419
12420 uint kernel_rules_cnt = 0;
12421
12422 kernel_rule_t *kernel_rules_buf = NULL;
12423
12424 char *rp_file = rp_files[i];
12425
12426 char in[BLOCK_SIZE] = { 0 };
12427 char out[BLOCK_SIZE] = { 0 };
12428
12429 FILE *fp = NULL;
12430
12431 uint rule_line = 0;
12432
12433 if ((fp = fopen (rp_file, "rb")) == NULL)
12434 {
12435 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12436
12437 return (-1);
12438 }
12439
12440 while (!feof (fp))
12441 {
12442 memset (rule_buf, 0, HCBUFSIZ);
12443
12444 rule_len = fgetl (fp, rule_buf);
12445
12446 rule_line++;
12447
12448 if (rule_len == 0) continue;
12449
12450 if (rule_buf[0] == '#') continue;
12451
12452 if (kernel_rules_avail == kernel_rules_cnt)
12453 {
12454 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12455
12456 kernel_rules_avail += INCR_RULES;
12457 }
12458
12459 memset (in, 0, BLOCK_SIZE);
12460 memset (out, 0, BLOCK_SIZE);
12461
12462 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12463
12464 if (result == -1)
12465 {
12466 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12467
12468 continue;
12469 }
12470
12471 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12472 {
12473 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12474
12475 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12476
12477 continue;
12478 }
12479
12480 /* its so slow
12481 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12482 {
12483 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12484
12485 continue;
12486 }
12487 */
12488
12489 kernel_rules_cnt++;
12490 }
12491
12492 fclose (fp);
12493
12494 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12495
12496 all_kernel_rules_buf[i] = kernel_rules_buf;
12497 }
12498
12499 /**
12500 * merge rules or automatic rule generator
12501 */
12502
12503 uint kernel_rules_cnt = 0;
12504
12505 kernel_rule_t *kernel_rules_buf = NULL;
12506
12507 if (attack_mode == ATTACK_MODE_STRAIGHT)
12508 {
12509 if (rp_files_cnt)
12510 {
12511 kernel_rules_cnt = 1;
12512
12513 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12514
12515 repeats[0] = kernel_rules_cnt;
12516
12517 for (uint i = 0; i < rp_files_cnt; i++)
12518 {
12519 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12520
12521 repeats[i + 1] = kernel_rules_cnt;
12522 }
12523
12524 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12525
12526 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12527
12528 for (uint i = 0; i < kernel_rules_cnt; i++)
12529 {
12530 uint out_pos = 0;
12531
12532 kernel_rule_t *out = &kernel_rules_buf[i];
12533
12534 for (uint j = 0; j < rp_files_cnt; j++)
12535 {
12536 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12537 uint in_pos;
12538
12539 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12540
12541 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12542 {
12543 if (out_pos == RULES_MAX - 1)
12544 {
12545 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12546
12547 break;
12548 }
12549
12550 out->cmds[out_pos] = in->cmds[in_pos];
12551 }
12552 }
12553 }
12554
12555 local_free (repeats);
12556 }
12557 else if (rp_gen)
12558 {
12559 uint kernel_rules_avail = 0;
12560
12561 while (kernel_rules_cnt < rp_gen)
12562 {
12563 if (kernel_rules_avail == kernel_rules_cnt)
12564 {
12565 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12566
12567 kernel_rules_avail += INCR_RULES;
12568 }
12569
12570 memset (rule_buf, 0, HCBUFSIZ);
12571
12572 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12573
12574 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12575
12576 kernel_rules_cnt++;
12577 }
12578 }
12579 }
12580
12581 myfree (rule_buf);
12582
12583 /**
12584 * generate NOP rules
12585 */
12586
12587 if (kernel_rules_cnt == 0)
12588 {
12589 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12590
12591 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12592
12593 kernel_rules_cnt++;
12594 }
12595
12596 data.kernel_rules_cnt = kernel_rules_cnt;
12597 data.kernel_rules_buf = kernel_rules_buf;
12598
12599 /**
12600 * OpenCL platforms: detect
12601 */
12602
12603 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12604 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12605
12606 cl_uint platforms_cnt = 0;
12607 cl_uint platform_devices_cnt = 0;
12608
12609 if (keyspace == 0)
12610 {
12611 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12612
12613 if (platforms_cnt == 0)
12614 {
12615 log_info ("");
12616 log_info ("ATTENTION! No OpenCL compatible platform found");
12617 log_info ("");
12618 log_info ("You're probably missing the OpenCL runtime installation");
12619 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
12620 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
12621 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
12622 log_info ("");
12623
12624 return (-1);
12625 }
12626
12627 if (opencl_platforms_filter != (uint) -1)
12628 {
12629 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
12630
12631 if (opencl_platforms_filter > platform_cnt_mask)
12632 {
12633 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
12634
12635 return (-1);
12636 }
12637 }
12638 }
12639
12640 /**
12641 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12642 */
12643
12644 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12645 {
12646 cl_platform_id platform = platforms[platform_id];
12647
12648 char platform_vendor[INFOSZ] = { 0 };
12649
12650 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12651
12652 #ifdef HAVE_HWMON
12653 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12654 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12655 {
12656 // make sure that we do not directly control the fan for NVidia
12657
12658 gpu_temp_retain = 0;
12659
12660 data.gpu_temp_retain = gpu_temp_retain;
12661 }
12662 #endif // HAVE_NVML || HAVE_NVAPI
12663 #endif
12664 }
12665
12666 /**
12667 * OpenCL device types:
12668 * 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.
12669 * In such a case, automatically enable CPU device type support, since it's disabled by default.
12670 */
12671
12672 if (opencl_device_types == NULL)
12673 {
12674 cl_device_type device_types_all = 0;
12675
12676 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12677 {
12678 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12679
12680 cl_platform_id platform = platforms[platform_id];
12681
12682 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12683
12684 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12685 {
12686 cl_device_id device = platform_devices[platform_devices_id];
12687
12688 cl_device_type device_type;
12689
12690 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12691
12692 device_types_all |= device_type;
12693 }
12694 }
12695
12696 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
12697 {
12698 device_types_filter |= CL_DEVICE_TYPE_CPU;
12699 }
12700 }
12701
12702 /**
12703 * OpenCL devices: simply push all devices from all platforms into the same device array
12704 */
12705
12706 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12707
12708 data.devices_param = devices_param;
12709
12710 uint devices_cnt = 0;
12711
12712 uint devices_active = 0;
12713
12714 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12715 {
12716 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12717
12718 cl_platform_id platform = platforms[platform_id];
12719
12720 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12721
12722 char platform_vendor[INFOSZ] = { 0 };
12723
12724 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12725
12726 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
12727 // this causes trouble with vendor id based macros
12728 // we'll assign generic to those without special optimization available
12729
12730 cl_uint vendor_id = 0;
12731
12732 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
12733 {
12734 vendor_id = VENDOR_ID_AMD;
12735 }
12736 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
12737 {
12738 vendor_id = VENDOR_ID_APPLE;
12739 }
12740 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
12741 {
12742 vendor_id = VENDOR_ID_INTEL_BEIGNET;
12743 }
12744 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
12745 {
12746 vendor_id = VENDOR_ID_INTEL_SDK;
12747 }
12748 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
12749 {
12750 vendor_id = VENDOR_ID_MESA;
12751 }
12752 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12753 {
12754 vendor_id = VENDOR_ID_NV;
12755 }
12756 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
12757 {
12758 vendor_id = VENDOR_ID_POCL;
12759 }
12760 else
12761 {
12762 vendor_id = VENDOR_ID_GENERIC;
12763 }
12764
12765 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12766 {
12767 size_t param_value_size = 0;
12768
12769 const uint device_id = devices_cnt;
12770
12771 hc_device_param_t *device_param = &data.devices_param[device_id];
12772
12773 device_param->vendor_id = vendor_id;
12774
12775 device_param->device = platform_devices[platform_devices_id];
12776
12777 device_param->device_id = device_id;
12778
12779 device_param->platform_devices_id = platform_devices_id;
12780
12781 // device_type
12782
12783 cl_device_type device_type;
12784
12785 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12786
12787 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12788
12789 device_param->device_type = device_type;
12790
12791 // device_name
12792
12793 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12794
12795 char *device_name = (char *) mymalloc (param_value_size);
12796
12797 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12798
12799 device_param->device_name = device_name;
12800
12801 // tuning db
12802
12803 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12804
12805 // device_version
12806
12807 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12808
12809 char *device_version = (char *) mymalloc (param_value_size);
12810
12811 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12812
12813 device_param->device_version = device_version;
12814
12815 // device_opencl_version
12816
12817 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12818
12819 char *device_opencl_version = (char *) mymalloc (param_value_size);
12820
12821 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12822
12823 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12824
12825 myfree (device_opencl_version);
12826
12827 // vector_width
12828
12829 cl_uint vector_width;
12830
12831 if (opencl_vector_width_chgd == 0)
12832 {
12833 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12834 {
12835 if (opti_type & OPTI_TYPE_USES_BITS_64)
12836 {
12837 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12838 }
12839 else
12840 {
12841 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12842 }
12843 }
12844 else
12845 {
12846 vector_width = (cl_uint) tuningdb_entry->vector_width;
12847 }
12848 }
12849 else
12850 {
12851 vector_width = opencl_vector_width;
12852 }
12853
12854 if (vector_width > 16) vector_width = 16;
12855
12856 device_param->vector_width = vector_width;
12857
12858 // max_compute_units
12859
12860 cl_uint device_processors;
12861
12862 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12863
12864 device_param->device_processors = device_processors;
12865
12866 // device_maxmem_alloc
12867 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
12868
12869 cl_ulong device_maxmem_alloc;
12870
12871 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12872
12873 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
12874
12875 // device_global_mem
12876
12877 cl_ulong device_global_mem;
12878
12879 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12880
12881 device_param->device_global_mem = device_global_mem;
12882
12883 // max_work_group_size
12884
12885 size_t device_maxworkgroup_size;
12886
12887 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
12888
12889 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
12890
12891 // max_clock_frequency
12892
12893 cl_uint device_maxclock_frequency;
12894
12895 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12896
12897 device_param->device_maxclock_frequency = device_maxclock_frequency;
12898
12899 // device_endian_little
12900
12901 cl_bool device_endian_little;
12902
12903 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
12904
12905 if (device_endian_little == CL_FALSE)
12906 {
12907 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
12908
12909 device_param->skipped = 1;
12910 }
12911
12912 // device_available
12913
12914 cl_bool device_available;
12915
12916 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
12917
12918 if (device_available == CL_FALSE)
12919 {
12920 log_info ("Device #%u: WARNING: device not available", device_id + 1);
12921
12922 device_param->skipped = 1;
12923 }
12924
12925 // device_compiler_available
12926
12927 cl_bool device_compiler_available;
12928
12929 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
12930
12931 if (device_compiler_available == CL_FALSE)
12932 {
12933 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
12934
12935 device_param->skipped = 1;
12936 }
12937
12938 // device_execution_capabilities
12939
12940 cl_device_exec_capabilities device_execution_capabilities;
12941
12942 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
12943
12944 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
12945 {
12946 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
12947
12948 device_param->skipped = 1;
12949 }
12950
12951 // device_extensions
12952
12953 size_t device_extensions_size;
12954
12955 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
12956
12957 char *device_extensions = mymalloc (device_extensions_size + 1);
12958
12959 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
12960
12961 if (strstr (device_extensions, "base_atomics") == 0)
12962 {
12963 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
12964
12965 device_param->skipped = 1;
12966 }
12967
12968 if (strstr (device_extensions, "byte_addressable_store") == 0)
12969 {
12970 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
12971
12972 device_param->skipped = 1;
12973 }
12974
12975 myfree (device_extensions);
12976
12977 // device_local_mem_size
12978
12979 cl_ulong device_local_mem_size;
12980
12981 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
12982
12983 if (device_local_mem_size < 32768)
12984 {
12985 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
12986
12987 device_param->skipped = 1;
12988 }
12989
12990
12991 // skipped
12992
12993 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
12994 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
12995
12996 // driver_version
12997
12998 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12999
13000 char *driver_version = (char *) mymalloc (param_value_size);
13001
13002 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13003
13004 device_param->driver_version = driver_version;
13005
13006 // device_name_chksum
13007
13008 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13009
13010 #if __x86_64__
13011 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);
13012 #else
13013 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);
13014 #endif
13015
13016 uint device_name_digest[4] = { 0 };
13017
13018 md5_64 ((uint *) device_name_chksum, device_name_digest);
13019
13020 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13021
13022 device_param->device_name_chksum = device_name_chksum;
13023
13024 // device_processor_cores
13025
13026 if (device_type & CL_DEVICE_TYPE_CPU)
13027 {
13028 cl_uint device_processor_cores = 1;
13029
13030 device_param->device_processor_cores = device_processor_cores;
13031 }
13032
13033 if (device_type & CL_DEVICE_TYPE_GPU)
13034 {
13035 if (vendor_id == VENDOR_ID_AMD)
13036 {
13037 cl_uint device_processor_cores = 0;
13038
13039 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13040
13041 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13042
13043 device_param->device_processor_cores = device_processor_cores;
13044 }
13045 else if (vendor_id == VENDOR_ID_NV)
13046 {
13047 cl_uint kernel_exec_timeout = 0;
13048
13049 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13050
13051 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13052
13053 device_param->kernel_exec_timeout = kernel_exec_timeout;
13054
13055 cl_uint device_processor_cores = 0;
13056
13057 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13058
13059 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13060
13061 device_param->device_processor_cores = device_processor_cores;
13062
13063 cl_uint sm_minor = 0;
13064 cl_uint sm_major = 0;
13065
13066 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13067 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13068
13069 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13070 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13071
13072 device_param->sm_minor = sm_minor;
13073 device_param->sm_major = sm_major;
13074 }
13075 else
13076 {
13077 cl_uint device_processor_cores = 1;
13078
13079 device_param->device_processor_cores = device_processor_cores;
13080 }
13081 }
13082
13083 // display results
13084
13085 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13086 {
13087 if (status_automat == 0)
13088 {
13089 if (device_param->skipped == 0)
13090 {
13091 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
13092 device_id + 1,
13093 device_name,
13094 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13095 (unsigned int) (device_global_mem / 1024 / 1024),
13096 (unsigned int) (device_maxclock_frequency),
13097 (unsigned int) device_processors);
13098 }
13099 else
13100 {
13101 log_info ("Device #%u: %s, skipped",
13102 device_id + 1,
13103 device_name);
13104 }
13105 }
13106 }
13107
13108 // common driver check
13109
13110 if (device_param->skipped == 0)
13111 {
13112 if (device_type & CL_DEVICE_TYPE_GPU)
13113 {
13114 if (vendor_id == VENDOR_ID_AMD)
13115 {
13116 int catalyst_check = (force == 1) ? 0 : 1;
13117
13118 int catalyst_warn = 0;
13119
13120 int catalyst_broken = 0;
13121
13122 if (catalyst_check == 1)
13123 {
13124 catalyst_warn = 1;
13125
13126 // v14.9 and higher
13127 if (atoi (device_param->driver_version) >= 1573)
13128 {
13129 catalyst_warn = 0;
13130 }
13131
13132 catalyst_check = 0;
13133 }
13134
13135 if (catalyst_broken == 1)
13136 {
13137 log_info ("");
13138 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13139 log_info ("It will pass over cracked hashes and does not report them as cracked");
13140 log_info ("You are STRONGLY encouraged not to use it");
13141 log_info ("You can use --force to override this but do not post error reports if you do so");
13142 log_info ("");
13143
13144 return (-1);
13145 }
13146
13147 if (catalyst_warn == 1)
13148 {
13149 log_info ("");
13150 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13151 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13152 log_info ("See hashcat's homepage for official supported catalyst drivers");
13153 #ifdef _WIN
13154 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13155 #endif
13156 log_info ("You can use --force to override this but do not post error reports if you do so");
13157 log_info ("");
13158
13159 return (-1);
13160 }
13161 }
13162 else if (vendor_id == VENDOR_ID_NV)
13163 {
13164 if (device_param->kernel_exec_timeout != 0)
13165 {
13166 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);
13167 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13168 }
13169 }
13170 }
13171
13172 if (device_type & CL_DEVICE_TYPE_CPU)
13173 {
13174 if (vendor_id == VENDOR_ID_AMD)
13175 {
13176 if (force == 0)
13177 {
13178 log_info ("");
13179 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13180 log_info ("You are STRONGLY encouraged not to use it");
13181 log_info ("You can use --force to override this but do not post error reports if you do so");
13182 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13183 log_info ("");
13184
13185 return (-1);
13186 }
13187 }
13188 }
13189
13190 /**
13191 * kernel accel and loops tuning db adjustment
13192 */
13193
13194 device_param->kernel_accel_min = 1;
13195 device_param->kernel_accel_max = 1024;
13196
13197 device_param->kernel_loops_min = 1;
13198 device_param->kernel_loops_max = 1024;
13199
13200 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13201
13202 if (tuningdb_entry)
13203 {
13204 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13205 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13206
13207 if (_kernel_accel)
13208 {
13209 device_param->kernel_accel_min = _kernel_accel;
13210 device_param->kernel_accel_max = _kernel_accel;
13211 }
13212
13213 if (_kernel_loops)
13214 {
13215 if (workload_profile == 1)
13216 {
13217 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13218 }
13219 else if (workload_profile == 2)
13220 {
13221 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13222 }
13223
13224 device_param->kernel_loops_min = _kernel_loops;
13225 device_param->kernel_loops_max = _kernel_loops;
13226 }
13227 }
13228
13229 // commandline parameters overwrite tuningdb entries
13230
13231 if (kernel_accel)
13232 {
13233 device_param->kernel_accel_min = kernel_accel;
13234 device_param->kernel_accel_max = kernel_accel;
13235 }
13236
13237 if (kernel_loops)
13238 {
13239 device_param->kernel_loops_min = kernel_loops;
13240 device_param->kernel_loops_max = kernel_loops;
13241 }
13242
13243 /**
13244 * activate device
13245 */
13246
13247 devices_active++;
13248 }
13249
13250 // next please
13251
13252 devices_cnt++;
13253 }
13254 }
13255
13256 if (keyspace == 0 && devices_active == 0)
13257 {
13258 log_error ("ERROR: No devices found/left");
13259
13260 return (-1);
13261 }
13262
13263 // 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)
13264
13265 if (devices_filter != (uint) -1)
13266 {
13267 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13268
13269 if (devices_filter > devices_cnt_mask)
13270 {
13271 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13272
13273 return (-1);
13274 }
13275 }
13276
13277 data.devices_cnt = devices_cnt;
13278
13279 data.devices_active = devices_active;
13280
13281 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13282 {
13283 if (status_automat == 0)
13284 {
13285 log_info ("");
13286 }
13287 }
13288
13289 /**
13290 * HM devices: init
13291 */
13292
13293 #ifdef HAVE_HWMON
13294 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13295 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13296 #endif
13297
13298 #ifdef HAVE_ADL
13299 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13300 #endif
13301
13302 if (gpu_temp_disable == 0)
13303 {
13304 #if defined(WIN) && defined(HAVE_NVAPI)
13305 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13306
13307 if (nvapi_init (nvapi) == 0)
13308 data.hm_nv = nvapi;
13309
13310 if (data.hm_nv)
13311 {
13312 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13313 {
13314 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13315
13316 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13317
13318 int tmp_out = 0;
13319
13320 for (int i = 0; i < tmp_in; i++)
13321 {
13322 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13323 }
13324
13325 for (int i = 0; i < tmp_out; i++)
13326 {
13327 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13328
13329 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13330
13331 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;
13332 }
13333 }
13334 }
13335 #endif // WIN && HAVE_NVAPI
13336
13337 #if defined(LINUX) && defined(HAVE_NVML)
13338 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13339
13340 if (nvml_init (nvml) == 0)
13341 data.hm_nv = nvml;
13342
13343 if (data.hm_nv)
13344 {
13345 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13346 {
13347 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13348
13349 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13350
13351 int tmp_out = 0;
13352
13353 for (int i = 0; i < tmp_in; i++)
13354 {
13355 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13356 }
13357
13358 for (int i = 0; i < tmp_out; i++)
13359 {
13360 unsigned int speed;
13361
13362 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;
13363 }
13364 }
13365 }
13366 #endif // LINUX && HAVE_NVML
13367
13368 data.hm_amd = NULL;
13369
13370 #ifdef HAVE_ADL
13371 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13372
13373 if (adl_init (adl) == 0)
13374 data.hm_amd = adl;
13375
13376 if (data.hm_amd)
13377 {
13378 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13379 {
13380 // total number of adapters
13381
13382 int hm_adapters_num;
13383
13384 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13385
13386 // adapter info
13387
13388 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13389
13390 if (lpAdapterInfo == NULL) return (-1);
13391
13392 // get a list (of ids of) valid/usable adapters
13393
13394 int num_adl_adapters = 0;
13395
13396 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13397
13398 if (num_adl_adapters > 0)
13399 {
13400 hc_thread_mutex_lock (mux_adl);
13401
13402 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13403
13404 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13405
13406 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13407 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13408
13409 hc_thread_mutex_unlock (mux_adl);
13410 }
13411
13412 myfree (valid_adl_device_list);
13413 myfree (lpAdapterInfo);
13414 }
13415 }
13416 #endif // HAVE_ADL
13417
13418 if (data.hm_amd == NULL && data.hm_nv == NULL)
13419 {
13420 gpu_temp_disable = 1;
13421 }
13422 }
13423
13424 /**
13425 * OpenCL devices: allocate buffer for device specific information
13426 */
13427
13428 #ifdef HAVE_HWMON
13429 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13430
13431 #ifdef HAVE_ADL
13432 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13433
13434 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13435 #endif // ADL
13436 #endif
13437
13438 /**
13439 * enable custom signal handler(s)
13440 */
13441
13442 if (benchmark == 0)
13443 {
13444 hc_signal (sigHandler_default);
13445 }
13446 else
13447 {
13448 hc_signal (sigHandler_benchmark);
13449 }
13450
13451 /**
13452 * User-defined GPU temp handling
13453 */
13454
13455 #ifdef HAVE_HWMON
13456 if (gpu_temp_disable == 1)
13457 {
13458 gpu_temp_abort = 0;
13459 gpu_temp_retain = 0;
13460 }
13461
13462 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13463 {
13464 if (gpu_temp_abort < gpu_temp_retain)
13465 {
13466 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13467
13468 return (-1);
13469 }
13470 }
13471
13472 data.gpu_temp_disable = gpu_temp_disable;
13473 data.gpu_temp_abort = gpu_temp_abort;
13474 data.gpu_temp_retain = gpu_temp_retain;
13475 #endif
13476
13477 /**
13478 * inform the user
13479 */
13480
13481 if (data.quiet == 0)
13482 {
13483 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13484
13485 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);
13486
13487 if (attack_mode == ATTACK_MODE_STRAIGHT)
13488 {
13489 log_info ("Rules: %u", kernel_rules_cnt);
13490 }
13491
13492 if (opti_type)
13493 {
13494 log_info ("Applicable Optimizers:");
13495
13496 for (uint i = 0; i < 32; i++)
13497 {
13498 const uint opti_bit = 1u << i;
13499
13500 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13501 }
13502 }
13503
13504 /**
13505 * Watchdog and Temperature balance
13506 */
13507
13508 #ifdef HAVE_HWMON
13509 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13510 {
13511 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13512 }
13513
13514 if (gpu_temp_abort == 0)
13515 {
13516 log_info ("Watchdog: Temperature abort trigger disabled");
13517 }
13518 else
13519 {
13520 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13521 }
13522
13523 if (gpu_temp_retain == 0)
13524 {
13525 log_info ("Watchdog: Temperature retain trigger disabled");
13526 }
13527 else
13528 {
13529 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13530 }
13531
13532 if (data.quiet == 0) log_info ("");
13533 #endif
13534 }
13535
13536 /**
13537 * HM devices: copy
13538 */
13539
13540 if (gpu_temp_disable == 0)
13541 {
13542 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13543 {
13544 hc_device_param_t *device_param = &data.devices_param[device_id];
13545
13546 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13547
13548 if (device_param->skipped) continue;
13549
13550 const uint platform_devices_id = device_param->platform_devices_id;
13551
13552 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13553 if (device_param->vendor_id == VENDOR_ID_NV)
13554 {
13555 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13556 }
13557 #endif
13558
13559 #ifdef HAVE_ADL
13560 if (device_param->vendor_id == VENDOR_ID_AMD)
13561 {
13562 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13563 }
13564 #endif
13565 }
13566 }
13567
13568 /*
13569 * Temporary fix:
13570 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13571 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13572 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13573 * Driver / ADL bug?
13574 */
13575
13576 #ifdef HAVE_ADL
13577 if (powertune_enable == 1)
13578 {
13579 hc_thread_mutex_lock (mux_adl);
13580
13581 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13582 {
13583 hc_device_param_t *device_param = &data.devices_param[device_id];
13584
13585 if (device_param->skipped) continue;
13586
13587 if (data.hm_device[device_id].od_version == 6)
13588 {
13589 // set powertune value only
13590
13591 int powertune_supported = 0;
13592
13593 int ADL_rc = 0;
13594
13595 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13596 {
13597 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13598
13599 return (-1);
13600 }
13601
13602 if (powertune_supported != 0)
13603 {
13604 // powertune set
13605 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13606
13607 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13608 {
13609 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13610
13611 return (-1);
13612 }
13613
13614 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13615 {
13616 log_error ("ERROR: Failed to set new ADL PowerControl values");
13617
13618 return (-1);
13619 }
13620 }
13621 }
13622 }
13623
13624 hc_thread_mutex_unlock (mux_adl);
13625 }
13626 #endif // HAVE_ADK
13627 #endif // HAVE_HWMON
13628
13629 #ifdef DEBUG
13630 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13631 #endif
13632
13633 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
13634
13635 uint kernel_power_all = 0;
13636
13637 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13638 {
13639 /**
13640 * host buffer
13641 */
13642
13643 hc_device_param_t *device_param = &data.devices_param[device_id];
13644
13645 if (device_param->skipped) continue;
13646
13647 /**
13648 * device properties
13649 */
13650
13651 const char *device_name_chksum = device_param->device_name_chksum;
13652 const u32 device_processors = device_param->device_processors;
13653 const u32 device_processor_cores = device_param->device_processor_cores;
13654
13655 /**
13656 * create context for each device
13657 */
13658
13659 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13660
13661 /**
13662 * create command-queue
13663 */
13664
13665 // not supported with NV
13666 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13667
13668 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13669
13670 /**
13671 * kernel threads: some algorithms need a fixed kernel-threads count
13672 * because of shared memory usage or bitslice
13673 * there needs to be some upper limit, otherwise there's too much overhead
13674 */
13675
13676 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
13677
13678 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
13679 {
13680 kernel_threads = KERNEL_THREADS_MAX_CPU;
13681 }
13682
13683 if (hash_mode == 1500) kernel_threads = 64; // DES
13684 if (hash_mode == 3000) kernel_threads = 64; // DES
13685 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
13686 if (hash_mode == 7500) kernel_threads = 64; // RC4
13687 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
13688 if (hash_mode == 9700) kernel_threads = 64; // RC4
13689 if (hash_mode == 9710) kernel_threads = 64; // RC4
13690 if (hash_mode == 9800) kernel_threads = 64; // RC4
13691 if (hash_mode == 9810) kernel_threads = 64; // RC4
13692 if (hash_mode == 10400) kernel_threads = 64; // RC4
13693 if (hash_mode == 10410) kernel_threads = 64; // RC4
13694 if (hash_mode == 10500) kernel_threads = 64; // RC4
13695 if (hash_mode == 13100) kernel_threads = 64; // RC4
13696
13697 /**
13698 * create input buffers on device : calculate size of fixed memory buffers
13699 */
13700
13701 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
13702 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13703
13704 device_param->size_root_css = size_root_css;
13705 device_param->size_markov_css = size_markov_css;
13706
13707 size_t size_results = kernel_threads * sizeof (uint);
13708
13709 device_param->size_results = size_results;
13710
13711 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13712 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13713
13714 size_t size_plains = digests_cnt * sizeof (plain_t);
13715 size_t size_salts = salts_cnt * sizeof (salt_t);
13716 size_t size_esalts = salts_cnt * esalt_size;
13717
13718 device_param->size_plains = size_plains;
13719 device_param->size_digests = size_digests;
13720 device_param->size_shown = size_shown;
13721 device_param->size_salts = size_salts;
13722
13723 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
13724 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
13725 size_t size_tm = 32 * sizeof (bs_word_t);
13726
13727 // scryptV stuff
13728
13729 size_t size_scryptV = 1;
13730
13731 if ((hash_mode == 8900) || (hash_mode == 9300))
13732 {
13733 uint tmto_start = 0;
13734 uint tmto_stop = 10;
13735
13736 if (scrypt_tmto)
13737 {
13738 tmto_start = scrypt_tmto;
13739 }
13740 else
13741 {
13742 // in case the user did not specify the tmto manually
13743 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13744 // but set the lower end only in case the user has a device with too less memory
13745
13746 if (hash_mode == 8900)
13747 {
13748 if (device_param->vendor_id == VENDOR_ID_AMD)
13749 {
13750 tmto_start = 1;
13751 }
13752 else if (device_param->vendor_id == VENDOR_ID_NV)
13753 {
13754 tmto_start = 2;
13755 }
13756 }
13757 else if (hash_mode == 9300)
13758 {
13759 if (device_param->vendor_id == VENDOR_ID_AMD)
13760 {
13761 tmto_start = 2;
13762 }
13763 else if (device_param->vendor_id == VENDOR_ID_NV)
13764 {
13765 tmto_start = 2;
13766 }
13767 }
13768 }
13769
13770 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13771 {
13772 // TODO: in theory the following calculation needs to be done per salt, not global
13773 // we assume all hashes have the same scrypt settings
13774
13775 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13776
13777 size_scryptV /= 1 << tmto;
13778
13779 size_scryptV *= device_processors * device_processor_cores;
13780
13781 if (size_scryptV > device_param->device_maxmem_alloc)
13782 {
13783 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13784
13785 continue;
13786 }
13787
13788 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13789 {
13790 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13791 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
13792 }
13793
13794 break;
13795 }
13796
13797 if (data.salts_buf[0].scrypt_phy == 0)
13798 {
13799 log_error ("ERROR: can't allocate enough device memory");
13800
13801 return -1;
13802 }
13803
13804 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13805 }
13806
13807 /**
13808 * some algorithms need a fixed kernel-loops count
13809 */
13810
13811 if (hash_mode == 1500)
13812 {
13813 const u32 kernel_loops_fixed = 1024;
13814
13815 device_param->kernel_loops_min = kernel_loops_fixed;
13816 device_param->kernel_loops_max = kernel_loops_fixed;
13817 }
13818
13819 if (hash_mode == 3000)
13820 {
13821 const u32 kernel_loops_fixed = 1024;
13822
13823 device_param->kernel_loops_min = kernel_loops_fixed;
13824 device_param->kernel_loops_max = kernel_loops_fixed;
13825 }
13826
13827 if (hash_mode == 8900)
13828 {
13829 const u32 kernel_loops_fixed = 1;
13830
13831 device_param->kernel_loops_min = kernel_loops_fixed;
13832 device_param->kernel_loops_max = kernel_loops_fixed;
13833 }
13834
13835 if (hash_mode == 9300)
13836 {
13837 const u32 kernel_loops_fixed = 1;
13838
13839 device_param->kernel_loops_min = kernel_loops_fixed;
13840 device_param->kernel_loops_max = kernel_loops_fixed;
13841 }
13842
13843 if (hash_mode == 12500)
13844 {
13845 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13846
13847 device_param->kernel_loops_min = kernel_loops_fixed;
13848 device_param->kernel_loops_max = kernel_loops_fixed;
13849 }
13850
13851 /**
13852 * some algorithms have a maximum kernel-loops count
13853 */
13854
13855 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13856 {
13857 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13858 {
13859 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13860 }
13861 }
13862
13863 /**
13864 * some algorithms need a special kernel-accel
13865 */
13866
13867 if (hash_mode == 8900)
13868 {
13869 device_param->kernel_accel_min = 1;
13870 device_param->kernel_accel_max = 64;
13871 }
13872
13873 if (hash_mode == 9300)
13874 {
13875 device_param->kernel_accel_min = 1;
13876 device_param->kernel_accel_max = 64;
13877 }
13878
13879 u32 kernel_accel_min = device_param->kernel_accel_min;
13880 u32 kernel_accel_max = device_param->kernel_accel_max;
13881
13882 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13883
13884 size_t size_pws = 4;
13885 size_t size_tmps = 4;
13886 size_t size_hooks = 4;
13887
13888 while (kernel_accel_max >= kernel_accel_min)
13889 {
13890 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13891
13892 // size_pws
13893
13894 size_pws = kernel_power_max * sizeof (pw_t);
13895
13896 // size_tmps
13897
13898 switch (hash_mode)
13899 {
13900 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13901 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13902 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13903 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13904 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13905 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13906 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13907 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13908 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13909 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13910 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13911 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13912 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13913 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13914 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13915 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13916 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13917 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13918 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13919 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13920 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13921 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13922 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13923 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13924 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13925 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13926 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13927 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13928 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13929 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13930 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13931 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13932 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13933 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13934 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13935 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13936 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13937 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13938 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13939 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13940 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13941 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13942 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13943 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13944 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13945 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13946 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13947 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13948 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13949 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13950 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13951 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13952 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13953 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13954 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13955 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13956 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13957 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13958 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13959 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13960 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13961 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
13962 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
13963 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13964 };
13965
13966 // size_hooks
13967
13968 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13969 {
13970 // none yet
13971 }
13972
13973 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13974 // if not, decrease amplifier and try again
13975
13976 int skip = 0;
13977
13978 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13979 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13980 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13981
13982 if (( bitmap_size
13983 + bitmap_size
13984 + bitmap_size
13985 + bitmap_size
13986 + bitmap_size
13987 + bitmap_size
13988 + bitmap_size
13989 + bitmap_size
13990 + size_bfs
13991 + size_combs
13992 + size_digests
13993 + size_esalts
13994 + size_hooks
13995 + size_markov_css
13996 + size_plains
13997 + size_pws
13998 + size_pws // not a bug
13999 + size_results
14000 + size_root_css
14001 + size_rules
14002 + size_rules_c
14003 + size_salts
14004 + size_scryptV
14005 + size_shown
14006 + size_tm
14007 + size_tmps) > device_param->device_global_mem) skip = 1;
14008
14009 if (skip == 1)
14010 {
14011 kernel_accel_max--;
14012
14013 continue;
14014 }
14015
14016 break;
14017 }
14018
14019 /*
14020 if (kernel_accel_max == 0)
14021 {
14022 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14023
14024 return -1;
14025 }
14026 */
14027
14028 device_param->kernel_accel_min = kernel_accel_min;
14029 device_param->kernel_accel_max = kernel_accel_max;
14030
14031 /*
14032 if (kernel_accel_max < kernel_accel)
14033 {
14034 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14035
14036 device_param->kernel_accel = kernel_accel_max;
14037 }
14038 */
14039
14040 device_param->size_bfs = size_bfs;
14041 device_param->size_combs = size_combs;
14042 device_param->size_rules = size_rules;
14043 device_param->size_rules_c = size_rules_c;
14044 device_param->size_pws = size_pws;
14045 device_param->size_tmps = size_tmps;
14046 device_param->size_hooks = size_hooks;
14047
14048 // do not confuse kernel_accel_max with kernel_accel here
14049
14050 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
14051
14052 device_param->kernel_threads = kernel_threads;
14053 device_param->kernel_power_user = kernel_power;
14054
14055 kernel_power_all += kernel_power;
14056
14057 /**
14058 * default building options
14059 */
14060
14061 char build_opts[1024] = { 0 };
14062
14063 // we don't have sm_* on vendors not NV but it doesn't matter
14064
14065 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);
14066
14067 if (device_param->vendor_id == VENDOR_ID_INTEL_SDK)
14068 {
14069 // we do vectorizing much better than the auto-vectorizer
14070
14071 char build_opts_new[1024] = { 0 };
14072
14073 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14074
14075 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14076 }
14077
14078 #ifdef DEBUG
14079 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14080 #endif
14081
14082 /**
14083 * main kernel
14084 */
14085
14086 {
14087 /**
14088 * kernel source filename
14089 */
14090
14091 char source_file[256] = { 0 };
14092
14093 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14094
14095 struct stat sst;
14096
14097 if (stat (source_file, &sst) == -1)
14098 {
14099 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14100
14101 return -1;
14102 }
14103
14104 /**
14105 * kernel cached filename
14106 */
14107
14108 char cached_file[256] = { 0 };
14109
14110 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14111
14112 int cached = 1;
14113
14114 struct stat cst;
14115
14116 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14117 {
14118 cached = 0;
14119 }
14120
14121 /**
14122 * kernel compile or load
14123 */
14124
14125 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14126
14127 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14128
14129 if (force_jit_compilation == -1)
14130 {
14131 if (cached == 0)
14132 {
14133 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14134
14135 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14136
14137 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14138
14139 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14140
14141 #ifdef DEBUG
14142 size_t build_log_size = 0;
14143
14144 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14145
14146 if (build_log_size > 1)
14147 {
14148 char *build_log = (char *) malloc (build_log_size + 1);
14149
14150 memset (build_log, 0, build_log_size + 1);
14151
14152 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14153
14154 puts (build_log);
14155
14156 free (build_log);
14157 }
14158 #endif
14159
14160 if (rc != 0)
14161 {
14162 device_param->skipped = true;
14163
14164 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14165
14166 continue;
14167 }
14168
14169 size_t binary_size;
14170
14171 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14172
14173 u8 *binary = (u8 *) mymalloc (binary_size);
14174
14175 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14176
14177 writeProgramBin (cached_file, binary, binary_size);
14178
14179 local_free (binary);
14180 }
14181 else
14182 {
14183 #ifdef DEBUG
14184 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14185 #endif
14186
14187 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14188
14189 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14190
14191 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14192 }
14193 }
14194 else
14195 {
14196 #ifdef DEBUG
14197 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14198 #endif
14199
14200 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14201
14202 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14203
14204 char build_opts_update[1024] = { 0 };
14205
14206 if (force_jit_compilation == 1500)
14207 {
14208 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14209 }
14210 else if (force_jit_compilation == 8900)
14211 {
14212 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);
14213 }
14214 else
14215 {
14216 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14217 }
14218
14219 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14220
14221 #ifdef DEBUG
14222 size_t build_log_size = 0;
14223
14224 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14225
14226 if (build_log_size > 1)
14227 {
14228 char *build_log = (char *) malloc (build_log_size + 1);
14229
14230 memset (build_log, 0, build_log_size + 1);
14231
14232 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14233
14234 puts (build_log);
14235
14236 free (build_log);
14237 }
14238 #endif
14239
14240 if (rc != 0)
14241 {
14242 device_param->skipped = true;
14243
14244 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14245 }
14246 }
14247
14248 local_free (kernel_lengths);
14249 local_free (kernel_sources[0]);
14250 local_free (kernel_sources);
14251 }
14252
14253 /**
14254 * word generator kernel
14255 */
14256
14257 if (attack_mode != ATTACK_MODE_STRAIGHT)
14258 {
14259 /**
14260 * kernel mp source filename
14261 */
14262
14263 char source_file[256] = { 0 };
14264
14265 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14266
14267 struct stat sst;
14268
14269 if (stat (source_file, &sst) == -1)
14270 {
14271 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14272
14273 return -1;
14274 }
14275
14276 /**
14277 * kernel mp cached filename
14278 */
14279
14280 char cached_file[256] = { 0 };
14281
14282 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14283
14284 int cached = 1;
14285
14286 struct stat cst;
14287
14288 if (stat (cached_file, &cst) == -1)
14289 {
14290 cached = 0;
14291 }
14292
14293 /**
14294 * kernel compile or load
14295 */
14296
14297 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14298
14299 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14300
14301 if (cached == 0)
14302 {
14303 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14304 if (quiet == 0) log_info ("");
14305
14306 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14307
14308 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14309
14310 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14311
14312 if (rc != 0)
14313 {
14314 device_param->skipped = true;
14315
14316 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14317
14318 continue;
14319 }
14320
14321 size_t binary_size;
14322
14323 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14324
14325 u8 *binary = (u8 *) mymalloc (binary_size);
14326
14327 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14328
14329 writeProgramBin (cached_file, binary, binary_size);
14330
14331 local_free (binary);
14332 }
14333 else
14334 {
14335 #ifdef DEBUG
14336 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14337 #endif
14338
14339 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14340
14341 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14342
14343 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14344 }
14345
14346 local_free (kernel_lengths);
14347 local_free (kernel_sources[0]);
14348 local_free (kernel_sources);
14349 }
14350
14351 /**
14352 * amplifier kernel
14353 */
14354
14355 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14356 {
14357
14358 }
14359 else
14360 {
14361 /**
14362 * kernel amp source filename
14363 */
14364
14365 char source_file[256] = { 0 };
14366
14367 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14368
14369 struct stat sst;
14370
14371 if (stat (source_file, &sst) == -1)
14372 {
14373 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14374
14375 return -1;
14376 }
14377
14378 /**
14379 * kernel amp cached filename
14380 */
14381
14382 char cached_file[256] = { 0 };
14383
14384 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14385
14386 int cached = 1;
14387
14388 struct stat cst;
14389
14390 if (stat (cached_file, &cst) == -1)
14391 {
14392 cached = 0;
14393 }
14394
14395 /**
14396 * kernel compile or load
14397 */
14398
14399 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14400
14401 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14402
14403 if (cached == 0)
14404 {
14405 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14406 if (quiet == 0) log_info ("");
14407
14408 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14409
14410 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14411
14412 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14413
14414 if (rc != 0)
14415 {
14416 device_param->skipped = true;
14417
14418 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14419
14420 continue;
14421 }
14422
14423 size_t binary_size;
14424
14425 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14426
14427 u8 *binary = (u8 *) mymalloc (binary_size);
14428
14429 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14430
14431 writeProgramBin (cached_file, binary, binary_size);
14432
14433 local_free (binary);
14434 }
14435 else
14436 {
14437 #ifdef DEBUG
14438 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14439 #endif
14440
14441 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14442
14443 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14444
14445 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14446 }
14447
14448 local_free (kernel_lengths);
14449 local_free (kernel_sources[0]);
14450 local_free (kernel_sources);
14451 }
14452
14453 // some algorithm collide too fast, make that impossible
14454
14455 if (benchmark == 1)
14456 {
14457 ((uint *) digests_buf)[0] = -1;
14458 ((uint *) digests_buf)[1] = -1;
14459 ((uint *) digests_buf)[2] = -1;
14460 ((uint *) digests_buf)[3] = -1;
14461 }
14462
14463 /**
14464 * global buffers
14465 */
14466
14467 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14468 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14469 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14470 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14471 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14472 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14473 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14474 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14475 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14476 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14477 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14478 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14479 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14480 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14481 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14482 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14483 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14484 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14485
14486 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);
14487 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);
14488 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);
14489 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);
14490 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);
14491 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);
14492 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);
14493 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);
14494 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14495 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14496 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14497
14498 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14499 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14500 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14501 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14502 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14503 run_kernel_bzero (device_param, device_param->d_result, size_results);
14504
14505 /**
14506 * special buffers
14507 */
14508
14509 if (attack_kern == ATTACK_KERN_STRAIGHT)
14510 {
14511 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14512 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14513
14514 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14515
14516 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14517 }
14518 else if (attack_kern == ATTACK_KERN_COMBI)
14519 {
14520 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14521 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14522 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14523 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14524
14525 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14526 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14527 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14528 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14529 }
14530 else if (attack_kern == ATTACK_KERN_BF)
14531 {
14532 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14533 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14534 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14535 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14536 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14537
14538 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14539 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14540 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14541 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14542 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14543 }
14544
14545 if (size_esalts)
14546 {
14547 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14548
14549 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14550 }
14551
14552 /**
14553 * main host data
14554 */
14555
14556 uint *result = (uint *) mymalloc (size_results);
14557
14558 device_param->result = result;
14559
14560 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14561
14562 device_param->pws_buf = pws_buf;
14563
14564 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14565
14566 device_param->combs_buf = combs_buf;
14567
14568 void *hooks_buf = mymalloc (size_hooks);
14569
14570 device_param->hooks_buf = hooks_buf;
14571
14572 /**
14573 * kernel args
14574 */
14575
14576 device_param->kernel_params_buf32[21] = bitmap_mask;
14577 device_param->kernel_params_buf32[22] = bitmap_shift1;
14578 device_param->kernel_params_buf32[23] = bitmap_shift2;
14579 device_param->kernel_params_buf32[24] = 0; // salt_pos
14580 device_param->kernel_params_buf32[25] = 0; // loop_pos
14581 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14582 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14583 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14584 device_param->kernel_params_buf32[29] = 0; // digests_offset
14585 device_param->kernel_params_buf32[30] = 0; // combs_mode
14586 device_param->kernel_params_buf32[31] = 0; // gid_max
14587
14588 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14589 ? &device_param->d_pws_buf
14590 : &device_param->d_pws_amp_buf;
14591 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14592 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14593 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14594 device_param->kernel_params[ 4] = &device_param->d_tmps;
14595 device_param->kernel_params[ 5] = &device_param->d_hooks;
14596 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14597 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14598 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14599 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14600 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14601 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14602 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14603 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14604 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14605 device_param->kernel_params[15] = &device_param->d_digests_buf;
14606 device_param->kernel_params[16] = &device_param->d_digests_shown;
14607 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14608 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14609 device_param->kernel_params[19] = &device_param->d_result;
14610 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14611 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14612 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14613 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14614 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14615 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14616 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14617 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14618 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14619 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14620 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14621 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14622
14623 device_param->kernel_params_mp_buf64[3] = 0;
14624 device_param->kernel_params_mp_buf32[4] = 0;
14625 device_param->kernel_params_mp_buf32[5] = 0;
14626 device_param->kernel_params_mp_buf32[6] = 0;
14627 device_param->kernel_params_mp_buf32[7] = 0;
14628 device_param->kernel_params_mp_buf32[8] = 0;
14629
14630 device_param->kernel_params_mp[0] = NULL;
14631 device_param->kernel_params_mp[1] = NULL;
14632 device_param->kernel_params_mp[2] = NULL;
14633 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14634 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14635 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14636 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14637 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14638 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14639
14640 device_param->kernel_params_mp_l_buf64[3] = 0;
14641 device_param->kernel_params_mp_l_buf32[4] = 0;
14642 device_param->kernel_params_mp_l_buf32[5] = 0;
14643 device_param->kernel_params_mp_l_buf32[6] = 0;
14644 device_param->kernel_params_mp_l_buf32[7] = 0;
14645 device_param->kernel_params_mp_l_buf32[8] = 0;
14646 device_param->kernel_params_mp_l_buf32[9] = 0;
14647
14648 device_param->kernel_params_mp_l[0] = NULL;
14649 device_param->kernel_params_mp_l[1] = NULL;
14650 device_param->kernel_params_mp_l[2] = NULL;
14651 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14652 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14653 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14654 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14655 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14656 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14657 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14658
14659 device_param->kernel_params_mp_r_buf64[3] = 0;
14660 device_param->kernel_params_mp_r_buf32[4] = 0;
14661 device_param->kernel_params_mp_r_buf32[5] = 0;
14662 device_param->kernel_params_mp_r_buf32[6] = 0;
14663 device_param->kernel_params_mp_r_buf32[7] = 0;
14664 device_param->kernel_params_mp_r_buf32[8] = 0;
14665
14666 device_param->kernel_params_mp_r[0] = NULL;
14667 device_param->kernel_params_mp_r[1] = NULL;
14668 device_param->kernel_params_mp_r[2] = NULL;
14669 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14670 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14671 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14672 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14673 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14674 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14675
14676 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14677 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14678
14679 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14680 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14681 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14682 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14683 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14684 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14685 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14686
14687 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14688 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14689
14690 /**
14691 * kernel name
14692 */
14693
14694 size_t kernel_wgs_tmp;
14695
14696 char kernel_name[64] = { 0 };
14697
14698 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14699 {
14700 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14701 {
14702 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14703
14704 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14705
14706 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14707
14708 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14709
14710 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14711
14712 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14713 }
14714 else
14715 {
14716 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14717
14718 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14719
14720 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14721
14722 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14723
14724 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14725
14726 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14727 }
14728
14729 if (data.attack_mode == ATTACK_MODE_BF)
14730 {
14731 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14732 {
14733 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14734
14735 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14736
14737 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_tm, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
14738 }
14739 }
14740 }
14741 else
14742 {
14743 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14744
14745 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14746
14747 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14748
14749 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14750
14751 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14752
14753 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14754
14755 if (opts_type & OPTS_TYPE_HOOK12)
14756 {
14757 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14758
14759 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14760
14761 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel12, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
14762 }
14763
14764 if (opts_type & OPTS_TYPE_HOOK23)
14765 {
14766 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14767
14768 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14769
14770 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel23, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
14771 }
14772 }
14773
14774 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel1, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
14775 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel2, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
14776 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel3, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
14777
14778 for (uint i = 0; i <= 20; i++)
14779 {
14780 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14781 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14782 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14783
14784 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14785 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14786 }
14787
14788 for (uint i = 21; i <= 31; i++)
14789 {
14790 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14791 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14792 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14793
14794 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14795 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14796 }
14797
14798 if (attack_mode == ATTACK_MODE_BF)
14799 {
14800 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14801 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14802
14803 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_mp_l, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
14804 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_mp_r, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
14805
14806 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14807 {
14808 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14809 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14810 }
14811 }
14812 else if (attack_mode == ATTACK_MODE_HYBRID1)
14813 {
14814 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14815
14816 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_mp, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
14817 }
14818 else if (attack_mode == ATTACK_MODE_HYBRID2)
14819 {
14820 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14821
14822 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_mp, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
14823 }
14824
14825 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14826 {
14827 // nothing to do
14828 }
14829 else
14830 {
14831 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14832
14833 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_amp, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
14834 }
14835
14836 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14837 {
14838 // nothing to do
14839 }
14840 else
14841 {
14842 for (uint i = 0; i < 5; i++)
14843 {
14844 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14845 }
14846
14847 for (uint i = 5; i < 7; i++)
14848 {
14849 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14850 }
14851 }
14852
14853 // maybe this has been updated by clGetKernelWorkGroupInfo()
14854 // value can only be decreased, so we don't need to reallocate buffers
14855
14856 device_param->kernel_threads = kernel_threads;
14857
14858 /**
14859 * Store initial fanspeed if gpu_temp_retain is enabled
14860 */
14861
14862 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14863 int gpu_temp_retain_set = 0;
14864
14865 if (gpu_temp_disable == 0)
14866 {
14867 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14868 {
14869 hc_thread_mutex_lock (mux_adl);
14870
14871 if (data.hm_device[device_id].fan_supported == 1)
14872 {
14873 if (gpu_temp_retain_chgd == 0)
14874 {
14875 uint cur_temp = 0;
14876 uint default_temp = 0;
14877
14878 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);
14879
14880 if (ADL_rc == ADL_OK)
14881 {
14882 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14883
14884 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14885
14886 // special case with multi gpu setups: always use minimum retain
14887
14888 if (gpu_temp_retain_set == 0)
14889 {
14890 gpu_temp_retain = gpu_temp_retain_target;
14891 gpu_temp_retain_set = 1;
14892 }
14893 else
14894 {
14895 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14896 }
14897
14898 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14899 }
14900 }
14901
14902 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14903
14904 temp_retain_fanspeed_value[device_id] = fan_speed;
14905
14906 if (fan_speed == -1)
14907 {
14908 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14909
14910 temp_retain_fanspeed_value[device_id] = 0;
14911 }
14912 }
14913
14914 hc_thread_mutex_unlock (mux_adl);
14915 }
14916 }
14917
14918 /**
14919 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14920 */
14921
14922 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14923 {
14924 hc_thread_mutex_lock (mux_adl);
14925
14926 if (data.hm_device[device_id].od_version == 6)
14927 {
14928 int ADL_rc;
14929
14930 // check powertune capabilities first, if not available then skip device
14931
14932 int powertune_supported = 0;
14933
14934 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14935 {
14936 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14937
14938 return (-1);
14939 }
14940
14941 if (powertune_supported != 0)
14942 {
14943 // powercontrol settings
14944
14945 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14946
14947 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14948 {
14949 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14950 }
14951
14952 if (ADL_rc != ADL_OK)
14953 {
14954 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14955
14956 return (-1);
14957 }
14958
14959 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14960 {
14961 log_error ("ERROR: Failed to set new ADL PowerControl values");
14962
14963 return (-1);
14964 }
14965
14966 // clocks
14967
14968 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14969
14970 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14971
14972 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)
14973 {
14974 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14975
14976 return (-1);
14977 }
14978
14979 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14980
14981 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14982
14983 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14984 {
14985 log_error ("ERROR: Failed to get ADL device capabilities");
14986
14987 return (-1);
14988 }
14989
14990 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14991 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14992
14993 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14994 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14995
14996 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14997 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14998
14999 // warning if profile has too low max values
15000
15001 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
15002 {
15003 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
15004 }
15005
15006 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
15007 {
15008 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
15009 }
15010
15011 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
15012
15013 performance_state->iNumberOfPerformanceLevels = 2;
15014
15015 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
15016 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
15017 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
15018 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
15019
15020 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)
15021 {
15022 log_info ("ERROR: Failed to set ADL performance state");
15023
15024 return (-1);
15025 }
15026
15027 local_free (performance_state);
15028 }
15029 }
15030
15031 hc_thread_mutex_unlock (mux_adl);
15032 }
15033 #endif // HAVE_HWMON && HAVE_ADL
15034 }
15035
15036 data.kernel_power_all = kernel_power_all;
15037
15038 if (data.quiet == 0) log_info_nn ("");
15039
15040 /**
15041 * In benchmark-mode, inform user which algorithm is checked
15042 */
15043
15044 if (benchmark == 1)
15045 {
15046 if (status_automat == 0)
15047 {
15048 quiet = 0;
15049
15050 data.quiet = quiet;
15051
15052 char *hash_type = strhashtype (data.hash_mode); // not a bug
15053
15054 log_info ("Hashtype: %s", hash_type);
15055 log_info ("");
15056 }
15057 }
15058
15059 /**
15060 * keep track of the progress
15061 */
15062
15063 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15064 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15065 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15066
15067 /**
15068 * open filehandles
15069 */
15070
15071 #if _WIN
15072 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15073 {
15074 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15075
15076 return (-1);
15077 }
15078
15079 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15080 {
15081 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15082
15083 return (-1);
15084 }
15085
15086 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15087 {
15088 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15089
15090 return (-1);
15091 }
15092 #endif
15093
15094 /**
15095 * dictionary pad
15096 */
15097
15098 segment_size *= (1024 * 1024);
15099
15100 data.segment_size = segment_size;
15101
15102 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15103
15104 wl_data->buf = (char *) mymalloc (segment_size);
15105 wl_data->avail = segment_size;
15106 wl_data->incr = segment_size;
15107 wl_data->cnt = 0;
15108 wl_data->pos = 0;
15109
15110 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15111
15112 data.wordlist_mode = wordlist_mode;
15113
15114 cs_t *css_buf = NULL;
15115 uint css_cnt = 0;
15116 uint dictcnt = 0;
15117 uint maskcnt = 1;
15118 char **masks = NULL;
15119 char **dictfiles = NULL;
15120
15121 uint mask_from_file = 0;
15122
15123 if (attack_mode == ATTACK_MODE_STRAIGHT)
15124 {
15125 if (wordlist_mode == WL_MODE_FILE)
15126 {
15127 int wls_left = myargc - (optind + 1);
15128
15129 for (int i = 0; i < wls_left; i++)
15130 {
15131 char *l0_filename = myargv[optind + 1 + i];
15132
15133 struct stat l0_stat;
15134
15135 if (stat (l0_filename, &l0_stat) == -1)
15136 {
15137 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15138
15139 return (-1);
15140 }
15141
15142 uint is_dir = S_ISDIR (l0_stat.st_mode);
15143
15144 if (is_dir == 0)
15145 {
15146 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15147
15148 dictcnt++;
15149
15150 dictfiles[dictcnt - 1] = l0_filename;
15151 }
15152 else
15153 {
15154 // do not allow --keyspace w/ a directory
15155
15156 if (keyspace == 1)
15157 {
15158 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15159
15160 return (-1);
15161 }
15162
15163 char **dictionary_files = NULL;
15164
15165 dictionary_files = scan_directory (l0_filename);
15166
15167 if (dictionary_files != NULL)
15168 {
15169 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15170
15171 for (int d = 0; dictionary_files[d] != NULL; d++)
15172 {
15173 char *l1_filename = dictionary_files[d];
15174
15175 struct stat l1_stat;
15176
15177 if (stat (l1_filename, &l1_stat) == -1)
15178 {
15179 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15180
15181 return (-1);
15182 }
15183
15184 if (S_ISREG (l1_stat.st_mode))
15185 {
15186 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15187
15188 dictcnt++;
15189
15190 dictfiles[dictcnt - 1] = strdup (l1_filename);
15191 }
15192 }
15193 }
15194
15195 local_free (dictionary_files);
15196 }
15197 }
15198
15199 if (dictcnt < 1)
15200 {
15201 log_error ("ERROR: No usable dictionary file found.");
15202
15203 return (-1);
15204 }
15205 }
15206 else if (wordlist_mode == WL_MODE_STDIN)
15207 {
15208 dictcnt = 1;
15209 }
15210 }
15211 else if (attack_mode == ATTACK_MODE_COMBI)
15212 {
15213 // display
15214
15215 char *dictfile1 = myargv[optind + 1 + 0];
15216 char *dictfile2 = myargv[optind + 1 + 1];
15217
15218 // find the bigger dictionary and use as base
15219
15220 FILE *fp1 = NULL;
15221 FILE *fp2 = NULL;
15222
15223 struct stat tmp_stat;
15224
15225 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15226 {
15227 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15228
15229 return (-1);
15230 }
15231
15232 if (stat (dictfile1, &tmp_stat) == -1)
15233 {
15234 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15235
15236 fclose (fp1);
15237
15238 return (-1);
15239 }
15240
15241 if (S_ISDIR (tmp_stat.st_mode))
15242 {
15243 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15244
15245 fclose (fp1);
15246
15247 return (-1);
15248 }
15249
15250 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15251 {
15252 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15253
15254 fclose (fp1);
15255
15256 return (-1);
15257 }
15258
15259 if (stat (dictfile2, &tmp_stat) == -1)
15260 {
15261 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15262
15263 fclose (fp1);
15264 fclose (fp2);
15265
15266 return (-1);
15267 }
15268
15269 if (S_ISDIR (tmp_stat.st_mode))
15270 {
15271 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15272
15273 fclose (fp1);
15274 fclose (fp2);
15275
15276 return (-1);
15277 }
15278
15279 data.combs_cnt = 1;
15280
15281 data.quiet = 1;
15282
15283 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15284
15285 data.quiet = quiet;
15286
15287 if (words1_cnt == 0)
15288 {
15289 log_error ("ERROR: %s: empty file", dictfile1);
15290
15291 fclose (fp1);
15292 fclose (fp2);
15293
15294 return (-1);
15295 }
15296
15297 data.combs_cnt = 1;
15298
15299 data.quiet = 1;
15300
15301 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15302
15303 data.quiet = quiet;
15304
15305 if (words2_cnt == 0)
15306 {
15307 log_error ("ERROR: %s: empty file", dictfile2);
15308
15309 fclose (fp1);
15310 fclose (fp2);
15311
15312 return (-1);
15313 }
15314
15315 fclose (fp1);
15316 fclose (fp2);
15317
15318 data.dictfile = dictfile1;
15319 data.dictfile2 = dictfile2;
15320
15321 if (words1_cnt >= words2_cnt)
15322 {
15323 data.combs_cnt = words2_cnt;
15324 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15325
15326 dictfiles = &data.dictfile;
15327
15328 dictcnt = 1;
15329 }
15330 else
15331 {
15332 data.combs_cnt = words1_cnt;
15333 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15334
15335 dictfiles = &data.dictfile2;
15336
15337 dictcnt = 1;
15338
15339 // we also have to switch wordlist related rules!
15340
15341 char *tmpc = data.rule_buf_l;
15342
15343 data.rule_buf_l = data.rule_buf_r;
15344 data.rule_buf_r = tmpc;
15345
15346 int tmpi = data.rule_len_l;
15347
15348 data.rule_len_l = data.rule_len_r;
15349 data.rule_len_r = tmpi;
15350 }
15351 }
15352 else if (attack_mode == ATTACK_MODE_BF)
15353 {
15354 char *mask = NULL;
15355
15356 maskcnt = 0;
15357
15358 if (benchmark == 0)
15359 {
15360 mask = myargv[optind + 1];
15361
15362 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15363
15364 if ((optind + 2) <= myargc)
15365 {
15366 struct stat file_stat;
15367
15368 if (stat (mask, &file_stat) == -1)
15369 {
15370 maskcnt = 1;
15371
15372 masks[maskcnt - 1] = mystrdup (mask);
15373 }
15374 else
15375 {
15376 int wls_left = myargc - (optind + 1);
15377
15378 uint masks_avail = INCR_MASKS;
15379
15380 for (int i = 0; i < wls_left; i++)
15381 {
15382 if (i != 0)
15383 {
15384 mask = myargv[optind + 1 + i];
15385
15386 if (stat (mask, &file_stat) == -1)
15387 {
15388 log_error ("ERROR: %s: %s", mask, strerror (errno));
15389
15390 return (-1);
15391 }
15392 }
15393
15394 uint is_file = S_ISREG (file_stat.st_mode);
15395
15396 if (is_file == 1)
15397 {
15398 FILE *mask_fp;
15399
15400 if ((mask_fp = fopen (mask, "r")) == NULL)
15401 {
15402 log_error ("ERROR: %s: %s", mask, strerror (errno));
15403
15404 return (-1);
15405 }
15406
15407 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15408
15409 while (!feof (mask_fp))
15410 {
15411 memset (line_buf, 0, HCBUFSIZ);
15412
15413 int line_len = fgetl (mask_fp, line_buf);
15414
15415 if (line_len == 0) continue;
15416
15417 if (line_buf[0] == '#') continue;
15418
15419 if (masks_avail == maskcnt)
15420 {
15421 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15422
15423 masks_avail += INCR_MASKS;
15424 }
15425
15426 masks[maskcnt] = mystrdup (line_buf);
15427
15428 maskcnt++;
15429 }
15430
15431 myfree (line_buf);
15432
15433 fclose (mask_fp);
15434 }
15435 else
15436 {
15437 log_error ("ERROR: %s: unsupported file-type", mask);
15438
15439 return (-1);
15440 }
15441 }
15442
15443 mask_from_file = 1;
15444 }
15445 }
15446 else
15447 {
15448 custom_charset_1 = (char *) "?l?d?u";
15449 custom_charset_2 = (char *) "?l?d";
15450 custom_charset_3 = (char *) "?l?d*!$@_";
15451
15452 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15453 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15454 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15455
15456 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15457
15458 wordlist_mode = WL_MODE_MASK;
15459
15460 data.wordlist_mode = wordlist_mode;
15461
15462 increment = 1;
15463
15464 maskcnt = 1;
15465 }
15466 }
15467 else
15468 {
15469 /**
15470 * generate full masks and charsets
15471 */
15472
15473 masks = (char **) mymalloc (sizeof (char *));
15474
15475 switch (hash_mode)
15476 {
15477 case 1731: pw_min = 5;
15478 pw_max = 5;
15479 mask = mystrdup ("?b?b?b?b?b");
15480 break;
15481 case 12500: pw_min = 5;
15482 pw_max = 5;
15483 mask = mystrdup ("?b?b?b?b?b");
15484 break;
15485 default: pw_min = 7;
15486 pw_max = 7;
15487 mask = mystrdup ("?b?b?b?b?b?b?b");
15488 break;
15489 }
15490
15491 maskcnt = 1;
15492
15493 masks[maskcnt - 1] = mystrdup (mask);
15494
15495 wordlist_mode = WL_MODE_MASK;
15496
15497 data.wordlist_mode = wordlist_mode;
15498
15499 increment = 1;
15500 }
15501
15502 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15503
15504 if (increment)
15505 {
15506 if (increment_min > pw_min) pw_min = increment_min;
15507
15508 if (increment_max < pw_max) pw_max = increment_max;
15509 }
15510 }
15511 else if (attack_mode == ATTACK_MODE_HYBRID1)
15512 {
15513 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15514
15515 // display
15516
15517 char *mask = myargv[myargc - 1];
15518
15519 maskcnt = 0;
15520
15521 masks = (char **) mymalloc (1 * sizeof (char *));
15522
15523 // mod
15524
15525 struct stat file_stat;
15526
15527 if (stat (mask, &file_stat) == -1)
15528 {
15529 maskcnt = 1;
15530
15531 masks[maskcnt - 1] = mystrdup (mask);
15532 }
15533 else
15534 {
15535 uint is_file = S_ISREG (file_stat.st_mode);
15536
15537 if (is_file == 1)
15538 {
15539 FILE *mask_fp;
15540
15541 if ((mask_fp = fopen (mask, "r")) == NULL)
15542 {
15543 log_error ("ERROR: %s: %s", mask, strerror (errno));
15544
15545 return (-1);
15546 }
15547
15548 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15549
15550 uint masks_avail = 1;
15551
15552 while (!feof (mask_fp))
15553 {
15554 memset (line_buf, 0, HCBUFSIZ);
15555
15556 int line_len = fgetl (mask_fp, line_buf);
15557
15558 if (line_len == 0) continue;
15559
15560 if (line_buf[0] == '#') continue;
15561
15562 if (masks_avail == maskcnt)
15563 {
15564 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15565
15566 masks_avail += INCR_MASKS;
15567 }
15568
15569 masks[maskcnt] = mystrdup (line_buf);
15570
15571 maskcnt++;
15572 }
15573
15574 myfree (line_buf);
15575
15576 fclose (mask_fp);
15577
15578 mask_from_file = 1;
15579 }
15580 else
15581 {
15582 maskcnt = 1;
15583
15584 masks[maskcnt - 1] = mystrdup (mask);
15585 }
15586 }
15587
15588 // base
15589
15590 int wls_left = myargc - (optind + 2);
15591
15592 for (int i = 0; i < wls_left; i++)
15593 {
15594 char *filename = myargv[optind + 1 + i];
15595
15596 struct stat file_stat;
15597
15598 if (stat (filename, &file_stat) == -1)
15599 {
15600 log_error ("ERROR: %s: %s", filename, strerror (errno));
15601
15602 return (-1);
15603 }
15604
15605 uint is_dir = S_ISDIR (file_stat.st_mode);
15606
15607 if (is_dir == 0)
15608 {
15609 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15610
15611 dictcnt++;
15612
15613 dictfiles[dictcnt - 1] = filename;
15614 }
15615 else
15616 {
15617 // do not allow --keyspace w/ a directory
15618
15619 if (keyspace == 1)
15620 {
15621 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15622
15623 return (-1);
15624 }
15625
15626 char **dictionary_files = NULL;
15627
15628 dictionary_files = scan_directory (filename);
15629
15630 if (dictionary_files != NULL)
15631 {
15632 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15633
15634 for (int d = 0; dictionary_files[d] != NULL; d++)
15635 {
15636 char *l1_filename = dictionary_files[d];
15637
15638 struct stat l1_stat;
15639
15640 if (stat (l1_filename, &l1_stat) == -1)
15641 {
15642 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15643
15644 return (-1);
15645 }
15646
15647 if (S_ISREG (l1_stat.st_mode))
15648 {
15649 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15650
15651 dictcnt++;
15652
15653 dictfiles[dictcnt - 1] = strdup (l1_filename);
15654 }
15655 }
15656 }
15657
15658 local_free (dictionary_files);
15659 }
15660 }
15661
15662 if (dictcnt < 1)
15663 {
15664 log_error ("ERROR: No usable dictionary file found.");
15665
15666 return (-1);
15667 }
15668
15669 if (increment)
15670 {
15671 maskcnt = 0;
15672
15673 uint mask_min = increment_min; // we can't reject smaller masks here
15674 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15675
15676 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15677 {
15678 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15679
15680 if (cur_mask == NULL) break;
15681
15682 masks[maskcnt] = cur_mask;
15683
15684 maskcnt++;
15685
15686 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15687 }
15688 }
15689 }
15690 else if (attack_mode == ATTACK_MODE_HYBRID2)
15691 {
15692 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15693
15694 // display
15695
15696 char *mask = myargv[optind + 1 + 0];
15697
15698 maskcnt = 0;
15699
15700 masks = (char **) mymalloc (1 * sizeof (char *));
15701
15702 // mod
15703
15704 struct stat file_stat;
15705
15706 if (stat (mask, &file_stat) == -1)
15707 {
15708 maskcnt = 1;
15709
15710 masks[maskcnt - 1] = mystrdup (mask);
15711 }
15712 else
15713 {
15714 uint is_file = S_ISREG (file_stat.st_mode);
15715
15716 if (is_file == 1)
15717 {
15718 FILE *mask_fp;
15719
15720 if ((mask_fp = fopen (mask, "r")) == NULL)
15721 {
15722 log_error ("ERROR: %s: %s", mask, strerror (errno));
15723
15724 return (-1);
15725 }
15726
15727 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15728
15729 uint masks_avail = 1;
15730
15731 while (!feof (mask_fp))
15732 {
15733 memset (line_buf, 0, HCBUFSIZ);
15734
15735 int line_len = fgetl (mask_fp, line_buf);
15736
15737 if (line_len == 0) continue;
15738
15739 if (line_buf[0] == '#') continue;
15740
15741 if (masks_avail == maskcnt)
15742 {
15743 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15744
15745 masks_avail += INCR_MASKS;
15746 }
15747
15748 masks[maskcnt] = mystrdup (line_buf);
15749
15750 maskcnt++;
15751 }
15752
15753 myfree (line_buf);
15754
15755 fclose (mask_fp);
15756
15757 mask_from_file = 1;
15758 }
15759 else
15760 {
15761 maskcnt = 1;
15762
15763 masks[maskcnt - 1] = mystrdup (mask);
15764 }
15765 }
15766
15767 // base
15768
15769 int wls_left = myargc - (optind + 2);
15770
15771 for (int i = 0; i < wls_left; i++)
15772 {
15773 char *filename = myargv[optind + 2 + i];
15774
15775 struct stat file_stat;
15776
15777 if (stat (filename, &file_stat) == -1)
15778 {
15779 log_error ("ERROR: %s: %s", filename, strerror (errno));
15780
15781 return (-1);
15782 }
15783
15784 uint is_dir = S_ISDIR (file_stat.st_mode);
15785
15786 if (is_dir == 0)
15787 {
15788 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15789
15790 dictcnt++;
15791
15792 dictfiles[dictcnt - 1] = filename;
15793 }
15794 else
15795 {
15796 // do not allow --keyspace w/ a directory
15797
15798 if (keyspace == 1)
15799 {
15800 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15801
15802 return (-1);
15803 }
15804
15805 char **dictionary_files = NULL;
15806
15807 dictionary_files = scan_directory (filename);
15808
15809 if (dictionary_files != NULL)
15810 {
15811 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15812
15813 for (int d = 0; dictionary_files[d] != NULL; d++)
15814 {
15815 char *l1_filename = dictionary_files[d];
15816
15817 struct stat l1_stat;
15818
15819 if (stat (l1_filename, &l1_stat) == -1)
15820 {
15821 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15822
15823 return (-1);
15824 }
15825
15826 if (S_ISREG (l1_stat.st_mode))
15827 {
15828 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15829
15830 dictcnt++;
15831
15832 dictfiles[dictcnt - 1] = strdup (l1_filename);
15833 }
15834 }
15835 }
15836
15837 local_free (dictionary_files);
15838 }
15839 }
15840
15841 if (dictcnt < 1)
15842 {
15843 log_error ("ERROR: No usable dictionary file found.");
15844
15845 return (-1);
15846 }
15847
15848 if (increment)
15849 {
15850 maskcnt = 0;
15851
15852 uint mask_min = increment_min; // we can't reject smaller masks here
15853 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15854
15855 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15856 {
15857 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15858
15859 if (cur_mask == NULL) break;
15860
15861 masks[maskcnt] = cur_mask;
15862
15863 maskcnt++;
15864
15865 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15866 }
15867 }
15868 }
15869
15870 data.pw_min = pw_min;
15871 data.pw_max = pw_max;
15872
15873 /**
15874 * weak hash check
15875 */
15876
15877 if (weak_hash_threshold >= salts_cnt)
15878 {
15879 hc_device_param_t *device_param = NULL;
15880
15881 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15882 {
15883 device_param = &data.devices_param[device_id];
15884
15885 if (device_param->skipped) continue;
15886
15887 break;
15888 }
15889
15890 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15891
15892 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15893 {
15894 weak_hash_check (device_param, salt_pos);
15895 }
15896
15897 // Display hack, guarantee that there is at least one \r before real start
15898
15899 //if (data.quiet == 0) log_info ("");
15900 }
15901
15902 /**
15903 * status and monitor threads
15904 */
15905
15906 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15907
15908 hc_thread_t i_thread = 0;
15909
15910 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15911 {
15912 hc_thread_create (i_thread, thread_keypress, &benchmark);
15913 }
15914
15915 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15916
15917 uint ni_threads_cnt = 0;
15918
15919 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15920
15921 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15922
15923 ni_threads_cnt++;
15924
15925 /**
15926 * Outfile remove
15927 */
15928
15929 if (keyspace == 0)
15930 {
15931 if (outfile_check_timer != 0)
15932 {
15933 if (data.outfile_check_directory != NULL)
15934 {
15935 if ((hash_mode != 5200) &&
15936 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15937 (hash_mode != 9000))
15938 {
15939 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15940
15941 ni_threads_cnt++;
15942 }
15943 else
15944 {
15945 outfile_check_timer = 0;
15946 }
15947 }
15948 else
15949 {
15950 outfile_check_timer = 0;
15951 }
15952 }
15953 }
15954
15955 /**
15956 * Inform the user if we got some hashes remove because of the pot file remove feature
15957 */
15958
15959 if (data.quiet == 0)
15960 {
15961 if (potfile_remove_cracks > 0)
15962 {
15963 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15964 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15965 }
15966 }
15967
15968 data.outfile_check_timer = outfile_check_timer;
15969
15970 /**
15971 * main loop
15972 */
15973
15974 char **induction_dictionaries = NULL;
15975
15976 int induction_dictionaries_cnt = 0;
15977
15978 hcstat_table_t *root_table_buf = NULL;
15979 hcstat_table_t *markov_table_buf = NULL;
15980
15981 uint initial_restore_done = 0;
15982
15983 data.maskcnt = maskcnt;
15984
15985 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15986 {
15987 if (data.devices_status == STATUS_CRACKED) break;
15988
15989 data.devices_status = STATUS_INIT;
15990
15991 if (maskpos > rd->maskpos)
15992 {
15993 rd->dictpos = 0;
15994 }
15995
15996 rd->maskpos = maskpos;
15997 data.maskpos = maskpos;
15998
15999 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16000 {
16001 char *mask = masks[maskpos];
16002
16003 if (mask_from_file == 1)
16004 {
16005 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16006
16007 char *str_ptr;
16008 uint str_pos;
16009
16010 uint mask_offset = 0;
16011
16012 uint separator_cnt;
16013
16014 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16015 {
16016 str_ptr = strstr (mask + mask_offset, ",");
16017
16018 if (str_ptr == NULL) break;
16019
16020 str_pos = str_ptr - mask;
16021
16022 // escaped separator, i.e. "\,"
16023
16024 if (str_pos > 0)
16025 {
16026 if (mask[str_pos - 1] == '\\')
16027 {
16028 separator_cnt --;
16029
16030 mask_offset = str_pos + 1;
16031
16032 continue;
16033 }
16034 }
16035
16036 // reset the offset
16037
16038 mask_offset = 0;
16039
16040 mask[str_pos] = '\0';
16041
16042 switch (separator_cnt)
16043 {
16044 case 0:
16045 mp_reset_usr (mp_usr, 0);
16046
16047 custom_charset_1 = mask;
16048 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16049 break;
16050
16051 case 1:
16052 mp_reset_usr (mp_usr, 1);
16053
16054 custom_charset_2 = mask;
16055 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16056 break;
16057
16058 case 2:
16059 mp_reset_usr (mp_usr, 2);
16060
16061 custom_charset_3 = mask;
16062 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16063 break;
16064
16065 case 3:
16066 mp_reset_usr (mp_usr, 3);
16067
16068 custom_charset_4 = mask;
16069 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16070 break;
16071 }
16072
16073 mask = mask + str_pos + 1;
16074 }
16075 }
16076
16077 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16078 {
16079 if (maskpos > 0)
16080 {
16081 local_free (css_buf);
16082 local_free (data.root_css_buf);
16083 local_free (data.markov_css_buf);
16084
16085 local_free (masks[maskpos - 1]);
16086 }
16087
16088 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16089
16090 data.mask = mask;
16091 data.css_cnt = css_cnt;
16092 data.css_buf = css_buf;
16093
16094 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16095
16096 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16097
16098 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16099 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16100
16101 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16102
16103 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16104
16105 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16106 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16107
16108 data.root_css_buf = root_css_buf;
16109 data.markov_css_buf = markov_css_buf;
16110
16111 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16112
16113 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16114
16115 local_free (root_table_buf);
16116 local_free (markov_table_buf);
16117
16118 // args
16119
16120 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16121 {
16122 hc_device_param_t *device_param = &data.devices_param[device_id];
16123
16124 if (device_param->skipped) continue;
16125
16126 device_param->kernel_params_mp[0] = &device_param->d_combs;
16127 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16128 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16129
16130 device_param->kernel_params_mp_buf64[3] = 0;
16131 device_param->kernel_params_mp_buf32[4] = css_cnt;
16132 device_param->kernel_params_mp_buf32[5] = 0;
16133 device_param->kernel_params_mp_buf32[6] = 0;
16134 device_param->kernel_params_mp_buf32[7] = 0;
16135
16136 if (attack_mode == ATTACK_MODE_HYBRID1)
16137 {
16138 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16139 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16140 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16141 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16142 }
16143 else if (attack_mode == ATTACK_MODE_HYBRID2)
16144 {
16145 device_param->kernel_params_mp_buf32[5] = 0;
16146 device_param->kernel_params_mp_buf32[6] = 0;
16147 device_param->kernel_params_mp_buf32[7] = 0;
16148 }
16149
16150 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]);
16151 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]);
16152 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]);
16153
16154 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);
16155 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);
16156 }
16157 }
16158 else if (attack_mode == ATTACK_MODE_BF)
16159 {
16160 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16161
16162 if (increment)
16163 {
16164 for (uint i = 0; i < dictcnt; i++)
16165 {
16166 local_free (dictfiles[i]);
16167 }
16168
16169 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16170 {
16171 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16172
16173 if (l1_filename == NULL) break;
16174
16175 dictcnt++;
16176
16177 dictfiles[dictcnt - 1] = l1_filename;
16178 }
16179 }
16180 else
16181 {
16182 dictcnt++;
16183
16184 dictfiles[dictcnt - 1] = mask;
16185 }
16186
16187 if (dictcnt == 0)
16188 {
16189 log_error ("ERROR: Mask is too small");
16190
16191 return (-1);
16192 }
16193 }
16194 }
16195
16196 free (induction_dictionaries);
16197
16198 // induction_dictionaries_cnt = 0; // implied
16199
16200 if (attack_mode != ATTACK_MODE_BF)
16201 {
16202 if (keyspace == 0)
16203 {
16204 induction_dictionaries = scan_directory (induction_directory);
16205
16206 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16207 }
16208 }
16209
16210 if (induction_dictionaries_cnt)
16211 {
16212 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16213 }
16214
16215 /**
16216 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16217 */
16218 if (keyspace == 1)
16219 {
16220 if ((maskcnt > 1) || (dictcnt > 1))
16221 {
16222 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16223
16224 return (-1);
16225 }
16226 }
16227
16228 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16229 {
16230 char *subid = logfile_generate_subid ();
16231
16232 data.subid = subid;
16233
16234 logfile_sub_msg ("START");
16235
16236 data.devices_status = STATUS_INIT;
16237
16238 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16239 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16240 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16241
16242 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16243
16244 data.cpt_pos = 0;
16245
16246 data.cpt_start = time (NULL);
16247
16248 data.cpt_total = 0;
16249
16250 if (data.restore == 0)
16251 {
16252 rd->words_cur = skip;
16253
16254 skip = 0;
16255
16256 data.skip = 0;
16257 }
16258
16259 data.ms_paused = 0;
16260
16261 data.words_cur = rd->words_cur;
16262
16263 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16264 {
16265 hc_device_param_t *device_param = &data.devices_param[device_id];
16266
16267 if (device_param->skipped) continue;
16268
16269 device_param->speed_pos = 0;
16270
16271 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16272 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16273
16274 device_param->exec_pos = 0;
16275
16276 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16277
16278 device_param->kernel_power = device_param->kernel_power_user;
16279
16280 device_param->outerloop_pos = 0;
16281 device_param->outerloop_left = 0;
16282 device_param->innerloop_pos = 0;
16283 device_param->innerloop_left = 0;
16284
16285 // some more resets:
16286
16287 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16288
16289 device_param->pws_cnt = 0;
16290
16291 device_param->words_off = 0;
16292 device_param->words_done = 0;
16293 }
16294
16295 data.kernel_power_div = 0;
16296
16297 // figure out some workload
16298
16299 if (attack_mode == ATTACK_MODE_STRAIGHT)
16300 {
16301 if (data.wordlist_mode == WL_MODE_FILE)
16302 {
16303 char *dictfile = NULL;
16304
16305 if (induction_dictionaries_cnt)
16306 {
16307 dictfile = induction_dictionaries[0];
16308 }
16309 else
16310 {
16311 dictfile = dictfiles[dictpos];
16312 }
16313
16314 data.dictfile = dictfile;
16315
16316 logfile_sub_string (dictfile);
16317
16318 for (uint i = 0; i < rp_files_cnt; i++)
16319 {
16320 logfile_sub_var_string ("rulefile", rp_files[i]);
16321 }
16322
16323 FILE *fd2 = fopen (dictfile, "rb");
16324
16325 if (fd2 == NULL)
16326 {
16327 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16328
16329 return (-1);
16330 }
16331
16332 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16333
16334 fclose (fd2);
16335
16336 if (data.words_cnt == 0)
16337 {
16338 if (data.devices_status == STATUS_CRACKED) break;
16339 if (data.devices_status == STATUS_ABORTED) break;
16340
16341 dictpos++;
16342
16343 continue;
16344 }
16345 }
16346 }
16347 else if (attack_mode == ATTACK_MODE_COMBI)
16348 {
16349 char *dictfile = data.dictfile;
16350 char *dictfile2 = data.dictfile2;
16351
16352 logfile_sub_string (dictfile);
16353 logfile_sub_string (dictfile2);
16354
16355 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16356 {
16357 FILE *fd2 = fopen (dictfile, "rb");
16358
16359 if (fd2 == NULL)
16360 {
16361 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16362
16363 return (-1);
16364 }
16365
16366 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16367
16368 fclose (fd2);
16369 }
16370 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16371 {
16372 FILE *fd2 = fopen (dictfile2, "rb");
16373
16374 if (fd2 == NULL)
16375 {
16376 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16377
16378 return (-1);
16379 }
16380
16381 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16382
16383 fclose (fd2);
16384 }
16385
16386 if (data.words_cnt == 0)
16387 {
16388 if (data.devices_status == STATUS_CRACKED) break;
16389 if (data.devices_status == STATUS_ABORTED) break;
16390
16391 dictpos++;
16392
16393 continue;
16394 }
16395 }
16396 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16397 {
16398 char *dictfile = NULL;
16399
16400 if (induction_dictionaries_cnt)
16401 {
16402 dictfile = induction_dictionaries[0];
16403 }
16404 else
16405 {
16406 dictfile = dictfiles[dictpos];
16407 }
16408
16409 data.dictfile = dictfile;
16410
16411 char *mask = data.mask;
16412
16413 logfile_sub_string (dictfile);
16414 logfile_sub_string (mask);
16415
16416 FILE *fd2 = fopen (dictfile, "rb");
16417
16418 if (fd2 == NULL)
16419 {
16420 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16421
16422 return (-1);
16423 }
16424
16425 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16426
16427 fclose (fd2);
16428
16429 if (data.words_cnt == 0)
16430 {
16431 if (data.devices_status == STATUS_CRACKED) break;
16432 if (data.devices_status == STATUS_ABORTED) break;
16433
16434 dictpos++;
16435
16436 continue;
16437 }
16438 }
16439 else if (attack_mode == ATTACK_MODE_BF)
16440 {
16441 local_free (css_buf);
16442 local_free (data.root_css_buf);
16443 local_free (data.markov_css_buf);
16444
16445 char *mask = dictfiles[dictpos];
16446
16447 logfile_sub_string (mask);
16448
16449 // base
16450
16451 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16452
16453 if (opts_type & OPTS_TYPE_PT_UNICODE)
16454 {
16455 uint css_cnt_unicode = css_cnt * 2;
16456
16457 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16458
16459 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16460 {
16461 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16462
16463 css_buf_unicode[j + 1].cs_buf[0] = 0;
16464 css_buf_unicode[j + 1].cs_len = 1;
16465 }
16466
16467 free (css_buf);
16468
16469 css_buf = css_buf_unicode;
16470 css_cnt = css_cnt_unicode;
16471 }
16472
16473 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16474
16475 uint mask_min = pw_min;
16476 uint mask_max = pw_max;
16477
16478 if (opts_type & OPTS_TYPE_PT_UNICODE)
16479 {
16480 mask_min *= 2;
16481 mask_max *= 2;
16482 }
16483
16484 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16485 {
16486 if (css_cnt < mask_min)
16487 {
16488 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16489 }
16490
16491 if (css_cnt > mask_max)
16492 {
16493 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16494 }
16495
16496 // skip to next mask
16497
16498 dictpos++;
16499
16500 rd->dictpos = dictpos;
16501
16502 logfile_sub_msg ("STOP");
16503
16504 continue;
16505 }
16506
16507 uint save_css_cnt = css_cnt;
16508
16509 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16510 {
16511 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16512 {
16513 uint salt_len = (uint) data.salts_buf[0].salt_len;
16514 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16515
16516 uint css_cnt_salt = css_cnt + salt_len;
16517
16518 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16519
16520 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16521
16522 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16523 {
16524 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16525 css_buf_salt[j].cs_len = 1;
16526 }
16527
16528 free (css_buf);
16529
16530 css_buf = css_buf_salt;
16531 css_cnt = css_cnt_salt;
16532 }
16533 }
16534
16535 data.mask = mask;
16536 data.css_cnt = css_cnt;
16537 data.css_buf = css_buf;
16538
16539 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16540
16541 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16542
16543 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16544
16545 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16546 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16547
16548 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16549
16550 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16551
16552 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16553 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16554
16555 data.root_css_buf = root_css_buf;
16556 data.markov_css_buf = markov_css_buf;
16557
16558 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16559
16560 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16561
16562 local_free (root_table_buf);
16563 local_free (markov_table_buf);
16564
16565 // copy + args
16566
16567 uint css_cnt_l = css_cnt;
16568 uint css_cnt_r;
16569
16570 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16571 {
16572 if (save_css_cnt < 6)
16573 {
16574 css_cnt_r = 1;
16575 }
16576 else if (save_css_cnt == 6)
16577 {
16578 css_cnt_r = 2;
16579 }
16580 else
16581 {
16582 if (opts_type & OPTS_TYPE_PT_UNICODE)
16583 {
16584 if (save_css_cnt == 8 || save_css_cnt == 10)
16585 {
16586 css_cnt_r = 2;
16587 }
16588 else
16589 {
16590 css_cnt_r = 4;
16591 }
16592 }
16593 else
16594 {
16595 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16596 {
16597 css_cnt_r = 3;
16598 }
16599 else
16600 {
16601 css_cnt_r = 4;
16602 }
16603 }
16604 }
16605 }
16606 else
16607 {
16608 css_cnt_r = 1;
16609
16610 /* unfinished code?
16611 int sum = css_buf[css_cnt_r - 1].cs_len;
16612
16613 for (uint i = 1; i < 4 && i < css_cnt; i++)
16614 {
16615 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16616
16617 css_cnt_r++;
16618
16619 sum *= css_buf[css_cnt_r - 1].cs_len;
16620 }
16621 */
16622 }
16623
16624 css_cnt_l -= css_cnt_r;
16625
16626 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16627
16628 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16629 {
16630 hc_device_param_t *device_param = &data.devices_param[device_id];
16631
16632 if (device_param->skipped) continue;
16633
16634 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16635 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16636 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16637
16638 device_param->kernel_params_mp_l_buf64[3] = 0;
16639 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16640 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16641 device_param->kernel_params_mp_l_buf32[6] = 0;
16642 device_param->kernel_params_mp_l_buf32[7] = 0;
16643 device_param->kernel_params_mp_l_buf32[8] = 0;
16644
16645 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16646 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16647 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16648 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16649
16650 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16651 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16652 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16653
16654 device_param->kernel_params_mp_r_buf64[3] = 0;
16655 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16656 device_param->kernel_params_mp_r_buf32[5] = 0;
16657 device_param->kernel_params_mp_r_buf32[6] = 0;
16658 device_param->kernel_params_mp_r_buf32[7] = 0;
16659
16660 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]);
16661 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]);
16662 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]);
16663
16664 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]);
16665 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]);
16666 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]);
16667
16668 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);
16669 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);
16670 }
16671 }
16672
16673 u64 words_base = data.words_cnt;
16674
16675 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16676 {
16677 if (data.kernel_rules_cnt)
16678 {
16679 words_base /= data.kernel_rules_cnt;
16680 }
16681 }
16682 else if (data.attack_kern == ATTACK_KERN_COMBI)
16683 {
16684 if (data.combs_cnt)
16685 {
16686 words_base /= data.combs_cnt;
16687 }
16688 }
16689 else if (data.attack_kern == ATTACK_KERN_BF)
16690 {
16691 if (data.bfs_cnt)
16692 {
16693 words_base /= data.bfs_cnt;
16694 }
16695 }
16696
16697 data.words_base = words_base;
16698
16699 if (keyspace == 1)
16700 {
16701 log_info ("%llu", (unsigned long long int) words_base);
16702
16703 return (0);
16704 }
16705
16706 if (data.words_cur > data.words_base)
16707 {
16708 log_error ("ERROR: restore value greater keyspace");
16709
16710 return (-1);
16711 }
16712
16713 if (data.words_cur)
16714 {
16715 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16716 {
16717 for (uint i = 0; i < data.salts_cnt; i++)
16718 {
16719 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16720 }
16721 }
16722 else if (data.attack_kern == ATTACK_KERN_COMBI)
16723 {
16724 for (uint i = 0; i < data.salts_cnt; i++)
16725 {
16726 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16727 }
16728 }
16729 else if (data.attack_kern == ATTACK_KERN_BF)
16730 {
16731 for (uint i = 0; i < data.salts_cnt; i++)
16732 {
16733 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16734 }
16735 }
16736 }
16737
16738 /*
16739 * Inform user about possible slow speeds
16740 */
16741
16742 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16743 {
16744 if (data.words_base < kernel_power_all)
16745 {
16746 if (quiet == 0)
16747 {
16748 log_info ("ATTENTION!");
16749 log_info (" The wordlist or mask you are using is too small.");
16750 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
16751 log_info (" The cracking speed will drop.");
16752 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16753 log_info ("");
16754 }
16755 }
16756 }
16757
16758 /*
16759 * Update loopback file
16760 */
16761
16762 if (loopback == 1)
16763 {
16764 time_t now;
16765
16766 time (&now);
16767
16768 uint random_num = get_random_num (0, 9999);
16769
16770 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16771
16772 data.loopback_file = loopback_file;
16773 }
16774
16775 /*
16776 * Update dictionary statistic
16777 */
16778
16779 if (keyspace == 0)
16780 {
16781 dictstat_fp = fopen (dictstat, "wb");
16782
16783 if (dictstat_fp)
16784 {
16785 lock_file (dictstat_fp);
16786
16787 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16788
16789 fclose (dictstat_fp);
16790 }
16791 }
16792
16793 data.devices_status = STATUS_RUNNING;
16794
16795 if (initial_restore_done == 0)
16796 {
16797 if (data.restore_disable == 0) cycle_restore ();
16798
16799 initial_restore_done = 1;
16800 }
16801
16802 hc_timer_set (&data.timer_running);
16803
16804 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16805 {
16806 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16807 {
16808 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16809 if (quiet == 0) fflush (stdout);
16810 }
16811 }
16812 else if (wordlist_mode == WL_MODE_STDIN)
16813 {
16814 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16815 if (data.quiet == 0) log_info ("");
16816 }
16817
16818 time_t runtime_start;
16819
16820 time (&runtime_start);
16821
16822 data.runtime_start = runtime_start;
16823
16824 /**
16825 * create cracker threads
16826 */
16827
16828 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16829
16830 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16831 {
16832 hc_device_param_t *device_param = &devices_param[device_id];
16833
16834 if (wordlist_mode == WL_MODE_STDIN)
16835 {
16836 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16837 }
16838 else
16839 {
16840 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16841 }
16842 }
16843
16844 // wait for crack threads to exit
16845
16846 hc_thread_wait (data.devices_cnt, c_threads);
16847
16848 local_free (c_threads);
16849
16850 data.restore = 0;
16851
16852 // finalize task
16853
16854 logfile_sub_var_uint ("status-after-work", data.devices_status);
16855
16856 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16857
16858 if (data.devices_status == STATUS_CRACKED) break;
16859 if (data.devices_status == STATUS_ABORTED) break;
16860
16861 if (data.devices_status == STATUS_BYPASS)
16862 {
16863 data.devices_status = STATUS_RUNNING;
16864 }
16865
16866 if (induction_dictionaries_cnt)
16867 {
16868 unlink (induction_dictionaries[0]);
16869 }
16870
16871 free (induction_dictionaries);
16872
16873 if (attack_mode != ATTACK_MODE_BF)
16874 {
16875 induction_dictionaries = scan_directory (induction_directory);
16876
16877 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16878 }
16879
16880 if (benchmark == 0)
16881 {
16882 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16883 {
16884 if (quiet == 0) clear_prompt ();
16885
16886 if (quiet == 0) log_info ("");
16887
16888 if (status == 1)
16889 {
16890 status_display ();
16891 }
16892 else
16893 {
16894 if (quiet == 0) status_display ();
16895 }
16896
16897 if (quiet == 0) log_info ("");
16898 }
16899 }
16900
16901 if (attack_mode == ATTACK_MODE_BF)
16902 {
16903 dictpos++;
16904
16905 rd->dictpos = dictpos;
16906 }
16907 else
16908 {
16909 if (induction_dictionaries_cnt)
16910 {
16911 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16912 }
16913 else
16914 {
16915 dictpos++;
16916
16917 rd->dictpos = dictpos;
16918 }
16919 }
16920
16921 time_t runtime_stop;
16922
16923 time (&runtime_stop);
16924
16925 data.runtime_stop = runtime_stop;
16926
16927 logfile_sub_uint (runtime_start);
16928 logfile_sub_uint (runtime_stop);
16929
16930 logfile_sub_msg ("STOP");
16931
16932 global_free (subid);
16933 }
16934
16935 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16936
16937 if (data.devices_status == STATUS_CRACKED) break;
16938 if (data.devices_status == STATUS_ABORTED) break;
16939 if (data.devices_status == STATUS_QUIT) break;
16940
16941 if (data.devices_status == STATUS_BYPASS)
16942 {
16943 data.devices_status = STATUS_RUNNING;
16944 }
16945 }
16946
16947 // 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
16948
16949 if (attack_mode == ATTACK_MODE_STRAIGHT)
16950 {
16951 if (data.wordlist_mode == WL_MODE_FILE)
16952 {
16953 if (data.dictfile == NULL)
16954 {
16955 if (dictfiles != NULL)
16956 {
16957 data.dictfile = dictfiles[0];
16958
16959 hc_timer_set (&data.timer_running);
16960 }
16961 }
16962 }
16963 }
16964 // NOTE: combi is okay because it is already set beforehand
16965 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16966 {
16967 if (data.dictfile == NULL)
16968 {
16969 if (dictfiles != NULL)
16970 {
16971 hc_timer_set (&data.timer_running);
16972
16973 data.dictfile = dictfiles[0];
16974 }
16975 }
16976 }
16977 else if (attack_mode == ATTACK_MODE_BF)
16978 {
16979 if (data.mask == NULL)
16980 {
16981 hc_timer_set (&data.timer_running);
16982
16983 data.mask = masks[0];
16984 }
16985 }
16986
16987 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16988 {
16989 data.devices_status = STATUS_EXHAUSTED;
16990 }
16991
16992 // if cracked / aborted remove last induction dictionary
16993
16994 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16995 {
16996 struct stat induct_stat;
16997
16998 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16999 {
17000 unlink (induction_dictionaries[file_pos]);
17001 }
17002 }
17003
17004 // wait for non-interactive threads
17005
17006 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17007 {
17008 hc_thread_wait (1, &ni_threads[thread_idx]);
17009 }
17010
17011 local_free (ni_threads);
17012
17013 // wait for interactive threads
17014
17015 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17016 {
17017 hc_thread_wait (1, &i_thread);
17018 }
17019
17020 // we dont need restore file anymore
17021 if (data.restore_disable == 0)
17022 {
17023 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17024 {
17025 unlink (eff_restore_file);
17026 unlink (new_restore_file);
17027 }
17028 else
17029 {
17030 cycle_restore ();
17031 }
17032 }
17033
17034 // finally save left hashes
17035
17036 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17037 {
17038 save_hash ();
17039 }
17040
17041 /**
17042 * Clean up
17043 */
17044
17045 if (benchmark == 1)
17046 {
17047 status_benchmark ();
17048
17049 if (status_automat == 0)
17050 {
17051 log_info ("");
17052 }
17053 }
17054 else
17055 {
17056 if (quiet == 0) clear_prompt ();
17057
17058 if (quiet == 0) log_info ("");
17059
17060 if (status == 1)
17061 {
17062 status_display ();
17063 }
17064 else
17065 {
17066 if (quiet == 0) status_display ();
17067 }
17068
17069 if (quiet == 0) log_info ("");
17070 }
17071
17072 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17073 {
17074 hc_device_param_t *device_param = &data.devices_param[device_id];
17075
17076 if (device_param->skipped) continue;
17077
17078 local_free (device_param->result);
17079
17080 local_free (device_param->combs_buf);
17081
17082 local_free (device_param->hooks_buf);
17083
17084 local_free (device_param->device_name);
17085
17086 local_free (device_param->device_name_chksum);
17087
17088 local_free (device_param->device_version);
17089
17090 local_free (device_param->driver_version);
17091
17092 if (device_param->pws_buf) myfree (device_param->pws_buf);
17093 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17094 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17095 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17096 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17097 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17098 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17099 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17100 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17101 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17102 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17103 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17104 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17105 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17106 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17107 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17108 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17109 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17110 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17111 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17112 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17113 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17114 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17115 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17116 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17117 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17118 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17119 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17120 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17121
17122 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17123 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17124 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17125 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17126 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17127 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17128 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17129 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17130 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17131 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17132
17133 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17134 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17135 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17136
17137 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17138 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17139 }
17140
17141 // reset default fan speed
17142
17143 #ifdef HAVE_HWMON
17144 if (gpu_temp_disable == 0)
17145 {
17146 #ifdef HAVE_ADL
17147 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17148 {
17149 hc_thread_mutex_lock (mux_adl);
17150
17151 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17152 {
17153 hc_device_param_t *device_param = &data.devices_param[device_id];
17154
17155 if (device_param->skipped) continue;
17156
17157 if (data.hm_device[device_id].fan_supported == 1)
17158 {
17159 int fanspeed = temp_retain_fanspeed_value[device_id];
17160
17161 if (fanspeed == -1) continue;
17162
17163 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
17164
17165 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
17166 }
17167 }
17168
17169 hc_thread_mutex_unlock (mux_adl);
17170 }
17171 #endif // HAVE_ADL
17172 }
17173
17174 #ifdef HAVE_ADL
17175 // reset power tuning
17176
17177 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17178 {
17179 hc_thread_mutex_lock (mux_adl);
17180
17181 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17182 {
17183 hc_device_param_t *device_param = &data.devices_param[device_id];
17184
17185 if (device_param->skipped) continue;
17186
17187 if (data.hm_device[device_id].od_version == 6)
17188 {
17189 // check powertune capabilities first, if not available then skip device
17190
17191 int powertune_supported = 0;
17192
17193 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17194 {
17195 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17196
17197 return (-1);
17198 }
17199
17200 if (powertune_supported != 0)
17201 {
17202 // powercontrol settings
17203
17204 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)
17205 {
17206 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17207
17208 return (-1);
17209 }
17210
17211 // clocks
17212
17213 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17214
17215 performance_state->iNumberOfPerformanceLevels = 2;
17216
17217 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17218 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17219 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17220 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17221
17222 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)
17223 {
17224 log_info ("ERROR: Failed to restore ADL performance state");
17225
17226 return (-1);
17227 }
17228
17229 local_free (performance_state);
17230 }
17231 }
17232 }
17233
17234 hc_thread_mutex_unlock (mux_adl);
17235 }
17236 #endif // HAVE_ADL
17237
17238 if (gpu_temp_disable == 0)
17239 {
17240 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17241 if (data.hm_nv)
17242 {
17243 #if defined(LINUX) && defined(HAVE_NVML)
17244
17245 hm_NVML_nvmlShutdown (data.hm_nv);
17246
17247 nvml_close (data.hm_nv);
17248
17249 #elif defined(WIN) && (HAVE_NVAPI)
17250
17251 hm_NvAPI_Unload (data.hm_nv);
17252
17253 nvapi_close (data.hm_nv);
17254
17255 #endif
17256
17257 data.hm_nv = NULL;
17258 }
17259 #endif
17260
17261 #ifdef HAVE_ADL
17262 if (data.hm_amd)
17263 {
17264 hm_ADL_Main_Control_Destroy (data.hm_amd);
17265
17266 adl_close (data.hm_amd);
17267 data.hm_amd = NULL;
17268 }
17269 #endif
17270 }
17271 #endif // HAVE_HWMON
17272
17273 // free memory
17274
17275 local_free (masks);
17276
17277 local_free (dictstat_base);
17278
17279 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17280 {
17281 pot_t *pot_ptr = &pot[pot_pos];
17282
17283 hash_t *hash = &pot_ptr->hash;
17284
17285 local_free (hash->digest);
17286
17287 if (isSalted)
17288 {
17289 local_free (hash->salt);
17290 }
17291 }
17292
17293 local_free (pot);
17294
17295 local_free (all_kernel_rules_cnt);
17296 local_free (all_kernel_rules_buf);
17297
17298 local_free (wl_data->buf);
17299 local_free (wl_data);
17300
17301 local_free (bitmap_s1_a);
17302 local_free (bitmap_s1_b);
17303 local_free (bitmap_s1_c);
17304 local_free (bitmap_s1_d);
17305 local_free (bitmap_s2_a);
17306 local_free (bitmap_s2_b);
17307 local_free (bitmap_s2_c);
17308 local_free (bitmap_s2_d);
17309
17310 #ifdef HAVE_HWMON
17311 local_free (temp_retain_fanspeed_value);
17312 #ifdef HAVE_ADL
17313 local_free (od_clock_mem_status);
17314 local_free (od_power_control_status);
17315 #endif // ADL
17316 #endif
17317
17318 global_free (devices_param);
17319
17320 global_free (kernel_rules_buf);
17321
17322 global_free (root_css_buf);
17323 global_free (markov_css_buf);
17324
17325 global_free (digests_buf);
17326 global_free (digests_shown);
17327 global_free (digests_shown_tmp);
17328
17329 global_free (salts_buf);
17330 global_free (salts_shown);
17331
17332 global_free (esalts_buf);
17333
17334 global_free (words_progress_done);
17335 global_free (words_progress_rejected);
17336 global_free (words_progress_restored);
17337
17338 if (pot_fp) fclose (pot_fp);
17339
17340 if (data.devices_status == STATUS_QUIT) break;
17341 }
17342
17343 // destroy others mutex
17344
17345 hc_thread_mutex_delete (mux_dispatcher);
17346 hc_thread_mutex_delete (mux_counter);
17347 hc_thread_mutex_delete (mux_display);
17348 hc_thread_mutex_delete (mux_adl);
17349
17350 // free memory
17351
17352 local_free (eff_restore_file);
17353 local_free (new_restore_file);
17354
17355 local_free (rd);
17356
17357 // tuning db
17358
17359 tuning_db_destroy (tuning_db);
17360
17361 // loopback
17362
17363 local_free (loopback_file);
17364
17365 if (loopback == 1) unlink (loopback_file);
17366
17367 // induction directory
17368
17369 if (induction_dir == NULL)
17370 {
17371 if (attack_mode != ATTACK_MODE_BF)
17372 {
17373 if (rmdir (induction_directory) == -1)
17374 {
17375 if (errno == ENOENT)
17376 {
17377 // good, we can ignore
17378 }
17379 else if (errno == ENOTEMPTY)
17380 {
17381 // good, we can ignore
17382 }
17383 else
17384 {
17385 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17386
17387 return (-1);
17388 }
17389 }
17390
17391 local_free (induction_directory);
17392 }
17393 }
17394
17395 // outfile-check directory
17396
17397 if (outfile_check_dir == NULL)
17398 {
17399 if (rmdir (outfile_check_directory) == -1)
17400 {
17401 if (errno == ENOENT)
17402 {
17403 // good, we can ignore
17404 }
17405 else if (errno == ENOTEMPTY)
17406 {
17407 // good, we can ignore
17408 }
17409 else
17410 {
17411 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17412
17413 return (-1);
17414 }
17415 }
17416
17417 local_free (outfile_check_directory);
17418 }
17419
17420 time_t proc_stop;
17421
17422 time (&proc_stop);
17423
17424 logfile_top_uint (proc_start);
17425 logfile_top_uint (proc_stop);
17426
17427 logfile_top_msg ("STOP");
17428
17429 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17430 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17431
17432 if (data.ocl) ocl_close (data.ocl);
17433
17434 if (data.devices_status == STATUS_ABORTED) return 2;
17435 if (data.devices_status == STATUS_QUIT) return 2;
17436 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17437 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17438 if (data.devices_status == STATUS_CRACKED) return 0;
17439
17440 return -1;
17441 }
Hashcat additions to support pwdhash