projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Evil Bug: Because of not-zeroing a buffer it's possible a hash was cracked but not...
[hashcat.git] / src / oclHashcat.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 = "oclHashcat";
19 const uint VERSION_BIN = 210;
20 const uint RESTORE_MIN = 210;
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 BENCHMARK_REPEATS 2
37 #define RESTORE 0
38 #define RESTORE_TIMER 60
39 #define RESTORE_DISABLE 0
40 #define STATUS 0
41 #define STATUS_TIMER 10
42 #define STATUS_AUTOMAT 0
43 #define LOOPBACK 0
44 #define WEAK_HASH_THRESHOLD 100
45 #define SHOW 0
46 #define LEFT 0
47 #define USERNAME 0
48 #define REMOVE 0
49 #define REMOVE_TIMER 60
50 #define SKIP 0
51 #define LIMIT 0
52 #define KEYSPACE 0
53 #define POTFILE_DISABLE 0
54 #define DEBUG_MODE 0
55 #define RP_GEN 0
56 #define RP_GEN_FUNC_MIN 1
57 #define RP_GEN_FUNC_MAX 4
58 #define RP_GEN_SEED 0
59 #define RULE_BUF_L ":"
60 #define RULE_BUF_R ":"
61 #define FORCE 0
62 #define RUNTIME 0
63 #define HEX_CHARSET 0
64 #define HEX_SALT 0
65 #define HEX_WORDLIST 0
66 #define OUTFILE_FORMAT 3
67 #define OUTFILE_AUTOHEX 1
68 #define OUTFILE_CHECK_TIMER 5
69 #define ATTACK_MODE 0
70 #define HASH_MODE 0
71 #define SEGMENT_SIZE 32
72 #define INCREMENT 0
73 #define INCREMENT_MIN 1
74 #define INCREMENT_MAX PW_MAX
75 #define SEPARATOR ':'
76 #define BITMAP_MIN 16
77 #define BITMAP_MAX 24
78 #define GPU_TEMP_DISABLE 0
79 #define GPU_TEMP_ABORT 90
80 #define GPU_TEMP_RETAIN 80
81 #define WORKLOAD_PROFILE 2
82 #define KERNEL_ACCEL 0
83 #define KERNEL_LOOPS 0
84 #define KERNEL_RULES 1024
85 #define KERNEL_COMBS 1024
86 #define KERNEL_BFS 1024
87 #define KERNEL_THREADS 64
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 HLFMT_HASHCAT 0
101 #define HLFMT_PWDUMP 1
102 #define HLFMT_PASSWD 2
103 #define HLFMT_SHADOW 3
104 #define HLFMT_DCC 4
105 #define HLFMT_DCC2 5
106 #define HLFMT_NETNTLM1 7
107 #define HLFMT_NETNTLM2 8
108 #define HLFMT_NSLDAP 9
109 #define HLFMT_NSLDAPS 10
110 #define HLFMTS_CNT 11
111
112 #define ATTACK_MODE_STRAIGHT 0
113 #define ATTACK_MODE_COMBI 1
114 #define ATTACK_MODE_TOGGLE 2
115 #define ATTACK_MODE_BF 3
116 #define ATTACK_MODE_PERM 4
117 #define ATTACK_MODE_TABLE 5
118 #define ATTACK_MODE_HYBRID1 6
119 #define ATTACK_MODE_HYBRID2 7
120 #define ATTACK_MODE_NONE 100
121
122 #define ATTACK_KERN_STRAIGHT 0
123 #define ATTACK_KERN_COMBI 1
124 #define ATTACK_KERN_BF 3
125 #define ATTACK_KERN_NONE 100
126
127 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
128 #define ATTACK_EXEC_INSIDE_KERNEL 11
129
130 #define COMBINATOR_MODE_BASE_LEFT 10001
131 #define COMBINATOR_MODE_BASE_RIGHT 10002
132
133 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
134 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
135
136 #define MAX_CUT_TRIES 4
137
138 #define MAX_DICTSTAT 10000
139
140 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 131
141
142 #define global_free(attr) \
143 { \
144 myfree ((void *) data.attr); \
145 \
146 data.attr = NULL; \
147 }
148
149 #define local_free(attr) \
150 { \
151 myfree ((void *) attr); \
152 \
153 attr = NULL; \
154 }
155
156 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
157 {
158 900,
159 0,
160 5100,
161 100,
162 1400,
163 10800,
164 1700,
165 5000,
166 10100,
167 6000,
168 6100,
169 6900,
170 11700,
171 11800,
172 400,
173 8900,
174 11900,
175 12000,
176 10900,
177 12100,
178 23,
179 2500,
180 5300,
181 5400,
182 5500,
183 5600,
184 7300,
185 7500,
186 13100,
187 8300,
188 11100,
189 11200,
190 11400,
191 121,
192 2611,
193 2711,
194 2811,
195 8400,
196 11,
197 2612,
198 7900,
199 21,
200 11000,
201 124,
202 10000,
203 3711,
204 7600,
205 12,
206 131,
207 132,
208 1731,
209 200,
210 300,
211 3100,
212 112,
213 12300,
214 8000,
215 141,
216 1441,
217 1600,
218 12600,
219 1421,
220 101,
221 111,
222 1711,
223 3000,
224 1000,
225 1100,
226 2100,
227 12800,
228 1500,
229 12400,
230 500,
231 3200,
232 7400,
233 1800,
234 122,
235 1722,
236 7100,
237 6300,
238 6700,
239 6400,
240 6500,
241 2400,
242 2410,
243 5700,
244 9200,
245 9300,
246 22,
247 501,
248 5800,
249 8100,
250 8500,
251 7200,
252 9900,
253 7700,
254 7800,
255 10300,
256 8600,
257 8700,
258 9100,
259 133,
260 11600,
261 12500,
262 13000,
263 6211,
264 6221,
265 6231,
266 6241,
267 8800,
268 12900,
269 12200,
270 9700,
271 9710,
272 9800,
273 9810,
274 9400,
275 9500,
276 9600,
277 10400,
278 10410,
279 10500,
280 10600,
281 10700,
282 9000,
283 5200,
284 6800,
285 6600,
286 8200,
287 11300,
288 12700
289 };
290
291 /**
292 * types
293 */
294
295 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
296
297 /**
298 * globals
299 */
300
301 static unsigned int full01 = 0x01010101;
302 static unsigned int full80 = 0x80808080;
303
304 int SUPPRESS_OUTPUT = 0;
305
306 hc_thread_mutex_t mux_adl;
307 hc_thread_mutex_t mux_counter;
308 hc_thread_mutex_t mux_dispatcher;
309 hc_thread_mutex_t mux_display;
310
311 hc_global_data_t data;
312
313 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
314
315 const char *USAGE_MINI[] =
316 {
317 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
318 "",
319 "Try --help for more help.",
320 NULL
321 };
322
323 const char *USAGE_BIG[] =
324 {
325 "%s, advanced password recovery",
326 "",
327 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
328 "",
329 "=======",
330 "Options",
331 "=======",
332 "",
333 "* General:",
334 "",
335 " -m, --hash-type=NUM Hash-type, see references below",
336 " -a, --attack-mode=NUM Attack-mode, see references below",
337 " -V, --version Print version",
338 " -h, --help Print help",
339 " --quiet Suppress output",
340 "",
341 "* Misc:",
342 "",
343 " --hex-charset Assume charset is given in hex",
344 " --hex-salt Assume salt is given in hex",
345 " --hex-wordlist Assume words in wordlist is given in hex",
346 " --force Ignore warnings",
347 " --status Enable automatic update of the status-screen",
348 " --status-timer=NUM Seconds between status-screen update",
349 " --status-automat Display the status view in a machine readable format",
350 " --loopback Add new plains to induct directory",
351 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
352 "",
353 "* Markov:",
354 "",
355 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
356 " --markov-disable Disables markov-chains, emulates classic brute-force",
357 " --markov-classic Enables classic markov-chains, no per-position enhancement",
358 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
359 "",
360 "* Session:",
361 "",
362 " --runtime=NUM Abort session after NUM seconds of runtime",
363 " --session=STR Define specific session name",
364 " --restore Restore session from --session",
365 " --restore-disable Do not write restore file",
366 "",
367 "* Files:",
368 "",
369 " -o, --outfile=FILE Define outfile for recovered hash",
370 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
371 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
372 " --outfile-check-timer=NUM Seconds between outfile checks",
373 " -p, --separator=CHAR Separator char for hashlists and outfile",
374 " --show Show cracked passwords only",
375 " --left Show un-cracked passwords only",
376 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
377 " --remove Enable remove of hash once it is cracked",
378 " --remove-timer=NUM Update input hash file each NUM seconds",
379 " --potfile-disable Do not write potfile",
380 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
381 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
382 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
383 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
384 " --logfile-disable Disable the logfile",
385 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
386 "",
387 "* Resources:",
388 "",
389 " -b, --benchmark Run benchmark",
390 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
391 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
392 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
393 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
394 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
395 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
396 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
397 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
398 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
399 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
400 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
401 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
402 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
403 #ifdef HAVE_HWMON
404 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
405 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
406 #ifdef HAVE_ADL
407 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
408 #endif
409 #endif
410 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
411 "",
412 "* Distributed:",
413 "",
414 " -s, --skip=NUM Skip number of words",
415 " -l, --limit=NUM Limit number of words",
416 " --keyspace Show keyspace base:mod values and quit",
417 "",
418 "* Rules:",
419 "",
420 " -j, --rule-left=RULE Single rule applied to each word from left dict",
421 " -k, --rule-right=RULE Single rule applied to each word from right dict",
422 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
423 " -g, --generate-rules=NUM Generate NUM random rules",
424 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
425 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
426 " --generate-rules-seed=NUM Force RNG seed to NUM",
427 "",
428 "* Custom charsets:",
429 "",
430 " -1, --custom-charset1=CS User-defined charsets",
431 " -2, --custom-charset2=CS Example:",
432 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
433 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
434 "",
435 "* Increment:",
436 "",
437 " -i, --increment Enable increment mode",
438 " --increment-min=NUM Start incrementing at NUM",
439 " --increment-max=NUM Stop incrementing at NUM",
440 "",
441 "==========",
442 "References",
443 "==========",
444 "",
445 "* Workload Profile:",
446 "",
447 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
448 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
449 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
450 "",
451 "* OpenCL device-types:",
452 "",
453 " 1 = CPU devices",
454 " 2 = GPU devices",
455 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
456 "",
457 "* Outfile Formats:",
458 "",
459 " 1 = hash[:salt]",
460 " 2 = plain",
461 " 3 = hash[:salt]:plain",
462 " 4 = hex_plain",
463 " 5 = hash[:salt]:hex_plain",
464 " 6 = plain:hex_plain",
465 " 7 = hash[:salt]:plain:hex_plain",
466 " 8 = crackpos",
467 " 9 = hash[:salt]:crackpos",
468 " 10 = plain:crackpos",
469 " 11 = hash[:salt]:plain:crackpos",
470 " 12 = hex_plain:crackpos",
471 " 13 = hash[:salt]:hex_plain:crackpos",
472 " 14 = plain:hex_plain:crackpos",
473 " 15 = hash[:salt]:plain:hex_plain:crackpos",
474 "",
475 "* Debug mode output formats (for hybrid mode only, by using rules):",
476 "",
477 " 1 = save finding rule",
478 " 2 = save original word",
479 " 3 = save original word and finding rule",
480 " 4 = save original word, finding rule and modified plain",
481 "",
482 "* Built-in charsets:",
483 "",
484 " ?l = abcdefghijklmnopqrstuvwxyz",
485 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
486 " ?d = 0123456789",
487 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
488 " ?a = ?l?u?d?s",
489 " ?b = 0x00 - 0xff",
490 "",
491 "* Attack modes:",
492 "",
493 " 0 = Straight",
494 " 1 = Combination",
495 " 3 = Brute-force",
496 " 6 = Hybrid dict + mask",
497 " 7 = Hybrid mask + dict",
498 "",
499 "* Hash types:",
500 "",
501 "[[ Roll-your-own: Raw Hashes ]]",
502 "",
503 " 900 = MD4",
504 " 0 = MD5",
505 " 5100 = Half MD5",
506 " 100 = SHA1",
507 " 10800 = SHA-384",
508 " 1400 = SHA-256",
509 " 1700 = SHA-512",
510 " 5000 = SHA-3(Keccak)",
511 " 10100 = SipHash",
512 " 6000 = RipeMD160",
513 " 6100 = Whirlpool",
514 " 6900 = GOST R 34.11-94",
515 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
516 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
517 "",
518 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
519 "",
520 " 10 = md5($pass.$salt)",
521 " 20 = md5($salt.$pass)",
522 " 30 = md5(unicode($pass).$salt)",
523 " 40 = md5($salt.unicode($pass))",
524 " 3800 = md5($salt.$pass.$salt)",
525 " 3710 = md5($salt.md5($pass))",
526 " 2600 = md5(md5($pass)",
527 " 4300 = md5(strtoupper(md5($pass)))",
528 " 4400 = md5(sha1($pass))",
529 " 110 = sha1($pass.$salt)",
530 " 120 = sha1($salt.$pass)",
531 " 130 = sha1(unicode($pass).$salt)",
532 " 140 = sha1($salt.unicode($pass))",
533 " 4500 = sha1(sha1($pass)",
534 " 4700 = sha1(md5($pass))",
535 " 4900 = sha1($salt.$pass.$salt)",
536 " 1410 = sha256($pass.$salt)",
537 " 1420 = sha256($salt.$pass)",
538 " 1430 = sha256(unicode($pass).$salt)",
539 " 1440 = sha256($salt.unicode($pass))",
540 " 1710 = sha512($pass.$salt)",
541 " 1720 = sha512($salt.$pass)",
542 " 1730 = sha512(unicode($pass).$salt)",
543 " 1740 = sha512($salt.unicode($pass))",
544 "",
545 "[[ Roll-your-own: Authenticated Hashes ]]",
546 "",
547 " 50 = HMAC-MD5 (key = $pass)",
548 " 60 = HMAC-MD5 (key = $salt)",
549 " 150 = HMAC-SHA1 (key = $pass)",
550 " 160 = HMAC-SHA1 (key = $salt)",
551 " 1450 = HMAC-SHA256 (key = $pass)",
552 " 1460 = HMAC-SHA256 (key = $salt)",
553 " 1750 = HMAC-SHA512 (key = $pass)",
554 " 1760 = HMAC-SHA512 (key = $salt)",
555 "",
556 "[[ Generic KDF ]]",
557 "",
558 " 400 = phpass",
559 " 8900 = scrypt",
560 " 11900 = PBKDF2-HMAC-MD5",
561 " 12000 = PBKDF2-HMAC-SHA1",
562 " 10900 = PBKDF2-HMAC-SHA256",
563 " 12100 = PBKDF2-HMAC-SHA512",
564 "",
565 "[[ Network protocols, Challenge-Response ]]",
566 "",
567 " 23 = Skype",
568 " 2500 = WPA/WPA2",
569 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
570 " 5300 = IKE-PSK MD5",
571 " 5400 = IKE-PSK SHA1",
572 " 5500 = NetNTLMv1",
573 " 5500 = NetNTLMv1 + ESS",
574 " 5600 = NetNTLMv2",
575 " 7300 = IPMI2 RAKP HMAC-SHA1",
576 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
577 " 8300 = DNSSEC (NSEC3)",
578 " 10200 = Cram MD5",
579 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
580 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
581 " 11400 = SIP digest authentication (MD5)",
582 " 13100 = Kerberos 5 TGS-REP etype 23",
583 "",
584 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
585 "",
586 " 121 = SMF (Simple Machines Forum)",
587 " 400 = phpBB3",
588 " 2611 = vBulletin < v3.8.5",
589 " 2711 = vBulletin > v3.8.5",
590 " 2811 = MyBB",
591 " 2811 = IPB (Invison Power Board)",
592 " 8400 = WBB3 (Woltlab Burning Board)",
593 " 11 = Joomla < 2.5.18",
594 " 400 = Joomla > 2.5.18",
595 " 400 = Wordpress",
596 " 2612 = PHPS",
597 " 7900 = Drupal7",
598 " 21 = osCommerce",
599 " 21 = xt:Commerce",
600 " 11000 = PrestaShop",
601 " 124 = Django (SHA-1)",
602 " 10000 = Django (PBKDF2-SHA256)",
603 " 3711 = Mediawiki B type",
604 " 7600 = Redmine",
605 "",
606 "[[ Database Server ]]",
607 "",
608 " 12 = PostgreSQL",
609 " 131 = MSSQL(2000)",
610 " 132 = MSSQL(2005)",
611 " 1731 = MSSQL(2012)",
612 " 1731 = MSSQL(2014)",
613 " 200 = MySQL323",
614 " 300 = MySQL4.1/MySQL5",
615 " 3100 = Oracle H: Type (Oracle 7+)",
616 " 112 = Oracle S: Type (Oracle 11+)",
617 " 12300 = Oracle T: Type (Oracle 12+)",
618 " 8000 = Sybase ASE",
619 "",
620 "[[ HTTP, SMTP, LDAP Server ]]",
621 "",
622 " 141 = EPiServer 6.x < v4",
623 " 1441 = EPiServer 6.x > v4",
624 " 1600 = Apache $apr1$",
625 " 12600 = ColdFusion 10+",
626 " 1421 = hMailServer",
627 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
628 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
629 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
630 "",
631 "[[ Checksums ]]",
632 "",
633 " 11500 = CRC32",
634 "",
635 "[[ Operating-Systems ]]",
636 "",
637 " 3000 = LM",
638 " 1000 = NTLM",
639 " 1100 = Domain Cached Credentials (DCC), MS Cache",
640 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
641 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
642 " 1500 = descrypt, DES(Unix), Traditional DES",
643 " 12400 = BSDiCrypt, Extended DES",
644 " 500 = md5crypt $1$, MD5(Unix)",
645 " 3200 = bcrypt $2*$, Blowfish(Unix)",
646 " 7400 = sha256crypt $5$, SHA256(Unix)",
647 " 1800 = sha512crypt $6$, SHA512(Unix)",
648 " 122 = OSX v10.4",
649 " 122 = OSX v10.5",
650 " 122 = OSX v10.6",
651 " 1722 = OSX v10.7",
652 " 7100 = OSX v10.8",
653 " 7100 = OSX v10.9",
654 " 7100 = OSX v10.10",
655 " 6300 = AIX {smd5}",
656 " 6700 = AIX {ssha1}",
657 " 6400 = AIX {ssha256}",
658 " 6500 = AIX {ssha512}",
659 " 2400 = Cisco-PIX",
660 " 2410 = Cisco-ASA",
661 " 500 = Cisco-IOS $1$",
662 " 5700 = Cisco-IOS $4$",
663 " 9200 = Cisco-IOS $8$",
664 " 9300 = Cisco-IOS $9$",
665 " 22 = Juniper Netscreen/SSG (ScreenOS)",
666 " 501 = Juniper IVE",
667 " 5800 = Android PIN",
668 " 8100 = Citrix Netscaler",
669 " 8500 = RACF",
670 " 7200 = GRUB 2",
671 " 9900 = Radmin2",
672 "",
673 "[[ Enterprise Application Software (EAS) ]]",
674 "",
675 " 7700 = SAP CODVN B (BCODE)",
676 " 7800 = SAP CODVN F/G (PASSCODE)",
677 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
678 " 8600 = Lotus Notes/Domino 5",
679 " 8700 = Lotus Notes/Domino 6",
680 " 9100 = Lotus Notes/Domino 8",
681 " 133 = PeopleSoft",
682 "",
683 "[[ Archives ]]",
684 "",
685 " 11600 = 7-Zip",
686 " 12500 = RAR3-hp",
687 " 13000 = RAR5",
688 "",
689 "[[ Full-Disk encryptions (FDE) ]]",
690 "",
691 " 62XY = TrueCrypt 5.0+",
692 " X = 1 = PBKDF2-HMAC-RipeMD160",
693 " X = 2 = PBKDF2-HMAC-SHA512",
694 " X = 3 = PBKDF2-HMAC-Whirlpool",
695 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
696 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
697 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
698 " Y = 3 = XTS 1536 bit (Ciphers: All)",
699 " 8800 = Android FDE < v4.3",
700 " 12900 = Android FDE (Samsung DEK)",
701 " 12200 = eCryptfs",
702 "",
703 "[[ Documents ]]",
704 "",
705 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
706 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
707 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
708 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
709 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
710 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
711 " 9400 = MS Office 2007",
712 " 9500 = MS Office 2010",
713 " 9600 = MS Office 2013",
714 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
715 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
716 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
717 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
718 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
719 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
720 "",
721 "[[ Password Managers ]]",
722 "",
723 " 9000 = Password Safe v2",
724 " 5200 = Password Safe v3",
725 " 6800 = Lastpass",
726 " 6600 = 1Password, agilekeychain",
727 " 8200 = 1Password, cloudkeychain",
728 " 11300 = Bitcoin/Litecoin wallet.dat",
729 " 12700 = Blockchain, My Wallet",
730 "",
731 NULL
732 };
733
734 /**
735 * oclHashcat specific functions
736 */
737
738 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
739 {
740 int exec_pos = (int) device_param->exec_pos - last_num_entries;
741
742 if (exec_pos < 0) exec_pos += EXEC_CACHE;
743
744 double exec_ms_sum = 0;
745
746 int exec_ms_cnt = 0;
747
748 for (int i = 0; i < last_num_entries; i++)
749 {
750 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
751
752 if (exec_ms)
753 {
754 exec_ms_sum += exec_ms;
755
756 exec_ms_cnt++;
757 }
758 }
759
760 if (exec_ms_cnt == 0) return 0;
761
762 return exec_ms_sum / exec_ms_cnt;
763 }
764
765 void status_display_automat ()
766 {
767 FILE *out = stdout;
768
769 fprintf (out, "STATUS\t%u\t", data.devices_status);
770
771 /**
772 * speed new
773 */
774
775 fprintf (out, "SPEED\t");
776
777 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
778 {
779 hc_device_param_t *device_param = &data.devices_param[device_id];
780
781 if (device_param->skipped) continue;
782
783 u64 speed_cnt = 0;
784 float speed_ms = 0;
785
786 for (int i = 0; i < SPEED_CACHE; i++)
787 {
788 float rec_ms;
789
790 hc_timer_get (device_param->speed_rec[i], rec_ms);
791
792 if (rec_ms > SPEED_MAXAGE) continue;
793
794 speed_cnt += device_param->speed_cnt[i];
795 speed_ms += device_param->speed_ms[i];
796 }
797
798 speed_cnt /= SPEED_CACHE;
799 speed_ms /= SPEED_CACHE;
800
801 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
802 }
803
804 /**
805 * exec time
806 */
807
808 fprintf (out, "EXEC_RUNTIME\t");
809
810 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
811 {
812 hc_device_param_t *device_param = &data.devices_param[device_id];
813
814 if (device_param->skipped) continue;
815
816 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
817
818 fprintf (out, "%f\t", exec_ms_avg);
819 }
820
821 /**
822 * words_cur
823 */
824
825 u64 words_cur = get_lowest_words_done ();
826
827 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
828
829 /**
830 * counter
831 */
832
833 uint salts_left = data.salts_cnt - data.salts_done;
834
835 if (salts_left == 0) salts_left = 1;
836
837 u64 progress_total = data.words_cnt * salts_left;
838
839 u64 all_done = 0;
840 u64 all_rejected = 0;
841 u64 all_restored = 0;
842
843 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
844 {
845 if (salts_left > 1)
846 {
847 // otherwise the final cracked status shows 0/XXX progress
848
849 if (data.salts_shown[salt_pos] == 1) continue;
850 }
851
852 all_done += data.words_progress_done[salt_pos];
853 all_rejected += data.words_progress_rejected[salt_pos];
854 all_restored += data.words_progress_restored[salt_pos];
855 }
856
857 u64 progress_cur = all_restored + all_done + all_rejected;
858 u64 progress_end = progress_total;
859
860 u64 progress_skip = 0;
861
862 if (data.skip)
863 {
864 progress_skip = MIN (data.skip, data.words_base) * salts_left;
865
866 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
867 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
868 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
869 }
870
871 if (data.limit)
872 {
873 progress_end = MIN (data.limit, data.words_base) * salts_left;
874
875 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
876 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
877 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
878 }
879
880 u64 progress_cur_relative_skip = progress_cur - progress_skip;
881 u64 progress_end_relative_skip = progress_end - progress_skip;
882
883 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
884
885 /**
886 * cracks
887 */
888
889 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
890 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
891
892 /**
893 * temperature
894 */
895
896 #ifdef HAVE_HWMON
897 if (data.gpu_temp_disable == 0)
898 {
899 fprintf (out, "TEMP\t");
900
901 hc_thread_mutex_lock (mux_adl);
902
903 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
904 {
905 hc_device_param_t *device_param = &data.devices_param[device_id];
906
907 if (device_param->skipped) continue;
908
909 int temp = hm_get_temperature_with_device_id (device_id);
910
911 fprintf (out, "%d\t", temp);
912 }
913
914 hc_thread_mutex_unlock (mux_adl);
915 }
916 #endif // HAVE_HWMON
917
918 /**
919 * flush
920 */
921
922 #ifdef _WIN
923 fputc ('\r', out);
924 fputc ('\n', out);
925 #endif
926
927 #ifdef _POSIX
928 fputc ('\n', out);
929 #endif
930
931 fflush (out);
932 }
933
934 void status_display ()
935 {
936 if (data.devices_status == STATUS_INIT) return;
937 if (data.devices_status == STATUS_STARTING) return;
938 if (data.devices_status == STATUS_BYPASS) return;
939
940 if (data.status_automat == 1)
941 {
942 status_display_automat ();
943
944 return;
945 }
946
947 char tmp_buf[1000] = { 0 };
948
949 uint tmp_len = 0;
950
951 log_info ("Session.Name...: %s", data.session);
952
953 char *status_type = strstatus (data.devices_status);
954
955 uint hash_mode = data.hash_mode;
956
957 char *hash_type = strhashtype (hash_mode); // not a bug
958
959 log_info ("Status.........: %s", status_type);
960
961 /**
962 * show rules
963 */
964
965 if (data.rp_files_cnt)
966 {
967 uint i;
968
969 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
970 {
971 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
972 }
973
974 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
975
976 log_info ("Rules.Type.....: %s", tmp_buf);
977
978 tmp_len = 0;
979 }
980
981 if (data.rp_gen)
982 {
983 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
984
985 if (data.rp_gen_seed)
986 {
987 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
988 }
989 }
990
991 /**
992 * show input
993 */
994
995 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
996 {
997 if (data.wordlist_mode == WL_MODE_FILE)
998 {
999 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1000 }
1001 else if (data.wordlist_mode == WL_MODE_STDIN)
1002 {
1003 log_info ("Input.Mode.....: Pipe");
1004 }
1005 }
1006 else if (data.attack_mode == ATTACK_MODE_COMBI)
1007 {
1008 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1009 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1010 }
1011 else if (data.attack_mode == ATTACK_MODE_BF)
1012 {
1013 char *mask = data.mask;
1014
1015 if (mask != NULL)
1016 {
1017 uint mask_len = data.css_cnt;
1018
1019 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1020
1021 if (mask_len > 0)
1022 {
1023 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1024 {
1025 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1026 {
1027 mask_len -= data.salts_buf[0].salt_len;
1028 }
1029 }
1030
1031 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1032
1033 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1034 }
1035
1036 if (data.maskcnt > 1)
1037 {
1038 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1039
1040 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1041 }
1042
1043 log_info ("Input.Mode.....: %s", tmp_buf);
1044 }
1045
1046 tmp_len = 0;
1047 }
1048 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1049 {
1050 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1051 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1052 }
1053 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1054 {
1055 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1056 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1057 }
1058
1059 if (data.digests_cnt == 1)
1060 {
1061 if (data.hash_mode == 2500)
1062 {
1063 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1064
1065 uint pke[25] = { 0 };
1066
1067 char *pke_ptr = (char *) pke;
1068
1069 for (uint i = 0; i < 25; i++)
1070 {
1071 pke[i] = byte_swap_32 (wpa->pke[i]);
1072 }
1073
1074 char mac1[6] = { 0 };
1075 char mac2[6] = { 0 };
1076
1077 memcpy (mac1, pke_ptr + 23, 6);
1078 memcpy (mac2, pke_ptr + 29, 6);
1079
1080 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1081 (char *) data.salts_buf[0].salt_buf,
1082 mac1[0] & 0xff,
1083 mac1[1] & 0xff,
1084 mac1[2] & 0xff,
1085 mac1[3] & 0xff,
1086 mac1[4] & 0xff,
1087 mac1[5] & 0xff,
1088 mac2[0] & 0xff,
1089 mac2[1] & 0xff,
1090 mac2[2] & 0xff,
1091 mac2[3] & 0xff,
1092 mac2[4] & 0xff,
1093 mac2[5] & 0xff);
1094 }
1095 else if (data.hash_mode == 5200)
1096 {
1097 log_info ("Hash.Target....: File (%s)", data.hashfile);
1098 }
1099 else if (data.hash_mode == 9000)
1100 {
1101 log_info ("Hash.Target....: File (%s)", data.hashfile);
1102 }
1103 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1104 {
1105 log_info ("Hash.Target....: File (%s)", data.hashfile);
1106 }
1107 else
1108 {
1109 char out_buf[4096] = { 0 };
1110
1111 ascii_digest (out_buf, 0, 0);
1112
1113 // limit length
1114 if (strlen (out_buf) > 40)
1115 {
1116 out_buf[41] = '.';
1117 out_buf[42] = '.';
1118 out_buf[43] = '.';
1119 out_buf[44] = 0;
1120 }
1121
1122 log_info ("Hash.Target....: %s", out_buf);
1123 }
1124 }
1125 else
1126 {
1127 if (data.hash_mode == 3000)
1128 {
1129 char out_buf1[4096] = { 0 };
1130 char out_buf2[4096] = { 0 };
1131
1132 ascii_digest (out_buf1, 0, 0);
1133 ascii_digest (out_buf2, 0, 1);
1134
1135 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1136 }
1137 else
1138 {
1139 log_info ("Hash.Target....: File (%s)", data.hashfile);
1140 }
1141 }
1142
1143 log_info ("Hash.Type......: %s", hash_type);
1144
1145 /**
1146 * speed new
1147 */
1148
1149 u64 speed_cnt[DEVICES_MAX] = { 0 };
1150 float speed_ms[DEVICES_MAX] = { 0 };
1151
1152 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1153 {
1154 hc_device_param_t *device_param = &data.devices_param[device_id];
1155
1156 if (device_param->skipped) continue;
1157
1158 // we need to clear values (set to 0) because in case the device does
1159 // not get new candidates it idles around but speed display would
1160 // show it as working.
1161 // if we instantly set it to 0 after reading it happens that the
1162 // speed can be shown as zero if the users refreshes too fast.
1163 // therefore, we add a timestamp when a stat was recorded and if its
1164 // too old we will not use it
1165
1166 speed_cnt[device_id] = 0;
1167 speed_ms[device_id] = 0;
1168
1169 for (int i = 0; i < SPEED_CACHE; i++)
1170 {
1171 float rec_ms;
1172
1173 hc_timer_get (device_param->speed_rec[i], rec_ms);
1174
1175 if (rec_ms > SPEED_MAXAGE) continue;
1176
1177 speed_cnt[device_id] += device_param->speed_cnt[i];
1178 speed_ms[device_id] += device_param->speed_ms[i];
1179 }
1180
1181 speed_cnt[device_id] /= SPEED_CACHE;
1182 speed_ms[device_id] /= SPEED_CACHE;
1183 }
1184
1185 float hashes_all_ms = 0;
1186
1187 float hashes_dev_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 hashes_dev_ms[device_id] = 0;
1196
1197 if (speed_ms[device_id])
1198 {
1199 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1200
1201 hashes_all_ms += hashes_dev_ms[device_id];
1202 }
1203 }
1204
1205 /**
1206 * exec time
1207 */
1208
1209 double exec_all_ms[DEVICES_MAX] = { 0 };
1210
1211 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1212 {
1213 hc_device_param_t *device_param = &data.devices_param[device_id];
1214
1215 if (device_param->skipped) continue;
1216
1217 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1218
1219 exec_all_ms[device_id] = exec_ms_avg;
1220 }
1221
1222 /**
1223 * timers
1224 */
1225
1226 float ms_running = 0;
1227
1228 hc_timer_get (data.timer_running, ms_running);
1229
1230 float ms_paused = data.ms_paused;
1231
1232 if (data.devices_status == STATUS_PAUSED)
1233 {
1234 float ms_paused_tmp = 0;
1235
1236 hc_timer_get (data.timer_paused, ms_paused_tmp);
1237
1238 ms_paused += ms_paused_tmp;
1239 }
1240
1241 #ifdef WIN
1242
1243 __time64_t sec_run = ms_running / 1000;
1244
1245 #else
1246
1247 time_t sec_run = ms_running / 1000;
1248
1249 #endif
1250
1251 if (sec_run)
1252 {
1253 char display_run[32] = { 0 };
1254
1255 struct tm tm_run;
1256
1257 struct tm *tmp = NULL;
1258
1259 #ifdef WIN
1260
1261 tmp = _gmtime64 (&sec_run);
1262
1263 #else
1264
1265 tmp = gmtime (&sec_run);
1266
1267 #endif
1268
1269 if (tmp != NULL)
1270 {
1271 memset (&tm_run, 0, sizeof (tm_run));
1272
1273 memcpy (&tm_run, tmp, sizeof (tm_run));
1274
1275 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1276
1277 char *start = ctime (&data.proc_start);
1278
1279 size_t start_len = strlen (start);
1280
1281 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1282 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1283
1284 log_info ("Time.Started...: %s (%s)", start, display_run);
1285 }
1286 }
1287 else
1288 {
1289 log_info ("Time.Started...: 0 secs");
1290 }
1291
1292 /**
1293 * counters
1294 */
1295
1296 uint salts_left = data.salts_cnt - data.salts_done;
1297
1298 if (salts_left == 0) salts_left = 1;
1299
1300 u64 progress_total = data.words_cnt * salts_left;
1301
1302 u64 all_done = 0;
1303 u64 all_rejected = 0;
1304 u64 all_restored = 0;
1305
1306 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1307 {
1308 if (salts_left > 1)
1309 {
1310 // otherwise the final cracked status shows 0/XXX progress
1311
1312 if (data.salts_shown[salt_pos] == 1) continue;
1313 }
1314
1315 all_done += data.words_progress_done[salt_pos];
1316 all_rejected += data.words_progress_rejected[salt_pos];
1317 all_restored += data.words_progress_restored[salt_pos];
1318 }
1319
1320 u64 progress_cur = all_restored + all_done + all_rejected;
1321 u64 progress_end = progress_total;
1322
1323 u64 progress_skip = 0;
1324
1325 if (data.skip)
1326 {
1327 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1328
1329 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1330 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1331 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1332 }
1333
1334 if (data.limit)
1335 {
1336 progress_end = MIN (data.limit, data.words_base) * salts_left;
1337
1338 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1339 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1340 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1341 }
1342
1343 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1344 u64 progress_end_relative_skip = progress_end - progress_skip;
1345
1346 float speed_ms_real = ms_running - ms_paused;
1347 u64 speed_plains_real = all_done;
1348
1349 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1350 {
1351 if (data.devices_status != STATUS_CRACKED)
1352 {
1353 u64 words_per_ms = 0;
1354
1355 if (speed_plains_real && speed_ms_real)
1356 {
1357 words_per_ms = speed_plains_real / speed_ms_real;
1358 }
1359
1360 #ifdef WIN
1361 __time64_t sec_etc = 0;
1362 #else
1363 time_t sec_etc = 0;
1364 #endif
1365
1366 if (words_per_ms)
1367 {
1368 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1369
1370 u64 ms_left = progress_left_relative_skip / words_per_ms;
1371
1372 sec_etc = ms_left / 1000;
1373 }
1374
1375 if (sec_etc == 0)
1376 {
1377 log_info ("Time.Estimated.: 0 secs");
1378 }
1379 else if ((u64) sec_etc > ETC_MAX)
1380 {
1381 log_info ("Time.Estimated.: > 10 Years");
1382 }
1383 else
1384 {
1385 char display_etc[32] = { 0 };
1386
1387 struct tm tm_etc;
1388
1389 struct tm *tmp = NULL;
1390
1391 #ifdef WIN
1392
1393 tmp = _gmtime64 (&sec_etc);
1394
1395 #else
1396
1397 tmp = gmtime (&sec_etc);
1398
1399 #endif
1400
1401 if (tmp != NULL)
1402 {
1403 memset (&tm_etc, 0, sizeof (tm_etc));
1404
1405 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1406
1407 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1408
1409 time_t now;
1410
1411 time (&now);
1412
1413 now += sec_etc;
1414
1415 char *etc = ctime (&now);
1416
1417 size_t etc_len = strlen (etc);
1418
1419 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1420 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1421
1422 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1423 }
1424 }
1425 }
1426 }
1427
1428 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1429 {
1430 hc_device_param_t *device_param = &data.devices_param[device_id];
1431
1432 if (device_param->skipped) continue;
1433
1434 char display_dev_cur[16] = { 0 };
1435
1436 strncpy (display_dev_cur, "0.00", 4);
1437
1438 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1439
1440 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1441 }
1442
1443 char display_all_cur[16] = { 0 };
1444
1445 strncpy (display_all_cur, "0.00", 4);
1446
1447 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1448
1449 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1450
1451 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1452 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1453
1454 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);
1455
1456 // crack-per-time
1457
1458 if (data.digests_cnt > 100)
1459 {
1460 time_t now = time (NULL);
1461
1462 int cpt_cur_min = 0;
1463 int cpt_cur_hour = 0;
1464 int cpt_cur_day = 0;
1465
1466 for (int i = 0; i < CPT_BUF; i++)
1467 {
1468 const uint cracked = data.cpt_buf[i].cracked;
1469 const time_t timestamp = data.cpt_buf[i].timestamp;
1470
1471 if ((timestamp + 60) > now)
1472 {
1473 cpt_cur_min += cracked;
1474 }
1475
1476 if ((timestamp + 3600) > now)
1477 {
1478 cpt_cur_hour += cracked;
1479 }
1480
1481 if ((timestamp + 86400) > now)
1482 {
1483 cpt_cur_day += cracked;
1484 }
1485 }
1486
1487 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1488 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1489 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1490
1491 if ((data.cpt_start + 86400) < now)
1492 {
1493 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1494 cpt_cur_min,
1495 cpt_cur_hour,
1496 cpt_cur_day,
1497 cpt_avg_min,
1498 cpt_avg_hour,
1499 cpt_avg_day);
1500 }
1501 else if ((data.cpt_start + 3600) < now)
1502 {
1503 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1504 cpt_cur_min,
1505 cpt_cur_hour,
1506 cpt_avg_min,
1507 cpt_avg_hour,
1508 cpt_avg_day);
1509 }
1510 else if ((data.cpt_start + 60) < now)
1511 {
1512 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1513 cpt_cur_min,
1514 cpt_avg_min,
1515 cpt_avg_hour,
1516 cpt_avg_day);
1517 }
1518 else
1519 {
1520 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1521 cpt_avg_min,
1522 cpt_avg_hour,
1523 cpt_avg_day);
1524 }
1525 }
1526
1527 // Restore point
1528
1529 u64 restore_point = get_lowest_words_done ();
1530
1531 u64 restore_total = data.words_base;
1532
1533 float percent_restore = 0;
1534
1535 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1536
1537 if (progress_end_relative_skip)
1538 {
1539 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1540 {
1541 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1542 float percent_rejected = 0.0;
1543
1544 if (progress_cur)
1545 {
1546 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1547 }
1548
1549 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);
1550 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1551
1552 if (data.restore_disable == 0)
1553 {
1554 if (percent_finished != 1)
1555 {
1556 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1557 }
1558 }
1559 }
1560 }
1561 else
1562 {
1563 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1564 {
1565 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1566 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1567
1568 if (data.restore_disable == 0)
1569 {
1570 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1571 }
1572 }
1573 else
1574 {
1575 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1576 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1577
1578 // --restore not allowed if stdin is used -- really? why?
1579
1580 //if (data.restore_disable == 0)
1581 //{
1582 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1583 //}
1584 }
1585 }
1586
1587 #ifdef HAVE_HWMON
1588 if (data.gpu_temp_disable == 0)
1589 {
1590 hc_thread_mutex_lock (mux_adl);
1591
1592 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1593 {
1594 hc_device_param_t *device_param = &data.devices_param[device_id];
1595
1596 if (device_param->skipped) continue;
1597
1598 #define HM_STR_BUF_SIZE 255
1599
1600 if (data.hm_device[device_id].fan_supported == 1)
1601 {
1602 char utilization[HM_STR_BUF_SIZE] = { 0 };
1603 char temperature[HM_STR_BUF_SIZE] = { 0 };
1604 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1605
1606 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1607 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1608
1609 if (device_param->vendor_id == VENDOR_ID_AMD)
1610 {
1611 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1612 }
1613 else if (device_param->vendor_id == VENDOR_ID_NV)
1614 {
1615 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1616 }
1617
1618 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1619 }
1620 else
1621 {
1622 char utilization[HM_STR_BUF_SIZE] = { 0 };
1623 char temperature[HM_STR_BUF_SIZE] = { 0 };
1624
1625 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1626 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1627
1628 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1629 }
1630 }
1631
1632 hc_thread_mutex_unlock (mux_adl);
1633 }
1634 #endif // HAVE_HWMON
1635 }
1636
1637 static void status_benchmark ()
1638 {
1639 if (data.devices_status == STATUS_INIT) return;
1640 if (data.devices_status == STATUS_STARTING) return;
1641
1642 if (data.words_cnt == 0) return;
1643
1644 u64 speed_cnt[DEVICES_MAX] = { 0 };
1645 float speed_ms[DEVICES_MAX] = { 0 };
1646
1647 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1648 {
1649 hc_device_param_t *device_param = &data.devices_param[device_id];
1650
1651 if (device_param->skipped) continue;
1652
1653 speed_cnt[device_id] = 0;
1654 speed_ms[device_id] = 0;
1655
1656 for (int i = 0; i < SPEED_CACHE; i++)
1657 {
1658 speed_cnt[device_id] += device_param->speed_cnt[i];
1659 speed_ms[device_id] += device_param->speed_ms[i];
1660 }
1661
1662 speed_cnt[device_id] /= SPEED_CACHE;
1663 speed_ms[device_id] /= SPEED_CACHE;
1664 }
1665
1666 float hashes_all_ms = 0;
1667
1668 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1669
1670 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1671 {
1672 hc_device_param_t *device_param = &data.devices_param[device_id];
1673
1674 if (device_param->skipped) continue;
1675
1676 hashes_dev_ms[device_id] = 0;
1677
1678 if (speed_ms[device_id])
1679 {
1680 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1681
1682 hashes_all_ms += hashes_dev_ms[device_id];
1683 }
1684 }
1685
1686 /**
1687 * exec time
1688 */
1689
1690 double exec_all_ms[DEVICES_MAX] = { 0 };
1691
1692 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1693 {
1694 hc_device_param_t *device_param = &data.devices_param[device_id];
1695
1696 if (device_param->skipped) continue;
1697
1698 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1699
1700 exec_all_ms[device_id] = exec_ms_avg;
1701 }
1702
1703 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1704 {
1705 hc_device_param_t *device_param = &data.devices_param[device_id];
1706
1707 if (device_param->skipped) continue;
1708
1709 char display_dev_cur[16] = { 0 };
1710
1711 strncpy (display_dev_cur, "0.00", 4);
1712
1713 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1714
1715 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1716 }
1717
1718 char display_all_cur[16] = { 0 };
1719
1720 strncpy (display_all_cur, "0.00", 4);
1721
1722 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1723
1724 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1725 }
1726
1727 /**
1728 * oclHashcat -only- functions
1729 */
1730
1731 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1732 {
1733 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1734 {
1735 if (attack_kern == ATTACK_KERN_STRAIGHT)
1736 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1737 else if (attack_kern == ATTACK_KERN_COMBI)
1738 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1739 else if (attack_kern == ATTACK_KERN_BF)
1740 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1741 }
1742 else
1743 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1744 }
1745
1746 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)
1747 {
1748 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1749 {
1750 if (attack_kern == ATTACK_KERN_STRAIGHT)
1751 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1752 else if (attack_kern == ATTACK_KERN_COMBI)
1753 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1754 else if (attack_kern == ATTACK_KERN_BF)
1755 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1756 }
1757 else
1758 {
1759 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1760 }
1761 }
1762
1763 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1764 {
1765 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1766 {
1767 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1768 }
1769 else
1770 {
1771 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1772 }
1773 }
1774
1775 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)
1776 {
1777 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1778 {
1779 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1780 }
1781 else
1782 {
1783 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1784 }
1785 }
1786
1787 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1788 {
1789 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1790 }
1791
1792 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1793 {
1794 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1795 }
1796
1797 static uint convert_from_hex (char *line_buf, const uint line_len)
1798 {
1799 if (line_len & 1) return (line_len); // not in hex
1800
1801 if (data.hex_wordlist == 1)
1802 {
1803 uint i;
1804 uint j;
1805
1806 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1807 {
1808 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1809 }
1810
1811 memset (line_buf + i, 0, line_len - i);
1812
1813 return (i);
1814 }
1815 else if (line_len >= 6) // $HEX[] = 6
1816 {
1817 if (line_buf[0] != '$') return (line_len);
1818 if (line_buf[1] != 'H') return (line_len);
1819 if (line_buf[2] != 'E') return (line_len);
1820 if (line_buf[3] != 'X') return (line_len);
1821 if (line_buf[4] != '[') return (line_len);
1822 if (line_buf[line_len - 1] != ']') return (line_len);
1823
1824 uint i;
1825 uint j;
1826
1827 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1828 {
1829 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1830 }
1831
1832 memset (line_buf + i, 0, line_len - i);
1833
1834 return (i);
1835 }
1836
1837 return (line_len);
1838 }
1839
1840 static void clear_prompt ()
1841 {
1842 fputc ('\r', stdout);
1843
1844 for (size_t i = 0; i < strlen (PROMPT); i++)
1845 {
1846 fputc (' ', stdout);
1847 }
1848
1849 fputc ('\r', stdout);
1850
1851 fflush (stdout);
1852 }
1853
1854 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1855 {
1856 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);
1857 }
1858
1859 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1860 {
1861 char *outfile = data.outfile;
1862 uint quiet = data.quiet;
1863 FILE *pot_fp = data.pot_fp;
1864 uint loopback = data.loopback;
1865 uint debug_mode = data.debug_mode;
1866 char *debug_file = data.debug_file;
1867
1868 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1869 int debug_rule_len = 0; // -1 error
1870 uint debug_plain_len = 0;
1871
1872 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1873
1874 // hash
1875
1876 char out_buf[4096] = { 0 };
1877
1878 ascii_digest (out_buf, salt_pos, digest_pos);
1879
1880 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1881
1882 // plain
1883
1884 plain_t plain;
1885
1886 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);
1887
1888 uint gidvid = plain.gidvid;
1889 uint il_pos = plain.il_pos;
1890
1891 u64 crackpos = device_param->words_off;
1892
1893 uint plain_buf[16] = { 0 };
1894
1895 u8 *plain_ptr = (u8 *) plain_buf;
1896 unsigned int plain_len = 0;
1897
1898 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1899 {
1900 u64 gidd = gidvid;
1901 u64 gidm = 0;
1902
1903 pw_t pw;
1904
1905 gidd_to_pw_t (device_param, gidd, &pw);
1906
1907 for (int i = 0, j = gidm; i < 16; i++, j++)
1908 {
1909 plain_buf[i] = pw.i[j];
1910 }
1911
1912 plain_len = pw.pw_len;
1913
1914 const uint off = device_param->innerloop_pos + il_pos;
1915
1916 if (debug_mode > 0)
1917 {
1918 debug_rule_len = 0;
1919
1920 // save rule
1921 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1922 {
1923 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1924
1925 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1926 }
1927
1928 // save plain
1929 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1930 {
1931 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1932
1933 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1934
1935 debug_plain_len = plain_len;
1936 }
1937 }
1938
1939 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1940
1941 crackpos += gidvid;
1942 crackpos *= data.kernel_rules_cnt;
1943 crackpos += device_param->innerloop_pos + il_pos;
1944
1945 if (plain_len > data.pw_max) plain_len = data.pw_max;
1946 }
1947 else if (data.attack_mode == ATTACK_MODE_COMBI)
1948 {
1949 u64 gidd = gidvid;
1950 u64 gidm = 0;
1951
1952 pw_t pw;
1953
1954 gidd_to_pw_t (device_param, gidd, &pw);
1955
1956 for (int i = 0, j = gidm; i < 16; i++, j++)
1957 {
1958 plain_buf[i] = pw.i[j];
1959 }
1960
1961 plain_len = pw.pw_len;
1962
1963 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1964 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1965
1966 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1967 {
1968 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1969 }
1970 else
1971 {
1972 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1973
1974 memcpy (plain_ptr, comb_buf, comb_len);
1975 }
1976
1977 plain_len += comb_len;
1978
1979 crackpos += gidvid;
1980 crackpos *= data.combs_cnt;
1981 crackpos += device_param->innerloop_pos + il_pos;
1982
1983 if (data.pw_max != PW_DICTMAX1)
1984 {
1985 if (plain_len > data.pw_max) plain_len = data.pw_max;
1986 }
1987 }
1988 else if (data.attack_mode == ATTACK_MODE_BF)
1989 {
1990 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1991 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1992
1993 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1994 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1995
1996 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1997 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1998
1999 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2000 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2001
2002 plain_len = data.css_cnt;
2003
2004 crackpos += gidvid;
2005 crackpos *= data.bfs_cnt;
2006 crackpos += device_param->innerloop_pos + il_pos;
2007 }
2008 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2009 {
2010 u64 gidd = gidvid;
2011 u64 gidm = 0;
2012
2013 pw_t pw;
2014
2015 gidd_to_pw_t (device_param, gidd, &pw);
2016
2017 for (int i = 0, j = gidm; i < 16; i++, j++)
2018 {
2019 plain_buf[i] = pw.i[j];
2020 }
2021
2022 plain_len = pw.pw_len;
2023
2024 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2025
2026 uint start = 0;
2027 uint stop = device_param->kernel_params_mp_buf32[4];
2028
2029 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2030
2031 plain_len += start + stop;
2032
2033 crackpos += gidvid;
2034 crackpos *= data.combs_cnt;
2035 crackpos += device_param->innerloop_pos + il_pos;
2036
2037 if (data.pw_max != PW_DICTMAX1)
2038 {
2039 if (plain_len > data.pw_max) plain_len = data.pw_max;
2040 }
2041 }
2042 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2043 {
2044 u64 gidd = gidvid;
2045 u64 gidm = 0;
2046
2047 pw_t pw;
2048
2049 gidd_to_pw_t (device_param, gidd, &pw);
2050
2051 for (int i = 0, j = gidm; i < 16; i++, j++)
2052 {
2053 plain_buf[i] = pw.i[j];
2054 }
2055
2056 plain_len = pw.pw_len;
2057
2058 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2059
2060 uint start = 0;
2061 uint stop = device_param->kernel_params_mp_buf32[4];
2062
2063 memmove (plain_ptr + stop, plain_ptr, plain_len);
2064
2065 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2066
2067 plain_len += start + stop;
2068
2069 crackpos += gidvid;
2070 crackpos *= data.combs_cnt;
2071 crackpos += device_param->innerloop_pos + il_pos;
2072
2073 if (data.pw_max != PW_DICTMAX1)
2074 {
2075 if (plain_len > data.pw_max) plain_len = data.pw_max;
2076 }
2077 }
2078
2079 if (data.attack_mode == ATTACK_MODE_BF)
2080 {
2081 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2082 {
2083 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2084 {
2085 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2086 {
2087 plain_len = plain_len - data.salts_buf[0].salt_len;
2088 }
2089 }
2090
2091 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2092 {
2093 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2094 {
2095 plain_ptr[j] = plain_ptr[i];
2096 }
2097
2098 plain_len = plain_len / 2;
2099 }
2100 }
2101 }
2102
2103 // if enabled, update also the potfile
2104
2105 if (pot_fp)
2106 {
2107 lock_file (pot_fp);
2108
2109 fprintf (pot_fp, "%s:", out_buf);
2110
2111 format_plain (pot_fp, plain_ptr, plain_len, 1);
2112
2113 fputc ('\n', pot_fp);
2114
2115 fflush (pot_fp);
2116
2117 unlock_file (pot_fp);
2118 }
2119
2120 // outfile
2121
2122 FILE *out_fp = NULL;
2123
2124 if (outfile != NULL)
2125 {
2126 if ((out_fp = fopen (outfile, "ab")) == NULL)
2127 {
2128 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2129
2130 out_fp = stdout;
2131 }
2132 lock_file (out_fp);
2133 }
2134 else
2135 {
2136 out_fp = stdout;
2137
2138 if (quiet == 0) clear_prompt ();
2139 }
2140
2141 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2142
2143 if (outfile != NULL)
2144 {
2145 if (out_fp != stdout)
2146 {
2147 fclose (out_fp);
2148 }
2149 }
2150 else
2151 {
2152 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2153 {
2154 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2155 {
2156 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2157 if (quiet == 0) fflush (stdout);
2158 }
2159 }
2160 }
2161
2162 // loopback
2163
2164 if (loopback)
2165 {
2166 char *loopback_file = data.loopback_file;
2167
2168 FILE *fb_fp = NULL;
2169
2170 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2171 {
2172 lock_file (fb_fp);
2173
2174 format_plain (fb_fp, plain_ptr, plain_len, 1);
2175
2176 fputc ('\n', fb_fp);
2177
2178 fclose (fb_fp);
2179 }
2180 }
2181
2182 // (rule) debug mode
2183
2184 // the next check implies that:
2185 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2186 // - debug_mode > 0
2187
2188 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2189 {
2190 if (debug_rule_len < 0) debug_rule_len = 0;
2191
2192 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2193
2194 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2195
2196 if ((quiet == 0) && (debug_file == NULL))
2197 {
2198 fprintf (stdout, "%s", PROMPT);
2199 fflush (stdout);
2200 }
2201 }
2202 }
2203
2204 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2205 {
2206 salt_t *salt_buf = &data.salts_buf[salt_pos];
2207
2208 int found = 0;
2209
2210 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);
2211
2212 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2213
2214 if (found == 1)
2215 {
2216 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2217
2218 log_info_nn ("");
2219
2220 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);
2221
2222 uint cpt_cracked = 0;
2223
2224 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2225 {
2226 uint idx = salt_buf->digests_offset + digest_pos;
2227
2228 if (data.digests_shown_tmp[idx] == 0) continue;
2229
2230 if (data.digests_shown[idx] == 1) continue;
2231
2232 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2233 {
2234 data.digests_shown[idx] = 1;
2235
2236 data.digests_done++;
2237
2238 cpt_cracked++;
2239
2240 salt_buf->digests_done++;
2241
2242 if (salt_buf->digests_done == salt_buf->digests_cnt)
2243 {
2244 data.salts_shown[salt_pos] = 1;
2245
2246 data.salts_done++;
2247 }
2248 }
2249
2250 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2251
2252 check_hash (device_param, salt_pos, digest_pos);
2253 }
2254
2255 if (cpt_cracked > 0)
2256 {
2257 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2258 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2259
2260 data.cpt_pos++;
2261
2262 data.cpt_total += cpt_cracked;
2263
2264 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2265 }
2266
2267 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2268 {
2269 // we need to reset cracked state on the device
2270 // otherwise host thinks again and again the hash was cracked
2271 // and returns invalid password each time
2272
2273 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2274
2275 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);
2276 }
2277
2278 memset (device_param->result, 0, device_param->size_results);
2279
2280 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);
2281 }
2282 }
2283
2284 static void save_hash ()
2285 {
2286 char *hashfile = data.hashfile;
2287
2288 char new_hashfile[256] = { 0 };
2289 char old_hashfile[256] = { 0 };
2290
2291 snprintf (new_hashfile, 255, "%s.new", hashfile);
2292 snprintf (old_hashfile, 255, "%s.old", hashfile);
2293
2294 unlink (new_hashfile);
2295
2296 char separator = data.separator;
2297
2298 FILE *fp = fopen (new_hashfile, "wb");
2299
2300 if (fp == NULL)
2301 {
2302 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2303
2304 exit (-1);
2305 }
2306
2307 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2308 {
2309 if (data.salts_shown[salt_pos] == 1) continue;
2310
2311 salt_t *salt_buf = &data.salts_buf[salt_pos];
2312
2313 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2314 {
2315 uint idx = salt_buf->digests_offset + digest_pos;
2316
2317 if (data.digests_shown[idx] == 1) continue;
2318
2319 if (data.hash_mode != 2500)
2320 {
2321 char out_buf[4096] = { 0 };
2322
2323 if (data.username == 1)
2324 {
2325 user_t *user = data.hash_info[idx]->user;
2326
2327 uint i;
2328
2329 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2330
2331 fputc (separator, fp);
2332 }
2333
2334 ascii_digest (out_buf, salt_pos, digest_pos);
2335
2336 fputs (out_buf, fp);
2337
2338 log_out (fp, "");
2339 }
2340 else
2341 {
2342 hccap_t hccap;
2343
2344 to_hccap_t (&hccap, salt_pos, digest_pos);
2345
2346 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2347 }
2348 }
2349 }
2350
2351 fflush (fp);
2352
2353 fclose (fp);
2354
2355 unlink (old_hashfile);
2356
2357 if (rename (hashfile, old_hashfile) != 0)
2358 {
2359 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2360
2361 exit (-1);
2362 }
2363
2364 unlink (hashfile);
2365
2366 if (rename (new_hashfile, hashfile) != 0)
2367 {
2368 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2369
2370 exit (-1);
2371 }
2372
2373 unlink (old_hashfile);
2374 }
2375
2376 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2377 {
2378 // function called only in case kernel_power_all > words_left
2379
2380 float kernel_power_div = (float) (total_left) / kernel_power_all;
2381
2382 kernel_power_div += kernel_power_div / 100;
2383
2384 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2385
2386 while (kernel_power_new < total_left)
2387 {
2388 kernel_power_div += kernel_power_div / 100;
2389
2390 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2391 }
2392
2393 if (data.quiet == 0)
2394 {
2395 clear_prompt ();
2396
2397 log_info ("");
2398
2399 log_info ("INFO: approaching final keyspace, workload adjusted");
2400
2401 log_info ("");
2402
2403 fprintf (stdout, "%s", PROMPT);
2404
2405 fflush (stdout);
2406 }
2407
2408 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2409
2410 return kernel_power_div;
2411 }
2412
2413 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2414 {
2415 uint num_elements = num;
2416
2417 device_param->kernel_params_buf32[30] = data.combs_mode;
2418 device_param->kernel_params_buf32[31] = num;
2419
2420 uint kernel_threads = device_param->kernel_threads;
2421
2422 while (num_elements % kernel_threads) num_elements++;
2423
2424 cl_kernel kernel = NULL;
2425
2426 switch (kern_run)
2427 {
2428 case KERN_RUN_1: kernel = device_param->kernel1; break;
2429 case KERN_RUN_12: kernel = device_param->kernel12; break;
2430 case KERN_RUN_2: kernel = device_param->kernel2; break;
2431 case KERN_RUN_23: kernel = device_param->kernel23; break;
2432 case KERN_RUN_3: kernel = device_param->kernel3; break;
2433 }
2434
2435 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2436 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2437 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2438 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2439 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2440 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2441 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2442 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2443 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2444 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2445 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2446
2447 hc_timer_t timer;
2448
2449 hc_timer_set (&timer);
2450
2451 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2452 {
2453 const size_t global_work_size[3] = { num_elements, 32, 1 };
2454 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2455
2456 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2457 }
2458 else
2459 {
2460 size_t workgroup_size = 0;
2461
2462 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2463
2464 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2465
2466 const size_t global_work_size[3] = { num_elements, 1, 1 };
2467 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2468
2469 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2470 }
2471
2472 hc_clFlush (data.ocl, device_param->command_queue);
2473
2474 hc_clFinish (data.ocl, device_param->command_queue);
2475
2476 if (event_update)
2477 {
2478 float exec_time;
2479
2480 hc_timer_get (timer, exec_time);
2481
2482 uint exec_pos = device_param->exec_pos;
2483
2484 device_param->exec_ms[exec_pos] = exec_time;
2485
2486 exec_pos++;
2487
2488 if (exec_pos == EXEC_CACHE)
2489 {
2490 exec_pos = 0;
2491 }
2492
2493 device_param->exec_pos = exec_pos;
2494 }
2495 }
2496
2497 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2498 {
2499 uint num_elements = num;
2500
2501 switch (kern_run)
2502 {
2503 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2504 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2505 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2506 }
2507
2508 // causes problems with special threads like in bcrypt
2509 // const uint kernel_threads = device_param->kernel_threads;
2510
2511 uint kernel_threads = KERNEL_THREADS;
2512
2513 while (num_elements % kernel_threads) num_elements++;
2514
2515 cl_kernel kernel = NULL;
2516
2517 switch (kern_run)
2518 {
2519 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2520 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2521 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2522 }
2523
2524 switch (kern_run)
2525 {
2526 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2527 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2528 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2529 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2530 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2531 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2532 break;
2533 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2534 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2535 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2536 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2537 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2538 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2539 break;
2540 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2541 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2542 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2543 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2544 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2545 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2546 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2547 break;
2548 }
2549
2550 size_t workgroup_size = 0;
2551 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
2552 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2553
2554 const size_t global_work_size[3] = { num_elements, 1, 1 };
2555 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2556
2557 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2558
2559 hc_clFlush (data.ocl, device_param->command_queue);
2560
2561 hc_clFinish (data.ocl, device_param->command_queue);
2562 }
2563
2564 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2565 {
2566 uint num_elements = num;
2567
2568 uint kernel_threads = device_param->kernel_threads;
2569
2570 while (num_elements % kernel_threads) num_elements++;
2571
2572 cl_kernel kernel = device_param->kernel_tb;
2573
2574 size_t workgroup_size = 0;
2575 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2576 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2577
2578 const size_t global_work_size[3] = { num_elements, 1, 1 };
2579 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2580
2581 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2582
2583 hc_clFlush (data.ocl, device_param->command_queue);
2584
2585 hc_clFinish (data.ocl, device_param->command_queue);
2586 }
2587
2588 static void run_kernel_tm (hc_device_param_t *device_param)
2589 {
2590 const uint num_elements = 1024; // fixed
2591
2592 uint kernel_threads = 32;
2593
2594 cl_kernel kernel = device_param->kernel_tm;
2595
2596 size_t workgroup_size = 0;
2597 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2598 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2599
2600 const size_t global_work_size[3] = { num_elements, 1, 1 };
2601 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2602
2603 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2604
2605 hc_clFlush (data.ocl, device_param->command_queue);
2606
2607 hc_clFinish (data.ocl, device_param->command_queue);
2608 }
2609
2610 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2611 {
2612 uint num_elements = num;
2613
2614 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2615 device_param->kernel_params_amp_buf32[6] = num_elements;
2616
2617 // causes problems with special threads like in bcrypt
2618 // const uint kernel_threads = device_param->kernel_threads;
2619
2620 uint kernel_threads = KERNEL_THREADS;
2621
2622 while (num_elements % kernel_threads) num_elements++;
2623
2624 cl_kernel kernel = device_param->kernel_amp;
2625
2626 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2627 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2628
2629 size_t workgroup_size = 0;
2630 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2631 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2632
2633 const size_t global_work_size[3] = { num_elements, 1, 1 };
2634 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2635
2636 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2637
2638 hc_clFlush (data.ocl, device_param->command_queue);
2639
2640 hc_clFinish (data.ocl, device_param->command_queue);
2641 }
2642
2643 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2644 {
2645 int rc = -1;
2646
2647 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2648 {
2649 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2650
2651 const cl_uchar zero = 0;
2652
2653 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2654 }
2655
2656 if (rc != 0)
2657 {
2658 // NOTE: clEnqueueFillBuffer () always fails with -59
2659 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2660 // How's that possible, OpenCL 1.2 support is advertised??
2661 // We need to workaround...
2662
2663 #define FILLSZ 0x100000
2664
2665 char *tmp = (char *) mymalloc (FILLSZ);
2666
2667 for (uint i = 0; i < size; i += FILLSZ)
2668 {
2669 const int left = size - i;
2670
2671 const int fillsz = MIN (FILLSZ, left);
2672
2673 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2674 }
2675
2676 myfree (tmp);
2677 }
2678 }
2679
2680 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)
2681 {
2682 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2683 {
2684 if (attack_mode == ATTACK_MODE_BF)
2685 {
2686 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2687 {
2688 const uint size_tm = 32 * sizeof (bs_word_t);
2689
2690 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2691
2692 run_kernel_tm (device_param);
2693
2694 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);
2695 }
2696 }
2697
2698 if (highest_pw_len < 16)
2699 {
2700 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2701 }
2702 else if (highest_pw_len < 32)
2703 {
2704 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2705 }
2706 else
2707 {
2708 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2709 }
2710 }
2711 else
2712 {
2713 run_kernel_amp (device_param, pws_cnt);
2714
2715 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2716
2717 if (opts_type & OPTS_TYPE_HOOK12)
2718 {
2719 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2720 }
2721
2722 uint iter = salt_buf->salt_iter;
2723
2724 uint loop_step = device_param->kernel_loops;
2725
2726 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2727 {
2728 uint loop_left = iter - loop_pos;
2729
2730 loop_left = MIN (loop_left, loop_step);
2731
2732 device_param->kernel_params_buf32[25] = loop_pos;
2733 device_param->kernel_params_buf32[26] = loop_left;
2734
2735 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2736
2737 if (data.devices_status == STATUS_CRACKED) break;
2738 if (data.devices_status == STATUS_ABORTED) break;
2739 if (data.devices_status == STATUS_QUIT) break;
2740 }
2741
2742 if (opts_type & OPTS_TYPE_HOOK23)
2743 {
2744 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2745
2746 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);
2747
2748 // do something with data
2749
2750 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);
2751 }
2752
2753 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2754 }
2755 }
2756
2757 static int run_rule_engine (const int rule_len, const char *rule_buf)
2758 {
2759 if (rule_len == 0)
2760 {
2761 return 0;
2762 }
2763 else if (rule_len == 1)
2764 {
2765 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2766 }
2767
2768 return 1;
2769 }
2770
2771 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2772 {
2773 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2774 {
2775 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);
2776 }
2777 else if (data.attack_kern == ATTACK_KERN_COMBI)
2778 {
2779 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2780 {
2781 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2782 {
2783 for (u32 i = 0; i < pws_cnt; i++)
2784 {
2785 const u32 pw_len = device_param->pws_buf[i].pw_len;
2786
2787 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2788
2789 ptr[pw_len] = 0x01;
2790 }
2791 }
2792 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2793 {
2794 for (u32 i = 0; i < pws_cnt; i++)
2795 {
2796 const u32 pw_len = device_param->pws_buf[i].pw_len;
2797
2798 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2799
2800 ptr[pw_len] = 0x80;
2801 }
2802 }
2803 }
2804
2805 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);
2806 }
2807 else if (data.attack_kern == ATTACK_KERN_BF)
2808 {
2809 const u64 off = device_param->words_off;
2810
2811 device_param->kernel_params_mp_l_buf64[3] = off;
2812
2813 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2814 }
2815 }
2816
2817 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops, const int repeat)
2818 {
2819 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2820
2821 device_param->kernel_params_buf32[26] = kernel_loops;
2822 device_param->kernel_params_buf32[27] = kernel_loops;
2823
2824 // init some fake words
2825
2826 if (data.attack_kern == ATTACK_KERN_BF)
2827 {
2828 run_kernel_mp (KERN_RUN_MP_L, device_param, kernel_power);
2829 run_kernel_mp (KERN_RUN_MP_R, device_param, kernel_loops);
2830 }
2831 else
2832 {
2833 for (u32 i = 0; i < kernel_power; i++)
2834 {
2835 device_param->pws_buf[i].pw_len = i & 7;
2836 }
2837
2838 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2839
2840 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2841 {
2842 run_kernel_amp (device_param, kernel_power);
2843 }
2844 }
2845
2846 // caching run
2847
2848 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2849 {
2850 run_kernel (KERN_RUN_1, device_param, kernel_power, false);
2851 }
2852 else
2853 {
2854 run_kernel (KERN_RUN_2, device_param, kernel_power, false);
2855 }
2856
2857 // now user repeats
2858
2859 for (int i = 0; i < repeat; i++)
2860 {
2861 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2862 {
2863 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2864 }
2865 else
2866 {
2867 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2868 }
2869 }
2870
2871 const double exec_ms_prev = get_avg_exec_time (device_param, repeat);
2872
2873 // reset fake words
2874
2875 memset (device_param->pws_buf, 0, kernel_power * sizeof (pw_t));
2876
2877 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2878 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_amp_buf, CL_TRUE, 0, kernel_power * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2879
2880 return exec_ms_prev;
2881 }
2882
2883 static void autotune (hc_device_param_t *device_param)
2884 {
2885 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2886
2887 const u32 kernel_accel_min = device_param->kernel_accel_min;
2888 const u32 kernel_accel_max = device_param->kernel_accel_max;
2889
2890 const u32 kernel_loops_min = device_param->kernel_loops_min;
2891 const u32 kernel_loops_max = device_param->kernel_loops_max;
2892
2893 u32 kernel_accel = kernel_accel_min;
2894 u32 kernel_loops = kernel_loops_min;
2895
2896 // steps
2897
2898 #define STEPS_CNT 10
2899
2900 #define STEPS_ACCEL_CNT (STEPS_CNT + 2)
2901 #define STEPS_LOOPS_CNT (STEPS_CNT + 2)
2902
2903 u32 steps_accel[STEPS_ACCEL_CNT];
2904 u32 steps_loops[STEPS_LOOPS_CNT];
2905
2906 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2907 {
2908 steps_accel[i] = 1 << i;
2909 }
2910
2911 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2912 {
2913 steps_loops[i] = 1 << i;
2914 }
2915
2916 steps_accel[STEPS_CNT + 0] = kernel_accel_min;
2917 steps_accel[STEPS_CNT + 1] = kernel_accel_max;
2918
2919 steps_loops[STEPS_CNT + 0] = kernel_loops_min;
2920 steps_loops[STEPS_CNT + 1] = kernel_loops_max;
2921
2922 qsort (steps_accel, STEPS_ACCEL_CNT, sizeof (u32), sort_by_u32);
2923 qsort (steps_loops, STEPS_LOOPS_CNT, sizeof (u32), sort_by_u32);
2924
2925 // find out highest kernel-loops that stays below target_ms, we can use it later for multiplication as this is a linear function
2926
2927 u32 kernel_loops_tmp;
2928
2929 for (kernel_loops_tmp = kernel_loops_max; kernel_loops_tmp > kernel_loops_min; kernel_loops_tmp >>= 1)
2930 {
2931 const double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops_tmp, 1);
2932
2933 if (exec_ms < target_ms) break;
2934 }
2935
2936 // kernel-accel
2937
2938 if (kernel_accel_min < kernel_accel_max)
2939 {
2940 double e_best = 0;
2941
2942 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2943 {
2944 const u32 kernel_accel_try = steps_accel[i];
2945
2946 if (kernel_accel_try < kernel_accel_min) continue;
2947 if (kernel_accel_try > kernel_accel_max) break;
2948
2949 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_tmp, 1);
2950
2951 if (exec_ms > target_ms) break;
2952
2953 const double e = kernel_accel_try / exec_ms;
2954
2955 if (e > e_best)
2956 {
2957 kernel_accel = kernel_accel_try;
2958
2959 e_best = e;
2960 }
2961 }
2962 }
2963
2964 // kernel-loops final
2965
2966 if (kernel_loops_min < kernel_loops_max)
2967 {
2968 double e_best = 0;
2969
2970 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2971 {
2972 const u32 kernel_loops_try = steps_loops[i];
2973
2974 if (kernel_loops_try < kernel_loops_min) continue;
2975 if (kernel_loops_try > kernel_loops_max) break;
2976
2977 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops_try, 1);
2978
2979 if (exec_ms > target_ms) break;
2980
2981 const double e = kernel_loops_try / exec_ms;
2982
2983 if (e > e_best)
2984 {
2985 kernel_loops = kernel_loops_try;
2986
2987 e_best = e;
2988 }
2989 }
2990 }
2991
2992 // final balance
2993
2994 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops, 1);
2995
2996 u32 kernel_accel_best = kernel_accel;
2997 u32 kernel_loops_best = kernel_loops;
2998
2999 u32 exec_best = exec_ms;
3000
3001 // reset
3002
3003 if (kernel_accel_min < kernel_accel_max)
3004 {
3005 u32 kernel_accel_try = kernel_accel;
3006 u32 kernel_loops_try = kernel_loops;
3007
3008 for (int i = 0; i < 2; i++)
3009 {
3010 kernel_accel_try >>= 1;
3011 kernel_loops_try <<= 1;
3012
3013 if (kernel_accel_try < kernel_accel_min) break;
3014 if (kernel_loops_try > kernel_loops_max) break;
3015
3016 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
3017
3018 if (exec_ms < exec_best)
3019 {
3020 kernel_accel_best = kernel_accel_try;
3021 kernel_loops_best = kernel_loops_try;
3022
3023 exec_best = exec_ms;
3024 }
3025 }
3026
3027 kernel_accel = kernel_accel_best;
3028 kernel_loops = kernel_loops_best;
3029 }
3030
3031 // reset
3032
3033
3034 if (kernel_loops_min < kernel_loops_max)
3035 {
3036 u32 kernel_accel_try = kernel_accel;
3037 u32 kernel_loops_try = kernel_loops;
3038
3039 for (int i = 0; i < 2; i++)
3040 {
3041 kernel_accel_try <<= 1;
3042 kernel_loops_try >>= 1;
3043
3044 if (kernel_accel_try > kernel_accel_max) break;
3045 if (kernel_loops_try < kernel_loops_min) break;
3046
3047 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
3048
3049 if (exec_ms < exec_best)
3050 {
3051 kernel_accel_best = kernel_accel_try;
3052 kernel_loops_best = kernel_loops_try;
3053
3054 exec_best = exec_ms;
3055 }
3056 }
3057
3058 kernel_accel = kernel_accel_best;
3059 kernel_loops = kernel_loops_best;
3060 }
3061
3062 // reset timer
3063
3064 device_param->exec_pos = 0;
3065
3066 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3067
3068 // store
3069
3070 device_param->kernel_loops = kernel_loops;
3071 device_param->kernel_accel = kernel_accel;
3072
3073 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3074
3075 device_param->kernel_power = kernel_power;
3076
3077 if (data.quiet == 0) log_info ("Device #%u: autotuned kernel-accel to %u", device_param->device_id + 1, kernel_accel);
3078 if (data.quiet == 0) log_info ("Device #%u: autotuned kernel-loops to %u", device_param->device_id + 1, kernel_loops);
3079 if (data.quiet == 0) log_info ("");
3080 }
3081
3082 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3083 {
3084 // init speed timer
3085
3086 uint speed_pos = device_param->speed_pos;
3087
3088 #ifdef _POSIX
3089 if (device_param->timer_speed.tv_sec == 0)
3090 {
3091 hc_timer_set (&device_param->timer_speed);
3092 }
3093 #endif
3094
3095 #ifdef _WIN
3096 if (device_param->timer_speed.QuadPart == 0)
3097 {
3098 hc_timer_set (&device_param->timer_speed);
3099 }
3100 #endif
3101
3102 // find higest password length, this is for optimization stuff
3103
3104 uint highest_pw_len = 0;
3105
3106 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3107 {
3108 }
3109 else if (data.attack_kern == ATTACK_KERN_COMBI)
3110 {
3111 }
3112 else if (data.attack_kern == ATTACK_KERN_BF)
3113 {
3114 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3115 + device_param->kernel_params_mp_l_buf32[5];
3116 }
3117
3118 // bitslice optimization stuff
3119
3120 if (data.attack_mode == ATTACK_MODE_BF)
3121 {
3122 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
3123 {
3124 run_kernel_tb (device_param, pws_cnt);
3125 }
3126 }
3127
3128 // iteration type
3129
3130 uint innerloop_step = 0;
3131 uint innerloop_cnt = 0;
3132
3133 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3134 else innerloop_step = 1;
3135
3136 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3137 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3138 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3139
3140 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3141
3142 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3143 {
3144 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3145
3146 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3147
3148 if (data.devices_status == STATUS_CRACKED) break;
3149 if (data.devices_status == STATUS_ABORTED) break;
3150 if (data.devices_status == STATUS_QUIT) break;
3151 if (data.devices_status == STATUS_BYPASS) break;
3152
3153 if (data.salts_shown[salt_pos] == 1) continue;
3154
3155 salt_t *salt_buf = &data.salts_buf[salt_pos];
3156
3157 device_param->kernel_params_buf32[24] = salt_pos;
3158 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3159 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3160
3161 FILE *combs_fp = device_param->combs_fp;
3162
3163 if (data.attack_mode == ATTACK_MODE_COMBI)
3164 {
3165 rewind (combs_fp);
3166 }
3167
3168 // innerloops
3169
3170 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3171 {
3172 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3173
3174 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3175
3176 if (data.devices_status == STATUS_CRACKED) break;
3177 if (data.devices_status == STATUS_ABORTED) break;
3178 if (data.devices_status == STATUS_QUIT) break;
3179 if (data.devices_status == STATUS_BYPASS) break;
3180
3181 uint innerloop_left = innerloop_cnt - innerloop_pos;
3182
3183 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3184
3185 device_param->innerloop_pos = innerloop_pos;
3186 device_param->innerloop_left = innerloop_left;
3187
3188 device_param->kernel_params_buf32[27] = innerloop_left;
3189
3190 // i think we can get rid of this
3191 if (innerloop_left == 0)
3192 {
3193 puts ("bug, how should this happen????\n");
3194
3195 continue;
3196 }
3197
3198 // initialize amplifiers
3199
3200 if (data.attack_mode == ATTACK_MODE_COMBI)
3201 {
3202 char line_buf[BUFSIZ] = { 0 };
3203
3204 uint i = 0;
3205
3206 while (i < innerloop_left)
3207 {
3208 if (feof (combs_fp)) break;
3209
3210 int line_len = fgetl (combs_fp, line_buf);
3211
3212 if (line_len >= PW_MAX1) continue;
3213
3214 line_len = convert_from_hex (line_buf, line_len);
3215
3216 char *line_buf_new = line_buf;
3217
3218 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3219 {
3220 char rule_buf_out[BLOCK_SIZE] = { 0 };
3221
3222 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3223
3224 if (rule_len_out < 0)
3225 {
3226 data.words_progress_rejected[salt_pos] += pws_cnt;
3227
3228 continue;
3229 }
3230
3231 line_len = rule_len_out;
3232
3233 line_buf_new = rule_buf_out;
3234 }
3235
3236 line_len = MIN (line_len, PW_DICTMAX);
3237
3238 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3239
3240 memcpy (ptr, line_buf_new, line_len);
3241
3242 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3243
3244 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3245 {
3246 uppercase (ptr, line_len);
3247 }
3248
3249 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3250 {
3251 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3252 {
3253 ptr[line_len] = 0x80;
3254 }
3255
3256 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3257 {
3258 ptr[line_len] = 0x01;
3259 }
3260 }
3261
3262 device_param->combs_buf[i].pw_len = line_len;
3263
3264 i++;
3265 }
3266
3267 for (uint j = i; j < innerloop_left; j++)
3268 {
3269 device_param->combs_buf[j].i[0] = 0;
3270 device_param->combs_buf[j].i[1] = 0;
3271 device_param->combs_buf[j].i[2] = 0;
3272 device_param->combs_buf[j].i[3] = 0;
3273 device_param->combs_buf[j].i[4] = 0;
3274 device_param->combs_buf[j].i[5] = 0;
3275 device_param->combs_buf[j].i[6] = 0;
3276 device_param->combs_buf[j].i[7] = 0;
3277
3278 device_param->combs_buf[j].pw_len = 0;
3279 }
3280
3281 innerloop_left = i;
3282 }
3283 else if (data.attack_mode == ATTACK_MODE_BF)
3284 {
3285 u64 off = innerloop_pos;
3286
3287 device_param->kernel_params_mp_r_buf64[3] = off;
3288
3289 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3290 }
3291 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3292 {
3293 u64 off = innerloop_pos;
3294
3295 device_param->kernel_params_mp_buf64[3] = off;
3296
3297 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3298 }
3299 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3300 {
3301 u64 off = innerloop_pos;
3302
3303 device_param->kernel_params_mp_buf64[3] = off;
3304
3305 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3306 }
3307
3308 // copy amplifiers
3309
3310 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3311 {
3312 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);
3313 }
3314 else if (data.attack_mode == ATTACK_MODE_COMBI)
3315 {
3316 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);
3317 }
3318 else if (data.attack_mode == ATTACK_MODE_BF)
3319 {
3320 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);
3321 }
3322 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3323 {
3324 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);
3325 }
3326 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3327 {
3328 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);
3329 }
3330
3331 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3332
3333 if (data.benchmark == 1)
3334 {
3335 for (u32 i = 0; i < data.benchmark_repeats; i++)
3336 {
3337 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3338 }
3339 }
3340
3341 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3342
3343 if (data.devices_status == STATUS_CRACKED) break;
3344 if (data.devices_status == STATUS_ABORTED) break;
3345 if (data.devices_status == STATUS_QUIT) break;
3346
3347 /**
3348 * result
3349 */
3350
3351 hc_thread_mutex_lock (mux_display);
3352
3353 check_cracked (device_param, salt_pos);
3354
3355 hc_thread_mutex_unlock (mux_display);
3356
3357 /**
3358 * progress
3359 */
3360
3361 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3362
3363 if (data.benchmark == 1)
3364 {
3365 perf_sum_all = (perf_sum_all * data.benchmark_repeats) + perf_sum_all;
3366 }
3367
3368 hc_thread_mutex_lock (mux_counter);
3369
3370 data.words_progress_done[salt_pos] += perf_sum_all;
3371
3372 hc_thread_mutex_unlock (mux_counter);
3373
3374 /**
3375 * speed
3376 */
3377
3378 float speed_ms;
3379
3380 hc_timer_get (device_param->timer_speed, speed_ms);
3381
3382 hc_timer_set (&device_param->timer_speed);
3383
3384 hc_thread_mutex_lock (mux_display);
3385
3386 device_param->speed_cnt[speed_pos] = perf_sum_all;
3387
3388 device_param->speed_ms[speed_pos] = speed_ms;
3389
3390 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3391
3392 hc_thread_mutex_unlock (mux_display);
3393
3394 speed_pos++;
3395
3396 if (speed_pos == SPEED_CACHE)
3397 {
3398 speed_pos = 0;
3399 }
3400
3401 /**
3402 * benchmark
3403 */
3404
3405 if (data.benchmark == 1) break;
3406 }
3407 }
3408
3409 device_param->speed_pos = speed_pos;
3410 }
3411
3412 static void load_segment (wl_data_t *wl_data, FILE *fd)
3413 {
3414 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3415
3416 wl_data->pos = 0;
3417
3418 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3419
3420 wl_data->buf[wl_data->cnt] = 0;
3421
3422 if (wl_data->cnt == 0) return;
3423
3424 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3425
3426 while (!feof (fd))
3427 {
3428 if (wl_data->cnt == wl_data->avail)
3429 {
3430 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3431
3432 wl_data->avail += wl_data->incr;
3433 }
3434
3435 const int c = fgetc (fd);
3436
3437 if (c == EOF) break;
3438
3439 wl_data->buf[wl_data->cnt] = (char) c;
3440
3441 wl_data->cnt++;
3442
3443 if (c == '\n') break;
3444 }
3445
3446 // ensure stream ends with a newline
3447
3448 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3449 {
3450 wl_data->cnt++;
3451
3452 wl_data->buf[wl_data->cnt - 1] = '\n';
3453 }
3454
3455 return;
3456 }
3457
3458 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3459 {
3460 char *ptr = buf;
3461
3462 for (u32 i = 0; i < sz; i++, ptr++)
3463 {
3464 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3465
3466 if (i == 7)
3467 {
3468 *off = i;
3469 *len = i;
3470
3471 return;
3472 }
3473
3474 if (*ptr != '\n') continue;
3475
3476 *off = i + 1;
3477
3478 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3479
3480 *len = i;
3481
3482 return;
3483 }
3484
3485 *off = sz;
3486 *len = sz;
3487 }
3488
3489 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3490 {
3491 char *ptr = buf;
3492
3493 for (u32 i = 0; i < sz; i++, ptr++)
3494 {
3495 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3496
3497 if (*ptr != '\n') continue;
3498
3499 *off = i + 1;
3500
3501 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3502
3503 *len = i;
3504
3505 return;
3506 }
3507
3508 *off = sz;
3509 *len = sz;
3510 }
3511
3512 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3513 {
3514 char *ptr = buf;
3515
3516 for (u32 i = 0; i < sz; i++, ptr++)
3517 {
3518 if (*ptr != '\n') continue;
3519
3520 *off = i + 1;
3521
3522 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3523
3524 *len = i;
3525
3526 return;
3527 }
3528
3529 *off = sz;
3530 *len = sz;
3531 }
3532
3533 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3534 {
3535 while (wl_data->pos < wl_data->cnt)
3536 {
3537 uint off;
3538 uint len;
3539
3540 char *ptr = wl_data->buf + wl_data->pos;
3541
3542 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3543
3544 wl_data->pos += off;
3545
3546 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3547 {
3548 char rule_buf_out[BLOCK_SIZE] = { 0 };
3549
3550 int rule_len_out = -1;
3551
3552 if (len < BLOCK_SIZE)
3553 {
3554 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3555 }
3556
3557 if (rule_len_out < 0)
3558 {
3559 continue;
3560 }
3561
3562 if (rule_len_out > PW_MAX)
3563 {
3564 continue;
3565 }
3566 }
3567 else
3568 {
3569 if (len > PW_MAX)
3570 {
3571 continue;
3572 }
3573 }
3574
3575 *out_buf = ptr;
3576 *out_len = len;
3577
3578 return;
3579 }
3580
3581 if (feof (fd))
3582 {
3583 fprintf (stderr, "BUG feof()!!\n");
3584
3585 return;
3586 }
3587
3588 load_segment (wl_data, fd);
3589
3590 get_next_word (wl_data, fd, out_buf, out_len);
3591 }
3592
3593 #ifdef _POSIX
3594 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3595 #endif
3596
3597 #ifdef _WIN
3598 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3599 #endif
3600 {
3601 hc_signal (NULL);
3602
3603 dictstat_t d;
3604
3605 d.cnt = 0;
3606
3607 #ifdef _POSIX
3608 fstat (fileno (fd), &d.stat);
3609 #endif
3610
3611 #ifdef _WIN
3612 _fstat64 (fileno (fd), &d.stat);
3613 #endif
3614
3615 d.stat.st_mode = 0;
3616 d.stat.st_nlink = 0;
3617 d.stat.st_uid = 0;
3618 d.stat.st_gid = 0;
3619 d.stat.st_rdev = 0;
3620 d.stat.st_atime = 0;
3621
3622 #ifdef _POSIX
3623 d.stat.st_blksize = 0;
3624 d.stat.st_blocks = 0;
3625 #endif
3626
3627 if (d.stat.st_size == 0) return 0;
3628
3629 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3630
3631 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3632 {
3633 if (d_cache)
3634 {
3635 u64 cnt = d_cache->cnt;
3636
3637 u64 keyspace = cnt;
3638
3639 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3640 {
3641 keyspace *= data.kernel_rules_cnt;
3642 }
3643 else if (data.attack_kern == ATTACK_KERN_COMBI)
3644 {
3645 keyspace *= data.combs_cnt;
3646 }
3647
3648 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);
3649 if (data.quiet == 0) log_info ("");
3650
3651 hc_signal (sigHandler_default);
3652
3653 return (keyspace);
3654 }
3655 }
3656
3657 time_t now = 0;
3658 time_t prev = 0;
3659
3660 u64 comp = 0;
3661 u64 cnt = 0;
3662 u64 cnt2 = 0;
3663
3664 while (!feof (fd))
3665 {
3666 load_segment (wl_data, fd);
3667
3668 comp += wl_data->cnt;
3669
3670 u32 i = 0;
3671
3672 while (i < wl_data->cnt)
3673 {
3674 u32 len;
3675 u32 off;
3676
3677 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3678
3679 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3680 {
3681 char rule_buf_out[BLOCK_SIZE] = { 0 };
3682
3683 int rule_len_out = -1;
3684
3685 if (len < BLOCK_SIZE)
3686 {
3687 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3688 }
3689
3690 if (rule_len_out < 0)
3691 {
3692 len = PW_MAX1;
3693 }
3694 else
3695 {
3696 len = rule_len_out;
3697 }
3698 }
3699
3700 if (len < PW_MAX1)
3701 {
3702 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3703 {
3704 cnt += data.kernel_rules_cnt;
3705 }
3706 else if (data.attack_kern == ATTACK_KERN_COMBI)
3707 {
3708 cnt += data.combs_cnt;
3709 }
3710
3711 d.cnt++;
3712 }
3713
3714 i += off;
3715
3716 cnt2++;
3717 }
3718
3719 time (&now);
3720
3721 if ((now - prev) == 0) continue;
3722
3723 float percent = (float) comp / (float) d.stat.st_size;
3724
3725 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);
3726
3727 time (&prev);
3728 }
3729
3730 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);
3731 if (data.quiet == 0) log_info ("");
3732
3733 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3734
3735 hc_signal (sigHandler_default);
3736
3737 return (cnt);
3738 }
3739
3740 static void *thread_monitor (void *p)
3741 {
3742 uint runtime_check = 0;
3743 uint remove_check = 0;
3744 uint status_check = 0;
3745 uint restore_check = 0;
3746
3747 uint restore_left = data.restore_timer;
3748 uint remove_left = data.remove_timer;
3749 uint status_left = data.status_timer;
3750
3751 #ifdef HAVE_HWMON
3752 uint hwmon_check = 0;
3753
3754 // these variables are mainly used for fan control (AMD only)
3755
3756 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3757
3758 // temperature controller "loopback" values
3759
3760 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3761 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3762
3763 #ifdef HAVE_ADL
3764 int temp_threshold = 1; // degrees celcius
3765
3766 int fan_speed_min = 15; // in percentage
3767 int fan_speed_max = 100;
3768 #endif // HAVE_ADL
3769
3770 time_t last_temp_check_time;
3771 #endif // HAVE_HWMON
3772
3773 uint sleep_time = 1;
3774
3775 if (data.runtime)
3776 {
3777 runtime_check = 1;
3778 }
3779
3780 if (data.restore_timer)
3781 {
3782 restore_check = 1;
3783 }
3784
3785 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3786 {
3787 remove_check = 1;
3788 }
3789
3790 if (data.status == 1)
3791 {
3792 status_check = 1;
3793 }
3794
3795 #ifdef HAVE_HWMON
3796 if (data.gpu_temp_disable == 0)
3797 {
3798 time (&last_temp_check_time);
3799
3800 hwmon_check = 1;
3801 }
3802 #endif
3803
3804 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3805 {
3806 #ifdef HAVE_HWMON
3807 if (hwmon_check == 0)
3808 #endif
3809 return (p);
3810 }
3811
3812 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3813 {
3814 hc_sleep (sleep_time);
3815
3816 if (data.devices_status != STATUS_RUNNING) continue;
3817
3818 #ifdef HAVE_HWMON
3819 if (hwmon_check == 1)
3820 {
3821 hc_thread_mutex_lock (mux_adl);
3822
3823 time_t temp_check_time;
3824
3825 time (&temp_check_time);
3826
3827 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3828
3829 if (Ta == 0) Ta = 1;
3830
3831 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3832 {
3833 hc_device_param_t *device_param = &data.devices_param[device_id];
3834
3835 if (device_param->skipped) continue;
3836
3837 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3838
3839 const int temperature = hm_get_temperature_with_device_id (device_id);
3840
3841 if (temperature > (int) data.gpu_temp_abort)
3842 {
3843 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3844
3845 if (data.devices_status != STATUS_QUIT) myabort ();
3846
3847 break;
3848 }
3849
3850 #ifdef HAVE_ADL
3851 const int gpu_temp_retain = data.gpu_temp_retain;
3852
3853 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3854 {
3855 if (data.hm_device[device_id].fan_supported == 1)
3856 {
3857 int temp_cur = temperature;
3858
3859 int temp_diff_new = gpu_temp_retain - temp_cur;
3860
3861 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3862
3863 // calculate Ta value (time difference in seconds between the last check and this check)
3864
3865 last_temp_check_time = temp_check_time;
3866
3867 float Kp = 1.8;
3868 float Ki = 0.005;
3869 float Kd = 6;
3870
3871 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3872
3873 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);
3874
3875 if (abs (fan_diff_required) >= temp_threshold)
3876 {
3877 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3878
3879 int fan_speed_level = fan_speed_cur;
3880
3881 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3882
3883 int fan_speed_new = fan_speed_level - fan_diff_required;
3884
3885 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3886 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3887
3888 if (fan_speed_new != fan_speed_cur)
3889 {
3890 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3891 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3892
3893 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3894 {
3895 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3896
3897 fan_speed_chgd[device_id] = 1;
3898 }
3899
3900 temp_diff_old[device_id] = temp_diff_new;
3901 }
3902 }
3903 }
3904 }
3905 #endif // HAVE_ADL
3906 }
3907
3908 hc_thread_mutex_unlock (mux_adl);
3909 }
3910 #endif // HAVE_HWMON
3911
3912 if (restore_check == 1)
3913 {
3914 restore_left--;
3915
3916 if (restore_left == 0)
3917 {
3918 if (data.restore_disable == 0) cycle_restore ();
3919
3920 restore_left = data.restore_timer;
3921 }
3922 }
3923
3924 if ((runtime_check == 1) && (data.runtime_start > 0))
3925 {
3926 time_t runtime_cur;
3927
3928 time (&runtime_cur);
3929
3930 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3931
3932 if (runtime_left <= 0)
3933 {
3934 if (data.benchmark == 0)
3935 {
3936 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3937 }
3938
3939 if (data.devices_status != STATUS_QUIT) myabort ();
3940 }
3941 }
3942
3943 if (remove_check == 1)
3944 {
3945 remove_left--;
3946
3947 if (remove_left == 0)
3948 {
3949 if (data.digests_saved != data.digests_done)
3950 {
3951 data.digests_saved = data.digests_done;
3952
3953 save_hash ();
3954 }
3955
3956 remove_left = data.remove_timer;
3957 }
3958 }
3959
3960 if (status_check == 1)
3961 {
3962 status_left--;
3963
3964 if (status_left == 0)
3965 {
3966 hc_thread_mutex_lock (mux_display);
3967
3968 if (data.quiet == 0) clear_prompt ();
3969
3970 if (data.quiet == 0) log_info ("");
3971
3972 status_display ();
3973
3974 if (data.quiet == 0) log_info ("");
3975
3976 hc_thread_mutex_unlock (mux_display);
3977
3978 status_left = data.status_timer;
3979 }
3980 }
3981 }
3982
3983 #ifdef HAVE_HWMON
3984 myfree (fan_speed_chgd);
3985
3986 myfree (temp_diff_old);
3987 myfree (temp_diff_sum);
3988 #endif
3989
3990 p = NULL;
3991
3992 return (p);
3993 }
3994
3995 static void *thread_outfile_remove (void *p)
3996 {
3997 // some hash-dependent constants
3998 char *outfile_dir = data.outfile_check_directory;
3999 uint dgst_size = data.dgst_size;
4000 uint isSalted = data.isSalted;
4001 uint esalt_size = data.esalt_size;
4002 uint hash_mode = data.hash_mode;
4003
4004 uint outfile_check_timer = data.outfile_check_timer;
4005
4006 char separator = data.separator;
4007
4008 // some hash-dependent functions
4009 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4010 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4011
4012 // buffers
4013 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4014
4015 hash_buf.digest = mymalloc (dgst_size);
4016
4017 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4018
4019 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4020
4021 uint digest_buf[64] = { 0 };
4022
4023 outfile_data_t *out_info = NULL;
4024
4025 char **out_files = NULL;
4026
4027 time_t folder_mtime = 0;
4028
4029 int out_cnt = 0;
4030
4031 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4032
4033 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4034 {
4035 hc_sleep (1);
4036
4037 if (data.devices_status != STATUS_RUNNING) continue;
4038
4039 check_left--;
4040
4041 if (check_left == 0)
4042 {
4043 struct stat outfile_check_stat;
4044
4045 if (stat (outfile_dir, &outfile_check_stat) == 0)
4046 {
4047 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4048
4049 if (is_dir == 1)
4050 {
4051 if (outfile_check_stat.st_mtime > folder_mtime)
4052 {
4053 char **out_files_new = scan_directory (outfile_dir);
4054
4055 int out_cnt_new = count_dictionaries (out_files_new);
4056
4057 outfile_data_t *out_info_new = NULL;
4058
4059 if (out_cnt_new > 0)
4060 {
4061 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4062
4063 for (int i = 0; i < out_cnt_new; i++)
4064 {
4065 out_info_new[i].file_name = out_files_new[i];
4066
4067 // check if there are files that we have seen/checked before (and not changed)
4068
4069 for (int j = 0; j < out_cnt; j++)
4070 {
4071 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4072 {
4073 struct stat outfile_stat;
4074
4075 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4076 {
4077 if (outfile_stat.st_ctime == out_info[j].ctime)
4078 {
4079 out_info_new[i].ctime = out_info[j].ctime;
4080 out_info_new[i].seek = out_info[j].seek;
4081 }
4082 }
4083 }
4084 }
4085 }
4086 }
4087
4088 local_free (out_info);
4089 local_free (out_files);
4090
4091 out_files = out_files_new;
4092 out_cnt = out_cnt_new;
4093 out_info = out_info_new;
4094
4095 folder_mtime = outfile_check_stat.st_mtime;
4096 }
4097
4098 for (int j = 0; j < out_cnt; j++)
4099 {
4100 FILE *fp = fopen (out_info[j].file_name, "rb");
4101
4102 if (fp != NULL)
4103 {
4104 //hc_thread_mutex_lock (mux_display);
4105
4106 #ifdef _POSIX
4107 struct stat outfile_stat;
4108
4109 fstat (fileno (fp), &outfile_stat);
4110 #endif
4111
4112 #ifdef _WIN
4113 struct stat64 outfile_stat;
4114
4115 _fstat64 (fileno (fp), &outfile_stat);
4116 #endif
4117
4118 if (outfile_stat.st_ctime > out_info[j].ctime)
4119 {
4120 out_info[j].ctime = outfile_stat.st_ctime;
4121 out_info[j].seek = 0;
4122 }
4123
4124 fseek (fp, out_info[j].seek, SEEK_SET);
4125
4126 while (!feof (fp))
4127 {
4128 char line_buf[BUFSIZ] = { 0 };
4129
4130 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
4131
4132 if (ptr == NULL) break;
4133
4134 int line_len = strlen (line_buf);
4135
4136 if (line_len <= 0) continue;
4137
4138 int iter = MAX_CUT_TRIES;
4139
4140 for (uint i = line_len - 1; i && iter; i--, line_len--)
4141 {
4142 if (line_buf[i] != separator) continue;
4143
4144 int parser_status = PARSER_OK;
4145
4146 if ((hash_mode != 2500) && (hash_mode != 6800))
4147 {
4148 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4149 }
4150
4151 uint found = 0;
4152
4153 if (parser_status == PARSER_OK)
4154 {
4155 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4156 {
4157 if (data.salts_shown[salt_pos] == 1) continue;
4158
4159 salt_t *salt_buf = &data.salts_buf[salt_pos];
4160
4161 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4162 {
4163 uint idx = salt_buf->digests_offset + digest_pos;
4164
4165 if (data.digests_shown[idx] == 1) continue;
4166
4167 uint cracked = 0;
4168
4169 if (hash_mode == 6800)
4170 {
4171 if (i == salt_buf->salt_len)
4172 {
4173 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4174 }
4175 }
4176 else if (hash_mode == 2500)
4177 {
4178 // BSSID : MAC1 : MAC2 (:plain)
4179 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4180 {
4181 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4182
4183 if (!cracked) continue;
4184
4185 // now compare MAC1 and MAC2 too, since we have this additional info
4186 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4187 char *mac2_pos = mac1_pos + 12 + 1;
4188
4189 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4190 wpa_t *wpa = &wpas[salt_pos];
4191
4192 uint pke[25] = { 0 };
4193
4194 char *pke_ptr = (char *) pke;
4195
4196 for (uint i = 0; i < 25; i++)
4197 {
4198 pke[i] = byte_swap_32 (wpa->pke[i]);
4199 }
4200
4201 u8 mac1[6] = { 0 };
4202 u8 mac2[6] = { 0 };
4203
4204 memcpy (mac1, pke_ptr + 23, 6);
4205 memcpy (mac2, pke_ptr + 29, 6);
4206
4207 // compare hex string(s) vs binary MAC address(es)
4208
4209 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4210 {
4211 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4212 {
4213 cracked = 0;
4214 break;
4215 }
4216 }
4217
4218 // early skip ;)
4219 if (!cracked) continue;
4220
4221 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4222 {
4223 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4224 {
4225 cracked = 0;
4226 break;
4227 }
4228 }
4229 }
4230 }
4231 else
4232 {
4233 char *digests_buf_ptr = (char *) data.digests_buf;
4234
4235 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4236
4237 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4238 }
4239
4240 if (cracked == 1)
4241 {
4242 found = 1;
4243
4244 data.digests_shown[idx] = 1;
4245
4246 data.digests_done++;
4247
4248 salt_buf->digests_done++;
4249
4250 if (salt_buf->digests_done == salt_buf->digests_cnt)
4251 {
4252 data.salts_shown[salt_pos] = 1;
4253
4254 data.salts_done++;
4255
4256 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4257 }
4258 }
4259 }
4260
4261 if (data.devices_status == STATUS_CRACKED) break;
4262 }
4263 }
4264
4265 if (found) break;
4266
4267 if (data.devices_status == STATUS_CRACKED) break;
4268
4269 iter--;
4270 }
4271
4272 if (data.devices_status == STATUS_CRACKED) break;
4273 }
4274
4275 out_info[j].seek = ftell (fp);
4276
4277 //hc_thread_mutex_unlock (mux_display);
4278
4279 fclose (fp);
4280 }
4281 }
4282 }
4283 }
4284
4285 check_left = outfile_check_timer;
4286 }
4287 }
4288
4289 if (esalt_size) local_free (hash_buf.esalt);
4290
4291 if (isSalted) local_free (hash_buf.salt);
4292
4293 local_free (hash_buf.digest);
4294
4295 local_free (out_info);
4296
4297 local_free (out_files);
4298
4299 p = NULL;
4300
4301 return (p);
4302 }
4303
4304 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4305 {
4306 if (device_param->pws_cnt < device_param->kernel_power)
4307 {
4308 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4309
4310 memcpy (pw->i, pw_buf, pw_len);
4311
4312 pw->pw_len = pw_len;
4313
4314 device_param->pws_cnt++;
4315 }
4316 else
4317 {
4318 fprintf (stderr, "BUG pw_add()!!\n");
4319
4320 return;
4321 }
4322 }
4323
4324 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4325 {
4326 hc_thread_mutex_lock (mux_dispatcher);
4327
4328 const u64 words_cur = data.words_cur;
4329 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4330
4331 device_param->words_off = words_cur;
4332
4333 const u64 words_left = words_base - words_cur;
4334
4335 if (allow_div)
4336 {
4337 if (data.kernel_power_all > words_left)
4338 {
4339 if (data.kernel_power_div == 0)
4340 {
4341 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4342 }
4343 }
4344
4345 if (data.kernel_power_div)
4346 {
4347 if (device_param->kernel_power == device_param->kernel_power_user)
4348 {
4349 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4350
4351 if (kernel_power_new < device_param->kernel_power)
4352 {
4353 device_param->kernel_power = kernel_power_new;
4354 }
4355 }
4356 }
4357 }
4358
4359 const uint kernel_power = device_param->kernel_power;
4360
4361 uint work = MIN (words_left, kernel_power);
4362
4363 work = MIN (work, max);
4364
4365 data.words_cur += work;
4366
4367 hc_thread_mutex_unlock (mux_dispatcher);
4368
4369 return work;
4370 }
4371
4372 static void *thread_calc_stdin (void *p)
4373 {
4374 hc_device_param_t *device_param = (hc_device_param_t *) p;
4375
4376 if (device_param->skipped) return NULL;
4377
4378 autotune (device_param);
4379
4380 const uint attack_kern = data.attack_kern;
4381
4382 const uint kernel_power = device_param->kernel_power;
4383
4384 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4385 {
4386 hc_thread_mutex_lock (mux_dispatcher);
4387
4388 if (feof (stdin) != 0)
4389 {
4390 hc_thread_mutex_unlock (mux_dispatcher);
4391
4392 break;
4393 }
4394
4395 uint words_cur = 0;
4396
4397 while (words_cur < kernel_power)
4398 {
4399 char buf[BUFSIZ] = { 0 };
4400
4401 char *line_buf = fgets (buf, sizeof (buf), stdin);
4402
4403 if (line_buf == NULL) break;
4404
4405 uint line_len = in_superchop (line_buf);
4406
4407 line_len = convert_from_hex (line_buf, line_len);
4408
4409 // post-process rule engine
4410
4411 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4412 {
4413 char rule_buf_out[BLOCK_SIZE] = { 0 };
4414
4415 int rule_len_out = -1;
4416
4417 if (line_len < BLOCK_SIZE)
4418 {
4419 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4420 }
4421
4422 if (rule_len_out < 0) continue;
4423
4424 line_buf = rule_buf_out;
4425 line_len = rule_len_out;
4426 }
4427
4428 if (line_len > PW_MAX)
4429 {
4430 continue;
4431 }
4432
4433 if (attack_kern == ATTACK_KERN_STRAIGHT)
4434 {
4435 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4436 {
4437 hc_thread_mutex_lock (mux_counter);
4438
4439 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4440 {
4441 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4442 }
4443
4444 hc_thread_mutex_unlock (mux_counter);
4445
4446 continue;
4447 }
4448 }
4449 else if (attack_kern == ATTACK_KERN_COMBI)
4450 {
4451 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4452 // since we still need to combine the plains
4453
4454 if (line_len > data.pw_max)
4455 {
4456 hc_thread_mutex_lock (mux_counter);
4457
4458 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4459 {
4460 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4461 }
4462
4463 hc_thread_mutex_unlock (mux_counter);
4464
4465 continue;
4466 }
4467 }
4468
4469 pw_add (device_param, (u8 *) line_buf, line_len);
4470
4471 words_cur++;
4472
4473 if (data.devices_status == STATUS_CRACKED) break;
4474 if (data.devices_status == STATUS_ABORTED) break;
4475 if (data.devices_status == STATUS_QUIT) break;
4476 if (data.devices_status == STATUS_BYPASS) break;
4477 }
4478
4479 hc_thread_mutex_unlock (mux_dispatcher);
4480
4481 if (data.devices_status == STATUS_CRACKED) break;
4482 if (data.devices_status == STATUS_ABORTED) break;
4483 if (data.devices_status == STATUS_QUIT) break;
4484 if (data.devices_status == STATUS_BYPASS) break;
4485
4486 // flush
4487
4488 const uint pws_cnt = device_param->pws_cnt;
4489
4490 if (pws_cnt)
4491 {
4492 run_copy (device_param, pws_cnt);
4493
4494 run_cracker (device_param, pws_cnt);
4495
4496 device_param->pws_cnt = 0;
4497
4498 if (attack_kern == ATTACK_KERN_STRAIGHT)
4499 {
4500 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4501 }
4502 else if (attack_kern == ATTACK_KERN_COMBI)
4503 {
4504 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4505 }
4506 }
4507 }
4508
4509 device_param->kernel_accel = 0;
4510 device_param->kernel_loops = 0;
4511
4512 return NULL;
4513 }
4514
4515 static void *thread_calc (void *p)
4516 {
4517 hc_device_param_t *device_param = (hc_device_param_t *) p;
4518
4519 if (device_param->skipped) return NULL;
4520
4521 autotune (device_param);
4522
4523 const uint attack_mode = data.attack_mode;
4524 const uint attack_kern = data.attack_kern;
4525
4526 if (attack_mode == ATTACK_MODE_BF)
4527 {
4528 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4529 {
4530 const uint work = get_work (device_param, -1, true);
4531
4532 if (work == 0) break;
4533
4534 const u64 words_off = device_param->words_off;
4535 const u64 words_fin = words_off + work;
4536
4537 const uint pws_cnt = work;
4538
4539 device_param->pws_cnt = pws_cnt;
4540
4541 if (pws_cnt)
4542 {
4543 run_copy (device_param, pws_cnt);
4544
4545 run_cracker (device_param, pws_cnt);
4546
4547 device_param->pws_cnt = 0;
4548
4549 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4550 }
4551
4552 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4553
4554 if (data.devices_status == STATUS_CRACKED) break;
4555 if (data.devices_status == STATUS_ABORTED) break;
4556 if (data.devices_status == STATUS_QUIT) break;
4557 if (data.devices_status == STATUS_BYPASS) break;
4558
4559 if (data.benchmark == 1) break;
4560
4561 device_param->words_done = words_fin;
4562 }
4563 }
4564 else
4565 {
4566 const uint segment_size = data.segment_size;
4567
4568 char *dictfile = data.dictfile;
4569
4570 if (attack_mode == ATTACK_MODE_COMBI)
4571 {
4572 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4573 {
4574 dictfile = data.dictfile2;
4575 }
4576 }
4577
4578 FILE *fd = fopen (dictfile, "rb");
4579
4580 if (fd == NULL)
4581 {
4582 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4583
4584 return NULL;
4585 }
4586
4587 if (attack_mode == ATTACK_MODE_COMBI)
4588 {
4589 const uint combs_mode = data.combs_mode;
4590
4591 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4592 {
4593 const char *dictfilec = data.dictfile2;
4594
4595 FILE *combs_fp = fopen (dictfilec, "rb");
4596
4597 if (combs_fp == NULL)
4598 {
4599 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4600
4601 fclose (fd);
4602
4603 return NULL;
4604 }
4605
4606 device_param->combs_fp = combs_fp;
4607 }
4608 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4609 {
4610 const char *dictfilec = data.dictfile;
4611
4612 FILE *combs_fp = fopen (dictfilec, "rb");
4613
4614 if (combs_fp == NULL)
4615 {
4616 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4617
4618 fclose (fd);
4619
4620 return NULL;
4621 }
4622
4623 device_param->combs_fp = combs_fp;
4624 }
4625 }
4626
4627 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4628
4629 wl_data->buf = (char *) mymalloc (segment_size);
4630 wl_data->avail = segment_size;
4631 wl_data->incr = segment_size;
4632 wl_data->cnt = 0;
4633 wl_data->pos = 0;
4634
4635 u64 words_cur = 0;
4636
4637 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4638 {
4639 u64 words_off = 0;
4640 u64 words_fin = 0;
4641
4642 bool allow_div = true;
4643
4644 u64 max = -1;
4645
4646 while (max)
4647 {
4648 const uint work = get_work (device_param, max, allow_div);
4649
4650 allow_div = false;
4651
4652 if (work == 0) break;
4653
4654 words_off = device_param->words_off;
4655 words_fin = words_off + work;
4656
4657 char *line_buf;
4658 uint line_len;
4659
4660 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4661
4662 max = 0;
4663
4664 for ( ; words_cur < words_fin; words_cur++)
4665 {
4666 get_next_word (wl_data, fd, &line_buf, &line_len);
4667
4668 line_len = convert_from_hex (line_buf, line_len);
4669
4670 // post-process rule engine
4671
4672 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4673 {
4674 char rule_buf_out[BLOCK_SIZE] = { 0 };
4675
4676 int rule_len_out = -1;
4677
4678 if (line_len < BLOCK_SIZE)
4679 {
4680 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4681 }
4682
4683 if (rule_len_out < 0) continue;
4684
4685 line_buf = rule_buf_out;
4686 line_len = rule_len_out;
4687 }
4688
4689 if (attack_kern == ATTACK_KERN_STRAIGHT)
4690 {
4691 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4692 {
4693 max++;
4694
4695 hc_thread_mutex_lock (mux_counter);
4696
4697 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4698 {
4699 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4700 }
4701
4702 hc_thread_mutex_unlock (mux_counter);
4703
4704 continue;
4705 }
4706 }
4707 else if (attack_kern == ATTACK_KERN_COMBI)
4708 {
4709 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4710 // since we still need to combine the plains
4711
4712 if (line_len > data.pw_max)
4713 {
4714 max++;
4715
4716 hc_thread_mutex_lock (mux_counter);
4717
4718 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4719 {
4720 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4721 }
4722
4723 hc_thread_mutex_unlock (mux_counter);
4724
4725 continue;
4726 }
4727 }
4728
4729 pw_add (device_param, (u8 *) line_buf, line_len);
4730
4731 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4732
4733 if (data.devices_status == STATUS_CRACKED) break;
4734 if (data.devices_status == STATUS_ABORTED) break;
4735 if (data.devices_status == STATUS_QUIT) break;
4736 if (data.devices_status == STATUS_BYPASS) break;
4737 }
4738
4739 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4740
4741 if (data.devices_status == STATUS_CRACKED) break;
4742 if (data.devices_status == STATUS_ABORTED) break;
4743 if (data.devices_status == STATUS_QUIT) break;
4744 if (data.devices_status == STATUS_BYPASS) break;
4745 }
4746
4747 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4748
4749 if (data.devices_status == STATUS_CRACKED) break;
4750 if (data.devices_status == STATUS_ABORTED) break;
4751 if (data.devices_status == STATUS_QUIT) break;
4752 if (data.devices_status == STATUS_BYPASS) break;
4753
4754 //
4755 // flush
4756 //
4757
4758 const uint pws_cnt = device_param->pws_cnt;
4759
4760 if (pws_cnt)
4761 {
4762 run_copy (device_param, pws_cnt);
4763
4764 run_cracker (device_param, pws_cnt);
4765
4766 device_param->pws_cnt = 0;
4767
4768 if (attack_kern == ATTACK_KERN_STRAIGHT)
4769 {
4770 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4771 }
4772 else if (attack_kern == ATTACK_KERN_COMBI)
4773 {
4774 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4775 }
4776 }
4777
4778 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4779
4780 if (data.devices_status == STATUS_CRACKED) break;
4781 if (data.devices_status == STATUS_ABORTED) break;
4782 if (data.devices_status == STATUS_QUIT) break;
4783 if (data.devices_status == STATUS_BYPASS) break;
4784
4785 if (words_fin == 0) break;
4786
4787 device_param->words_done = words_fin;
4788 }
4789
4790 if (attack_mode == ATTACK_MODE_COMBI)
4791 {
4792 fclose (device_param->combs_fp);
4793 }
4794
4795 free (wl_data->buf);
4796 free (wl_data);
4797
4798 fclose (fd);
4799 }
4800
4801 device_param->kernel_accel = 0;
4802 device_param->kernel_loops = 0;
4803
4804 return NULL;
4805 }
4806
4807 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4808 {
4809 if (!device_param)
4810 {
4811 log_error ("ERROR: %s : Invalid argument", __func__);
4812
4813 exit (-1);
4814 }
4815
4816 salt_t *salt_buf = &data.salts_buf[salt_pos];
4817
4818 device_param->kernel_params_buf32[24] = salt_pos;
4819 device_param->kernel_params_buf32[27] = 1;
4820 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4821 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4822 device_param->kernel_params_buf32[30] = 0;
4823 device_param->kernel_params_buf32[31] = 1;
4824
4825 char *dictfile_old = data.dictfile;
4826
4827 const char *weak_hash_check = "weak-hash-check";
4828
4829 data.dictfile = (char *) weak_hash_check;
4830
4831 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4832
4833 data.kernel_rules_buf[0].cmds[0] = 0;
4834
4835 /**
4836 * run the kernel
4837 */
4838
4839 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4840 {
4841 run_kernel (KERN_RUN_1, device_param, 1, false);
4842 }
4843 else
4844 {
4845 run_kernel (KERN_RUN_1, device_param, 1, false);
4846
4847 uint loop_step = 16;
4848
4849 const uint iter = salt_buf->salt_iter;
4850
4851 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4852 {
4853 uint loop_left = iter - loop_pos;
4854
4855 loop_left = MIN (loop_left, loop_step);
4856
4857 device_param->kernel_params_buf32[25] = loop_pos;
4858 device_param->kernel_params_buf32[26] = loop_left;
4859
4860 run_kernel (KERN_RUN_2, device_param, 1, false);
4861 }
4862
4863 run_kernel (KERN_RUN_3, device_param, 1, false);
4864 }
4865
4866 /**
4867 * result
4868 */
4869
4870 check_cracked (device_param, salt_pos);
4871
4872 /**
4873 * cleanup
4874 */
4875
4876 device_param->kernel_params_buf32[24] = 0;
4877 device_param->kernel_params_buf32[25] = 0;
4878 device_param->kernel_params_buf32[26] = 0;
4879 device_param->kernel_params_buf32[27] = 0;
4880 device_param->kernel_params_buf32[28] = 0;
4881 device_param->kernel_params_buf32[29] = 0;
4882 device_param->kernel_params_buf32[30] = 0;
4883 device_param->kernel_params_buf32[31] = 0;
4884
4885 data.dictfile = dictfile_old;
4886
4887 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4888 }
4889
4890 // hlfmt hashcat
4891
4892 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4893 {
4894 if (data.username == 0)
4895 {
4896 *hashbuf_pos = line_buf;
4897 *hashbuf_len = line_len;
4898 }
4899 else
4900 {
4901 char *pos = line_buf;
4902 int len = line_len;
4903
4904 for (int i = 0; i < line_len; i++, pos++, len--)
4905 {
4906 if (line_buf[i] == data.separator)
4907 {
4908 pos++;
4909
4910 len--;
4911
4912 break;
4913 }
4914 }
4915
4916 *hashbuf_pos = pos;
4917 *hashbuf_len = len;
4918 }
4919 }
4920
4921 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4922 {
4923 char *pos = NULL;
4924 int len = 0;
4925
4926 int sep_cnt = 0;
4927
4928 for (int i = 0; i < line_len; i++)
4929 {
4930 if (line_buf[i] == data.separator)
4931 {
4932 sep_cnt++;
4933
4934 continue;
4935 }
4936
4937 if (sep_cnt == 0)
4938 {
4939 if (pos == NULL) pos = line_buf + i;
4940
4941 len++;
4942 }
4943 }
4944
4945 *userbuf_pos = pos;
4946 *userbuf_len = len;
4947 }
4948
4949 // hlfmt pwdump
4950
4951 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4952 {
4953 int sep_cnt = 0;
4954
4955 int sep2_len = 0;
4956 int sep3_len = 0;
4957
4958 for (int i = 0; i < line_len; i++)
4959 {
4960 if (line_buf[i] == ':')
4961 {
4962 sep_cnt++;
4963
4964 continue;
4965 }
4966
4967 if (sep_cnt == 2) sep2_len++;
4968 if (sep_cnt == 3) sep3_len++;
4969 }
4970
4971 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4972
4973 return 0;
4974 }
4975
4976 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4977 {
4978 char *pos = NULL;
4979 int len = 0;
4980
4981 int sep_cnt = 0;
4982
4983 for (int i = 0; i < line_len; i++)
4984 {
4985 if (line_buf[i] == ':')
4986 {
4987 sep_cnt++;
4988
4989 continue;
4990 }
4991
4992 if (data.hash_mode == 1000)
4993 {
4994 if (sep_cnt == 3)
4995 {
4996 if (pos == NULL) pos = line_buf + i;
4997
4998 len++;
4999 }
5000 }
5001 else if (data.hash_mode == 3000)
5002 {
5003 if (sep_cnt == 2)
5004 {
5005 if (pos == NULL) pos = line_buf + i;
5006
5007 len++;
5008 }
5009 }
5010 }
5011
5012 *hashbuf_pos = pos;
5013 *hashbuf_len = len;
5014 }
5015
5016 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5017 {
5018 char *pos = NULL;
5019 int len = 0;
5020
5021 int sep_cnt = 0;
5022
5023 for (int i = 0; i < line_len; i++)
5024 {
5025 if (line_buf[i] == ':')
5026 {
5027 sep_cnt++;
5028
5029 continue;
5030 }
5031
5032 if (sep_cnt == 0)
5033 {
5034 if (pos == NULL) pos = line_buf + i;
5035
5036 len++;
5037 }
5038 }
5039
5040 *userbuf_pos = pos;
5041 *userbuf_len = len;
5042 }
5043
5044 // hlfmt passwd
5045
5046 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
5047 {
5048 int sep_cnt = 0;
5049
5050 char sep5_first = 0;
5051 char sep6_first = 0;
5052
5053 for (int i = 0; i < line_len; i++)
5054 {
5055 if (line_buf[i] == ':')
5056 {
5057 sep_cnt++;
5058
5059 continue;
5060 }
5061
5062 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5063 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5064 }
5065
5066 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5067
5068 return 0;
5069 }
5070
5071 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5072 {
5073 char *pos = NULL;
5074 int len = 0;
5075
5076 int sep_cnt = 0;
5077
5078 for (int i = 0; i < line_len; i++)
5079 {
5080 if (line_buf[i] == ':')
5081 {
5082 sep_cnt++;
5083
5084 continue;
5085 }
5086
5087 if (sep_cnt == 1)
5088 {
5089 if (pos == NULL) pos = line_buf + i;
5090
5091 len++;
5092 }
5093 }
5094
5095 *hashbuf_pos = pos;
5096 *hashbuf_len = len;
5097 }
5098
5099 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5100 {
5101 char *pos = NULL;
5102 int len = 0;
5103
5104 int sep_cnt = 0;
5105
5106 for (int i = 0; i < line_len; i++)
5107 {
5108 if (line_buf[i] == ':')
5109 {
5110 sep_cnt++;
5111
5112 continue;
5113 }
5114
5115 if (sep_cnt == 0)
5116 {
5117 if (pos == NULL) pos = line_buf + i;
5118
5119 len++;
5120 }
5121 }
5122
5123 *userbuf_pos = pos;
5124 *userbuf_len = len;
5125 }
5126
5127 // hlfmt shadow
5128
5129 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
5130 {
5131 int sep_cnt = 0;
5132
5133 for (int i = 0; i < line_len; i++)
5134 {
5135 if (line_buf[i] == ':') sep_cnt++;
5136 }
5137
5138 if (sep_cnt == 8) return 1;
5139
5140 return 0;
5141 }
5142
5143 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5144 {
5145 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5146 }
5147
5148 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5149 {
5150 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5151 }
5152
5153 // hlfmt main
5154
5155 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5156 {
5157 switch (hashfile_format)
5158 {
5159 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5160 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5161 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5162 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5163 }
5164 }
5165
5166 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5167 {
5168 switch (hashfile_format)
5169 {
5170 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5171 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5172 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5173 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5174 }
5175 }
5176
5177 static uint hlfmt_detect (FILE *fp, uint max_check)
5178 {
5179 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5180
5181 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5182 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5183
5184 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5185
5186 uint num_check = 0;
5187
5188 while (!feof (fp))
5189 {
5190 char line_buf[BUFSIZ] = { 0 };
5191
5192 int line_len = fgetl (fp, line_buf);
5193
5194 if (line_len == 0) continue;
5195
5196 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5197 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5198 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5199
5200 if (num_check == max_check) break;
5201
5202 num_check++;
5203 }
5204
5205 uint hashlist_format = HLFMT_HASHCAT;
5206
5207 for (int i = 1; i < HLFMTS_CNT; i++)
5208 {
5209 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5210
5211 hashlist_format = i;
5212 }
5213
5214 free (formats_cnt);
5215
5216 return hashlist_format;
5217 }
5218
5219 /**
5220 * some further helper function
5221 */
5222
5223 // wrapper around mymalloc for ADL
5224
5225 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5226 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5227 {
5228 return mymalloc (iSize);
5229 }
5230 #endif
5231
5232 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)
5233 {
5234 u64 collisions = 0;
5235
5236 const uint dgst_pos0 = data.dgst_pos0;
5237 const uint dgst_pos1 = data.dgst_pos1;
5238 const uint dgst_pos2 = data.dgst_pos2;
5239 const uint dgst_pos3 = data.dgst_pos3;
5240
5241 memset (bitmap_a, 0, bitmap_size);
5242 memset (bitmap_b, 0, bitmap_size);
5243 memset (bitmap_c, 0, bitmap_size);
5244 memset (bitmap_d, 0, bitmap_size);
5245
5246 for (uint i = 0; i < digests_cnt; i++)
5247 {
5248 uint *digest_ptr = (uint *) digests_buf_ptr;
5249
5250 digests_buf_ptr += dgst_size;
5251
5252 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5253 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5254 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5255 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5256
5257 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5258 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5259 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5260 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5261
5262 if (bitmap_a[idx0] & val0) collisions++;
5263 if (bitmap_b[idx1] & val1) collisions++;
5264 if (bitmap_c[idx2] & val2) collisions++;
5265 if (bitmap_d[idx3] & val3) collisions++;
5266
5267 bitmap_a[idx0] |= val0;
5268 bitmap_b[idx1] |= val1;
5269 bitmap_c[idx2] |= val2;
5270 bitmap_d[idx3] |= val3;
5271
5272 if (collisions >= collisions_max) return 0x7fffffff;
5273 }
5274
5275 return collisions;
5276 }
5277
5278 /**
5279 * main
5280 */
5281
5282 int main (int argc, char **argv)
5283 {
5284 /**
5285 * To help users a bit
5286 */
5287
5288 char *compute = getenv ("COMPUTE");
5289
5290 if (compute)
5291 {
5292 static char display[100];
5293
5294 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5295
5296 putenv (display);
5297 }
5298 else
5299 {
5300 if (getenv ("DISPLAY") == NULL)
5301 putenv ((char *) "DISPLAY=:0");
5302 }
5303
5304 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5305 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5306
5307 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5308 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5309
5310 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5311 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5312
5313 /**
5314 * Real init
5315 */
5316
5317 memset (&data, 0, sizeof (hc_global_data_t));
5318
5319 time_t proc_start;
5320
5321 time (&proc_start);
5322
5323 data.proc_start = proc_start;
5324
5325 int myargc = argc;
5326 char **myargv = argv;
5327
5328 hc_thread_mutex_init (mux_dispatcher);
5329 hc_thread_mutex_init (mux_counter);
5330 hc_thread_mutex_init (mux_display);
5331 hc_thread_mutex_init (mux_adl);
5332
5333 /**
5334 * commandline parameters
5335 */
5336
5337 uint usage = USAGE;
5338 uint version = VERSION;
5339 uint quiet = QUIET;
5340 uint benchmark = BENCHMARK;
5341 uint benchmark_repeats = BENCHMARK_REPEATS;
5342 uint show = SHOW;
5343 uint left = LEFT;
5344 uint username = USERNAME;
5345 uint remove = REMOVE;
5346 uint remove_timer = REMOVE_TIMER;
5347 u64 skip = SKIP;
5348 u64 limit = LIMIT;
5349 uint keyspace = KEYSPACE;
5350 uint potfile_disable = POTFILE_DISABLE;
5351 uint debug_mode = DEBUG_MODE;
5352 char *debug_file = NULL;
5353 char *induction_dir = NULL;
5354 char *outfile_check_dir = NULL;
5355 uint force = FORCE;
5356 uint runtime = RUNTIME;
5357 uint hash_mode = HASH_MODE;
5358 uint attack_mode = ATTACK_MODE;
5359 uint markov_disable = MARKOV_DISABLE;
5360 uint markov_classic = MARKOV_CLASSIC;
5361 uint markov_threshold = MARKOV_THRESHOLD;
5362 char *markov_hcstat = NULL;
5363 char *outfile = NULL;
5364 uint outfile_format = OUTFILE_FORMAT;
5365 uint outfile_autohex = OUTFILE_AUTOHEX;
5366 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5367 uint restore = RESTORE;
5368 uint restore_timer = RESTORE_TIMER;
5369 uint restore_disable = RESTORE_DISABLE;
5370 uint status = STATUS;
5371 uint status_timer = STATUS_TIMER;
5372 uint status_automat = STATUS_AUTOMAT;
5373 uint loopback = LOOPBACK;
5374 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5375 char *session = NULL;
5376 uint hex_charset = HEX_CHARSET;
5377 uint hex_salt = HEX_SALT;
5378 uint hex_wordlist = HEX_WORDLIST;
5379 uint rp_gen = RP_GEN;
5380 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5381 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5382 uint rp_gen_seed = RP_GEN_SEED;
5383 char *rule_buf_l = (char *) RULE_BUF_L;
5384 char *rule_buf_r = (char *) RULE_BUF_R;
5385 uint increment = INCREMENT;
5386 uint increment_min = INCREMENT_MIN;
5387 uint increment_max = INCREMENT_MAX;
5388 char *cpu_affinity = NULL;
5389 OCL_PTR *ocl = NULL;
5390 char *opencl_devices = NULL;
5391 char *opencl_platforms = NULL;
5392 char *opencl_device_types = NULL;
5393 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5394 char *truecrypt_keyfiles = NULL;
5395 uint workload_profile = WORKLOAD_PROFILE;
5396 uint kernel_accel = KERNEL_ACCEL;
5397 uint kernel_loops = KERNEL_LOOPS;
5398 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5399 #ifdef HAVE_HWMON
5400 uint gpu_temp_abort = GPU_TEMP_ABORT;
5401 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5402 #ifdef HAVE_ADL
5403 uint powertune_enable = POWERTUNE_ENABLE;
5404 #endif
5405 #endif
5406 uint logfile_disable = LOGFILE_DISABLE;
5407 uint segment_size = SEGMENT_SIZE;
5408 uint scrypt_tmto = SCRYPT_TMTO;
5409 char separator = SEPARATOR;
5410 uint bitmap_min = BITMAP_MIN;
5411 uint bitmap_max = BITMAP_MAX;
5412 char *custom_charset_1 = NULL;
5413 char *custom_charset_2 = NULL;
5414 char *custom_charset_3 = NULL;
5415 char *custom_charset_4 = NULL;
5416
5417 #define IDX_HELP 'h'
5418 #define IDX_VERSION 'V'
5419 #define IDX_VERSION_LOWER 'v'
5420 #define IDX_QUIET 0xff02
5421 #define IDX_SHOW 0xff03
5422 #define IDX_LEFT 0xff04
5423 #define IDX_REMOVE 0xff05
5424 #define IDX_REMOVE_TIMER 0xff37
5425 #define IDX_SKIP 's'
5426 #define IDX_LIMIT 'l'
5427 #define IDX_KEYSPACE 0xff35
5428 #define IDX_POTFILE_DISABLE 0xff06
5429 #define IDX_DEBUG_MODE 0xff43
5430 #define IDX_DEBUG_FILE 0xff44
5431 #define IDX_INDUCTION_DIR 0xff46
5432 #define IDX_OUTFILE_CHECK_DIR 0xff47
5433 #define IDX_USERNAME 0xff07
5434 #define IDX_FORCE 0xff08
5435 #define IDX_RUNTIME 0xff09
5436 #define IDX_BENCHMARK 'b'
5437 #define IDX_BENCHMARK_REPEATS 0xff78
5438 #define IDX_HASH_MODE 'm'
5439 #define IDX_ATTACK_MODE 'a'
5440 #define IDX_RP_FILE 'r'
5441 #define IDX_RP_GEN 'g'
5442 #define IDX_RP_GEN_FUNC_MIN 0xff10
5443 #define IDX_RP_GEN_FUNC_MAX 0xff11
5444 #define IDX_RP_GEN_SEED 0xff34
5445 #define IDX_RULE_BUF_L 'j'
5446 #define IDX_RULE_BUF_R 'k'
5447 #define IDX_INCREMENT 'i'
5448 #define IDX_INCREMENT_MIN 0xff12
5449 #define IDX_INCREMENT_MAX 0xff13
5450 #define IDX_OUTFILE 'o'
5451 #define IDX_OUTFILE_FORMAT 0xff14
5452 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5453 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5454 #define IDX_RESTORE 0xff15
5455 #define IDX_RESTORE_DISABLE 0xff27
5456 #define IDX_STATUS 0xff17
5457 #define IDX_STATUS_TIMER 0xff18
5458 #define IDX_STATUS_AUTOMAT 0xff50
5459 #define IDX_LOOPBACK 0xff38
5460 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5461 #define IDX_SESSION 0xff19
5462 #define IDX_HEX_CHARSET 0xff20
5463 #define IDX_HEX_SALT 0xff21
5464 #define IDX_HEX_WORDLIST 0xff40
5465 #define IDX_MARKOV_DISABLE 0xff22
5466 #define IDX_MARKOV_CLASSIC 0xff23
5467 #define IDX_MARKOV_THRESHOLD 't'
5468 #define IDX_MARKOV_HCSTAT 0xff24
5469 #define IDX_CPU_AFFINITY 0xff25
5470 #define IDX_OPENCL_DEVICES 'd'
5471 #define IDX_OPENCL_PLATFORMS 0xff72
5472 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5473 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5474 #define IDX_WORKLOAD_PROFILE 'w'
5475 #define IDX_KERNEL_ACCEL 'n'
5476 #define IDX_KERNEL_LOOPS 'u'
5477 #define IDX_GPU_TEMP_DISABLE 0xff29
5478 #define IDX_GPU_TEMP_ABORT 0xff30
5479 #define IDX_GPU_TEMP_RETAIN 0xff31
5480 #define IDX_POWERTUNE_ENABLE 0xff41
5481 #define IDX_LOGFILE_DISABLE 0xff51
5482 #define IDX_TRUECRYPT_KEYFILES 0xff52
5483 #define IDX_SCRYPT_TMTO 0xff61
5484 #define IDX_SEGMENT_SIZE 'c'
5485 #define IDX_SEPARATOR 'p'
5486 #define IDX_BITMAP_MIN 0xff70
5487 #define IDX_BITMAP_MAX 0xff71
5488 #define IDX_CUSTOM_CHARSET_1 '1'
5489 #define IDX_CUSTOM_CHARSET_2 '2'
5490 #define IDX_CUSTOM_CHARSET_3 '3'
5491 #define IDX_CUSTOM_CHARSET_4 '4'
5492
5493 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5494
5495 struct option long_options[] =
5496 {
5497 {"help", no_argument, 0, IDX_HELP},
5498 {"version", no_argument, 0, IDX_VERSION},
5499 {"quiet", no_argument, 0, IDX_QUIET},
5500 {"show", no_argument, 0, IDX_SHOW},
5501 {"left", no_argument, 0, IDX_LEFT},
5502 {"username", no_argument, 0, IDX_USERNAME},
5503 {"remove", no_argument, 0, IDX_REMOVE},
5504 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5505 {"skip", required_argument, 0, IDX_SKIP},
5506 {"limit", required_argument, 0, IDX_LIMIT},
5507 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5508 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5509 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5510 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5511 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5512 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5513 {"force", no_argument, 0, IDX_FORCE},
5514 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5515 {"benchmark-repeats", required_argument, 0, IDX_BENCHMARK_REPEATS},
5516 {"restore", no_argument, 0, IDX_RESTORE},
5517 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5518 {"status", no_argument, 0, IDX_STATUS},
5519 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5520 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5521 {"loopback", no_argument, 0, IDX_LOOPBACK},
5522 {"weak-hash-threshold",
5523 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5524 {"session", required_argument, 0, IDX_SESSION},
5525 {"runtime", required_argument, 0, IDX_RUNTIME},
5526 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5527 {"generate-rules-func-min",
5528 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5529 {"generate-rules-func-max",
5530 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5531 {"generate-rules-seed",
5532 required_argument, 0, IDX_RP_GEN_SEED},
5533 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5534 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5535 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5536 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5537 {"rules-file", required_argument, 0, IDX_RP_FILE},
5538 {"outfile", required_argument, 0, IDX_OUTFILE},
5539 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5540 {"outfile-autohex-disable",
5541 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5542 {"outfile-check-timer",
5543 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5544 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5545 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5546 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5547 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5548 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5549 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5550 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5551 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5552 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5553 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5554 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5555 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5556 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5557 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5558 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5559 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5560 #ifdef HAVE_HWMON
5561 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5562 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5563 #ifdef HAVE_ADL
5564 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5565 #endif
5566 #endif // HAVE_HWMON
5567 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5568 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5569 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5570 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5571 // deprecated
5572 {"seperator", required_argument, 0, IDX_SEPARATOR},
5573 {"separator", required_argument, 0, IDX_SEPARATOR},
5574 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5575 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5576 {"increment", no_argument, 0, IDX_INCREMENT},
5577 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5578 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5579 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5580 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5581 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5582 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5583
5584 {0, 0, 0, 0}
5585 };
5586
5587 uint rp_files_cnt = 0;
5588
5589 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5590
5591 int option_index = 0;
5592 int c = -1;
5593
5594 optind = 1;
5595 optopt = 0;
5596
5597 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5598 {
5599 switch (c)
5600 {
5601 case IDX_HELP: usage = 1; break;
5602 case IDX_VERSION:
5603 case IDX_VERSION_LOWER: version = 1; break;
5604 case IDX_RESTORE: restore = 1; break;
5605 case IDX_SESSION: session = optarg; break;
5606 case IDX_SHOW: show = 1; break;
5607 case IDX_LEFT: left = 1; break;
5608 case '?': return (-1);
5609 }
5610 }
5611
5612 if (optopt != 0)
5613 {
5614 log_error ("ERROR: Invalid argument specified");
5615
5616 return (-1);
5617 }
5618
5619 /**
5620 * exit functions
5621 */
5622
5623 if (version)
5624 {
5625 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5626
5627 return (0);
5628 }
5629
5630 if (usage)
5631 {
5632 usage_big_print (PROGNAME);
5633
5634 return (0);
5635 }
5636
5637 /**
5638 * session needs to be set, always!
5639 */
5640
5641 if (session == NULL) session = (char *) PROGNAME;
5642
5643 /**
5644 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5645 */
5646
5647 char *exec_path = get_exec_path ();
5648
5649 #ifdef LINUX
5650
5651 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5652 char *resolved_exec_path = realpath (exec_path, NULL);
5653
5654 char *install_dir = get_install_dir (resolved_exec_path);
5655 char *profile_dir = NULL;
5656 char *session_dir = NULL;
5657 char *shared_dir = NULL;
5658
5659 if (strcmp (install_dir, resolved_install_folder) == 0)
5660 {
5661 struct passwd *pw = getpwuid (getuid ());
5662
5663 const char *homedir = pw->pw_dir;
5664
5665 profile_dir = get_profile_dir (homedir);
5666 session_dir = get_session_dir (profile_dir);
5667 shared_dir = strdup (SHARED_FOLDER);
5668
5669 mkdir (profile_dir, 0700);
5670 mkdir (session_dir, 0700);
5671 }
5672 else
5673 {
5674 profile_dir = install_dir;
5675 session_dir = install_dir;
5676 shared_dir = install_dir;
5677 }
5678
5679 myfree (resolved_install_folder);
5680 myfree (resolved_exec_path);
5681
5682 #else
5683
5684 char *install_dir = get_install_dir (exec_path);
5685 char *profile_dir = install_dir;
5686 char *session_dir = install_dir;
5687 char *shared_dir = install_dir;
5688
5689 #endif
5690
5691 data.install_dir = install_dir;
5692 data.profile_dir = profile_dir;
5693 data.session_dir = session_dir;
5694 data.shared_dir = shared_dir;
5695
5696 myfree (exec_path);
5697
5698 /**
5699 * kernel cache, we need to make sure folder exist
5700 */
5701
5702 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5703
5704 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5705
5706 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5707
5708 mkdir (kernels_folder, 0700);
5709
5710 myfree (kernels_folder);
5711
5712 /**
5713 * session
5714 */
5715
5716 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5717
5718 data.session = session;
5719
5720 char *eff_restore_file = (char *) mymalloc (session_size);
5721 char *new_restore_file = (char *) mymalloc (session_size);
5722
5723 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5724 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5725
5726 data.eff_restore_file = eff_restore_file;
5727 data.new_restore_file = new_restore_file;
5728
5729 if (((show == 1) || (left == 1)) && (restore == 1))
5730 {
5731 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5732 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5733
5734 return (-1);
5735 }
5736
5737 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5738 if ((show == 1) || (left == 1))
5739 {
5740 restore_disable = 1;
5741
5742 restore = 0;
5743 }
5744
5745 data.restore_disable = restore_disable;
5746
5747 restore_data_t *rd = init_restore (argc, argv);
5748
5749 data.rd = rd;
5750
5751 /**
5752 * restore file
5753 */
5754
5755 if (restore == 1)
5756 {
5757 read_restore (eff_restore_file, rd);
5758
5759 if (rd->version_bin < RESTORE_MIN)
5760 {
5761 log_error ("ERROR: Incompatible restore-file version");
5762
5763 return (-1);
5764 }
5765
5766 myargc = rd->argc;
5767 myargv = rd->argv;
5768
5769 #ifdef _POSIX
5770 rd->pid = getpid ();
5771 #elif _WIN
5772 rd->pid = GetCurrentProcessId ();
5773 #endif
5774 }
5775
5776 uint hash_mode_chgd = 0;
5777 uint runtime_chgd = 0;
5778 uint kernel_loops_chgd = 0;
5779 uint kernel_accel_chgd = 0;
5780 uint attack_mode_chgd = 0;
5781 uint outfile_format_chgd = 0;
5782 uint rp_gen_seed_chgd = 0;
5783 uint remove_timer_chgd = 0;
5784 uint increment_min_chgd = 0;
5785 uint increment_max_chgd = 0;
5786 uint workload_profile_chgd = 0;
5787 uint opencl_vector_width_chgd = 0;
5788
5789 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5790 uint gpu_temp_retain_chgd = 0;
5791 uint gpu_temp_abort_chgd = 0;
5792 #endif
5793
5794 optind = 1;
5795 optopt = 0;
5796 option_index = 0;
5797
5798 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5799 {
5800 switch (c)
5801 {
5802 //case IDX_HELP: usage = 1; break;
5803 //case IDX_VERSION: version = 1; break;
5804 //case IDX_RESTORE: restore = 1; break;
5805 case IDX_QUIET: quiet = 1; break;
5806 //case IDX_SHOW: show = 1; break;
5807 case IDX_SHOW: break;
5808 //case IDX_LEFT: left = 1; break;
5809 case IDX_LEFT: break;
5810 case IDX_USERNAME: username = 1; break;
5811 case IDX_REMOVE: remove = 1; break;
5812 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5813 remove_timer_chgd = 1; break;
5814 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5815 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5816 case IDX_DEBUG_FILE: debug_file = optarg; break;
5817 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5818 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5819 case IDX_FORCE: force = 1; break;
5820 case IDX_SKIP: skip = atoll (optarg); break;
5821 case IDX_LIMIT: limit = atoll (optarg); break;
5822 case IDX_KEYSPACE: keyspace = 1; break;
5823 case IDX_BENCHMARK: benchmark = 1; break;
5824 case IDX_BENCHMARK_REPEATS: benchmark_repeats = atoi (optarg); break;
5825 case IDX_RESTORE: break;
5826 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5827 case IDX_STATUS: status = 1; break;
5828 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5829 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5830 case IDX_LOOPBACK: loopback = 1; break;
5831 case IDX_WEAK_HASH_THRESHOLD:
5832 weak_hash_threshold = atoi (optarg); break;
5833 //case IDX_SESSION: session = optarg; break;
5834 case IDX_SESSION: break;
5835 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5836 hash_mode_chgd = 1; break;
5837 case IDX_RUNTIME: runtime = atoi (optarg);
5838 runtime_chgd = 1; break;
5839 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5840 attack_mode_chgd = 1; break;
5841 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5842 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5843 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5844 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5845 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5846 rp_gen_seed_chgd = 1; break;
5847 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5848 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5849 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5850 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5851 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5852 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5853 case IDX_OUTFILE: outfile = optarg; break;
5854 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5855 outfile_format_chgd = 1; break;
5856 case IDX_OUTFILE_AUTOHEX_DISABLE:
5857 outfile_autohex = 0; break;
5858 case IDX_OUTFILE_CHECK_TIMER:
5859 outfile_check_timer = atoi (optarg); break;
5860 case IDX_HEX_CHARSET: hex_charset = 1; break;
5861 case IDX_HEX_SALT: hex_salt = 1; break;
5862 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5863 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5864 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5865 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5866 case IDX_OPENCL_DEVICE_TYPES:
5867 opencl_device_types = optarg; break;
5868 case IDX_OPENCL_VECTOR_WIDTH:
5869 opencl_vector_width = atoi (optarg);
5870 opencl_vector_width_chgd = 1; break;
5871 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5872 workload_profile_chgd = 1; break;
5873 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5874 kernel_accel_chgd = 1; break;
5875 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5876 kernel_loops_chgd = 1; break;
5877 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5878 #ifdef HAVE_HWMON
5879 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5880 #ifdef HAVE_ADL
5881 gpu_temp_abort_chgd = 1;
5882 #endif
5883 break;
5884 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5885 #ifdef HAVE_ADL
5886 gpu_temp_retain_chgd = 1;
5887 #endif
5888 break;
5889 #ifdef HAVE_ADL
5890 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5891 #endif
5892 #endif // HAVE_HWMON
5893 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5894 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5895 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5896 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5897 case IDX_SEPARATOR: separator = optarg[0]; break;
5898 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5899 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5900 case IDX_INCREMENT: increment = 1; break;
5901 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5902 increment_min_chgd = 1; break;
5903 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5904 increment_max_chgd = 1; break;
5905 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5906 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5907 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5908 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5909
5910 default:
5911 log_error ("ERROR: Invalid argument specified");
5912 return (-1);
5913 }
5914 }
5915
5916 if (optopt != 0)
5917 {
5918 log_error ("ERROR: Invalid argument specified");
5919
5920 return (-1);
5921 }
5922
5923 /**
5924 * Inform user things getting started,
5925 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5926 * - we do not need to check algorithm_pos
5927 */
5928
5929 if (quiet == 0)
5930 {
5931 if (benchmark == 1)
5932 {
5933 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5934
5935 log_info ("");
5936 }
5937 else if (restore == 1)
5938 {
5939 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5940
5941 log_info ("");
5942 }
5943 else
5944 {
5945 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5946
5947 log_info ("");
5948 }
5949 }
5950
5951 /**
5952 * sanity check
5953 */
5954
5955 if (attack_mode > 7)
5956 {
5957 log_error ("ERROR: Invalid attack-mode specified");
5958
5959 return (-1);
5960 }
5961
5962 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5963 {
5964 log_error ("ERROR: Invalid runtime specified");
5965
5966 return (-1);
5967 }
5968
5969 if (hash_mode_chgd && hash_mode > 13100) // just added to remove compiler warnings for hash_mode_chgd
5970 {
5971 log_error ("ERROR: Invalid hash-type specified");
5972
5973 return (-1);
5974 }
5975
5976 // renamed hash modes
5977
5978 if (hash_mode_chgd)
5979 {
5980 int n = -1;
5981
5982 switch (hash_mode)
5983 {
5984 case 123: n = 124;
5985 break;
5986 }
5987
5988 if (n >= 0)
5989 {
5990 log_error ("Old -m specified, use -m %d instead", n);
5991
5992 return (-1);
5993 }
5994 }
5995
5996 if (username == 1)
5997 {
5998 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5999 {
6000 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6001
6002 return (-1);
6003 }
6004 }
6005
6006 if (outfile_format > 16)
6007 {
6008 log_error ("ERROR: Invalid outfile-format specified");
6009
6010 return (-1);
6011 }
6012
6013 if (left == 1)
6014 {
6015 if (outfile_format_chgd == 1)
6016 {
6017 if (outfile_format > 1)
6018 {
6019 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6020
6021 return (-1);
6022 }
6023 }
6024 else
6025 {
6026 outfile_format = OUTFILE_FMT_HASH;
6027 }
6028 }
6029
6030 if (show == 1)
6031 {
6032 if (outfile_format_chgd == 1)
6033 {
6034 if ((outfile_format > 7) && (outfile_format < 16))
6035 {
6036 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6037
6038 return (-1);
6039 }
6040 }
6041 }
6042
6043 if (increment_min < INCREMENT_MIN)
6044 {
6045 log_error ("ERROR: Invalid increment-min specified");
6046
6047 return (-1);
6048 }
6049
6050 if (increment_max > INCREMENT_MAX)
6051 {
6052 log_error ("ERROR: Invalid increment-max specified");
6053
6054 return (-1);
6055 }
6056
6057 if (increment_min > increment_max)
6058 {
6059 log_error ("ERROR: Invalid increment-min specified");
6060
6061 return (-1);
6062 }
6063
6064 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6065 {
6066 log_error ("ERROR: increment is not allowed in attack-mode 0");
6067
6068 return (-1);
6069 }
6070
6071 if ((increment == 0) && (increment_min_chgd == 1))
6072 {
6073 log_error ("ERROR: increment-min is only supported together with increment switch");
6074
6075 return (-1);
6076 }
6077
6078 if ((increment == 0) && (increment_max_chgd == 1))
6079 {
6080 log_error ("ERROR: increment-max is only supported together with increment switch");
6081
6082 return (-1);
6083 }
6084
6085 if (rp_files_cnt && rp_gen)
6086 {
6087 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6088
6089 return (-1);
6090 }
6091
6092 if (rp_files_cnt || rp_gen)
6093 {
6094 if (attack_mode != ATTACK_MODE_STRAIGHT)
6095 {
6096 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6097
6098 return (-1);
6099 }
6100 }
6101
6102 if (rp_gen_func_min > rp_gen_func_max)
6103 {
6104 log_error ("ERROR: Invalid rp-gen-func-min specified");
6105
6106 return (-1);
6107 }
6108
6109 if (kernel_accel_chgd == 1)
6110 {
6111 if (kernel_accel < 1)
6112 {
6113 log_error ("ERROR: Invalid kernel-accel specified");
6114
6115 return (-1);
6116 }
6117
6118 if (kernel_accel > 1024)
6119 {
6120 log_error ("ERROR: Invalid kernel-accel specified");
6121
6122 return (-1);
6123 }
6124 }
6125
6126 if (kernel_loops_chgd == 1)
6127 {
6128 if (kernel_loops < 1)
6129 {
6130 log_error ("ERROR: Invalid kernel-loops specified");
6131
6132 return (-1);
6133 }
6134
6135 if (kernel_loops > 1024)
6136 {
6137 log_error ("ERROR: Invalid kernel-loops specified");
6138
6139 return (-1);
6140 }
6141 }
6142
6143 if ((workload_profile < 1) || (workload_profile > 3))
6144 {
6145 log_error ("ERROR: workload-profile %i not available", workload_profile);
6146
6147 return (-1);
6148 }
6149
6150 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6151 {
6152 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6153
6154 return (-1);
6155 }
6156
6157 if (show == 1 || left == 1)
6158 {
6159 attack_mode = ATTACK_MODE_NONE;
6160
6161 if (remove == 1)
6162 {
6163 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6164
6165 return (-1);
6166 }
6167
6168 if (potfile_disable == 1)
6169 {
6170 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6171
6172 return (-1);
6173 }
6174 }
6175
6176 uint attack_kern = ATTACK_KERN_NONE;
6177
6178 switch (attack_mode)
6179 {
6180 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6181 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6182 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6183 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6184 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6185 }
6186
6187 if (benchmark == 0)
6188 {
6189 if (keyspace == 1)
6190 {
6191 int num_additional_params = 1;
6192
6193 if (attack_kern == ATTACK_KERN_COMBI)
6194 {
6195 num_additional_params = 2;
6196 }
6197
6198 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6199
6200 if (keyspace_wordlist_specified == 0) optind--;
6201 }
6202
6203 if (attack_kern == ATTACK_KERN_NONE)
6204 {
6205 if ((optind + 1) != myargc)
6206 {
6207 usage_mini_print (myargv[0]);
6208
6209 return (-1);
6210 }
6211 }
6212 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6213 {
6214 if ((optind + 1) > myargc)
6215 {
6216 usage_mini_print (myargv[0]);
6217
6218 return (-1);
6219 }
6220 }
6221 else if (attack_kern == ATTACK_KERN_COMBI)
6222 {
6223 if ((optind + 3) != myargc)
6224 {
6225 usage_mini_print (myargv[0]);
6226
6227 return (-1);
6228 }
6229 }
6230 else if (attack_kern == ATTACK_KERN_BF)
6231 {
6232 if ((optind + 1) > myargc)
6233 {
6234 usage_mini_print (myargv[0]);
6235
6236 return (-1);
6237 }
6238 }
6239 else
6240 {
6241 usage_mini_print (myargv[0]);
6242
6243 return (-1);
6244 }
6245 }
6246 else
6247 {
6248 if (myargv[optind] != 0)
6249 {
6250 log_error ("ERROR: Invalid argument for benchmark mode specified");
6251
6252 return (-1);
6253 }
6254
6255 if (attack_mode_chgd == 1)
6256 {
6257 if (attack_mode != ATTACK_MODE_BF)
6258 {
6259 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6260
6261 return (-1);
6262 }
6263 }
6264 }
6265
6266 if (skip != 0 && limit != 0)
6267 {
6268 limit += skip;
6269 }
6270
6271 if (keyspace == 1)
6272 {
6273 if (show == 1)
6274 {
6275 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6276
6277 return (-1);
6278 }
6279 else if (left == 1)
6280 {
6281 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6282
6283 return (-1);
6284 }
6285
6286 potfile_disable = 1;
6287
6288 restore_disable = 1;
6289
6290 restore = 0;
6291
6292 weak_hash_threshold = 0;
6293
6294 quiet = 1;
6295 }
6296
6297 if (remove_timer_chgd == 1)
6298 {
6299 if (remove == 0)
6300 {
6301 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6302
6303 return (-1);
6304 }
6305
6306 if (remove_timer < 1)
6307 {
6308 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6309
6310 return (-1);
6311 }
6312 }
6313
6314 if (loopback == 1)
6315 {
6316 if (attack_mode == ATTACK_MODE_BF)
6317 {
6318 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6319
6320 return (-1);
6321 }
6322 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6323 {
6324 if ((rp_files_cnt == 0) && (rp_gen == 0))
6325 {
6326 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6327
6328 return (-1);
6329 }
6330 }
6331 }
6332
6333 if (debug_mode > 0)
6334 {
6335 if (attack_mode != ATTACK_MODE_STRAIGHT)
6336 {
6337 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6338
6339 return (-1);
6340 }
6341
6342 if ((rp_files_cnt == 0) && (rp_gen == 0))
6343 {
6344 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6345
6346 return (-1);
6347 }
6348 }
6349
6350 if (debug_mode > 4)
6351 {
6352 log_error ("ERROR: Invalid debug-mode specified");
6353
6354 return (-1);
6355 }
6356
6357 if (debug_file != NULL)
6358 {
6359 if (debug_mode < 1)
6360 {
6361 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6362
6363 return (-1);
6364 }
6365 }
6366
6367 if (induction_dir != NULL)
6368 {
6369 if (attack_mode == ATTACK_MODE_BF)
6370 {
6371 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6372
6373 return (-1);
6374 }
6375 }
6376
6377 if (attack_mode != ATTACK_MODE_STRAIGHT)
6378 {
6379 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6380 {
6381 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6382
6383 return (-1);
6384 }
6385
6386 weak_hash_threshold = 0;
6387 }
6388
6389 /**
6390 * induction directory
6391 */
6392
6393 char *induction_directory = NULL;
6394
6395 if (attack_mode != ATTACK_MODE_BF)
6396 {
6397 if (induction_dir == NULL)
6398 {
6399 induction_directory = (char *) mymalloc (session_size);
6400
6401 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6402
6403 // create induction folder if it does not already exist
6404
6405 if (keyspace == 0)
6406 {
6407 if (rmdir (induction_directory) == -1)
6408 {
6409 if (errno == ENOENT)
6410 {
6411 // good, we can ignore
6412 }
6413 else if (errno == ENOTEMPTY)
6414 {
6415 char *induction_directory_mv = (char *) mymalloc (session_size);
6416
6417 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6418
6419 if (rename (induction_directory, induction_directory_mv) != 0)
6420 {
6421 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6422
6423 return (-1);
6424 }
6425 }
6426 else
6427 {
6428 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6429
6430 return (-1);
6431 }
6432 }
6433
6434 if (mkdir (induction_directory, 0700) == -1)
6435 {
6436 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6437
6438 return (-1);
6439 }
6440 }
6441 }
6442 else
6443 {
6444 induction_directory = induction_dir;
6445 }
6446 }
6447
6448 data.induction_directory = induction_directory;
6449
6450 /**
6451 * loopback
6452 */
6453
6454 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6455
6456 char *loopback_file = (char *) mymalloc (loopback_size);
6457
6458 /**
6459 * tuning db
6460 */
6461
6462 char tuning_db_file[256] = { 0 };
6463
6464 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6465
6466 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6467
6468 /**
6469 * outfile-check directory
6470 */
6471
6472 char *outfile_check_directory = NULL;
6473
6474 if (outfile_check_dir == NULL)
6475 {
6476 outfile_check_directory = (char *) mymalloc (session_size);
6477
6478 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6479 }
6480 else
6481 {
6482 outfile_check_directory = outfile_check_dir;
6483 }
6484
6485 data.outfile_check_directory = outfile_check_directory;
6486
6487 if (keyspace == 0)
6488 {
6489 struct stat outfile_check_stat;
6490
6491 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6492 {
6493 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6494
6495 if (is_dir == 0)
6496 {
6497 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6498
6499 return (-1);
6500 }
6501 }
6502 else if (outfile_check_dir == NULL)
6503 {
6504 if (mkdir (outfile_check_directory, 0700) == -1)
6505 {
6506 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6507
6508 return (-1);
6509 }
6510 }
6511 }
6512
6513 /**
6514 * special other stuff
6515 */
6516
6517 if (hash_mode == 9710)
6518 {
6519 outfile_format = 5;
6520 outfile_format_chgd = 1;
6521 }
6522
6523 if (hash_mode == 9810)
6524 {
6525 outfile_format = 5;
6526 outfile_format_chgd = 1;
6527 }
6528
6529 if (hash_mode == 10410)
6530 {
6531 outfile_format = 5;
6532 outfile_format_chgd = 1;
6533 }
6534
6535 /**
6536 * store stuff
6537 */
6538
6539 data.hash_mode = hash_mode;
6540 data.restore = restore;
6541 data.restore_timer = restore_timer;
6542 data.restore_disable = restore_disable;
6543 data.status = status;
6544 data.status_timer = status_timer;
6545 data.status_automat = status_automat;
6546 data.loopback = loopback;
6547 data.runtime = runtime;
6548 data.remove = remove;
6549 data.remove_timer = remove_timer;
6550 data.debug_mode = debug_mode;
6551 data.debug_file = debug_file;
6552 data.username = username;
6553 data.quiet = quiet;
6554 data.outfile = outfile;
6555 data.outfile_format = outfile_format;
6556 data.outfile_autohex = outfile_autohex;
6557 data.hex_charset = hex_charset;
6558 data.hex_salt = hex_salt;
6559 data.hex_wordlist = hex_wordlist;
6560 data.separator = separator;
6561 data.rp_files = rp_files;
6562 data.rp_files_cnt = rp_files_cnt;
6563 data.rp_gen = rp_gen;
6564 data.rp_gen_seed = rp_gen_seed;
6565 data.force = force;
6566 data.benchmark = benchmark;
6567 data.benchmark_repeats = benchmark_repeats;
6568 data.skip = skip;
6569 data.limit = limit;
6570 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6571 data.powertune_enable = powertune_enable;
6572 #endif
6573 data.logfile_disable = logfile_disable;
6574 data.truecrypt_keyfiles = truecrypt_keyfiles;
6575 data.scrypt_tmto = scrypt_tmto;
6576 data.workload_profile = workload_profile;
6577
6578 /**
6579 * cpu affinity
6580 */
6581
6582 if (cpu_affinity)
6583 {
6584 set_cpu_affinity (cpu_affinity);
6585 }
6586
6587 if (rp_gen_seed_chgd == 0)
6588 {
6589 srand (proc_start);
6590 }
6591 else
6592 {
6593 srand (rp_gen_seed);
6594 }
6595
6596 /**
6597 * logfile init
6598 */
6599
6600 if (logfile_disable == 0)
6601 {
6602 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6603
6604 char *logfile = (char *) mymalloc (logfile_size);
6605
6606 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6607
6608 data.logfile = logfile;
6609
6610 char *topid = logfile_generate_topid ();
6611
6612 data.topid = topid;
6613 }
6614
6615 // logfile_append() checks for logfile_disable internally to make it easier from here
6616
6617 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6618 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6619 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6620 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6621 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6622 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6623 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6624 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6625 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6626 #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));
6627
6628 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6629 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6630 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6631 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6632 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6633 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6634 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6635 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6636
6637 logfile_top_msg ("START");
6638
6639 logfile_top_uint (attack_mode);
6640 logfile_top_uint (attack_kern);
6641 logfile_top_uint (benchmark);
6642 logfile_top_uint (benchmark_repeats);
6643 logfile_top_uint (bitmap_min);
6644 logfile_top_uint (bitmap_max);
6645 logfile_top_uint (debug_mode);
6646 logfile_top_uint (force);
6647 logfile_top_uint (kernel_accel);
6648 logfile_top_uint (kernel_loops);
6649 logfile_top_uint (gpu_temp_disable);
6650 #ifdef HAVE_HWMON
6651 logfile_top_uint (gpu_temp_abort);
6652 logfile_top_uint (gpu_temp_retain);
6653 #endif
6654 logfile_top_uint (hash_mode);
6655 logfile_top_uint (hex_charset);
6656 logfile_top_uint (hex_salt);
6657 logfile_top_uint (hex_wordlist);
6658 logfile_top_uint (increment);
6659 logfile_top_uint (increment_max);
6660 logfile_top_uint (increment_min);
6661 logfile_top_uint (keyspace);
6662 logfile_top_uint (left);
6663 logfile_top_uint (logfile_disable);
6664 logfile_top_uint (loopback);
6665 logfile_top_uint (markov_classic);
6666 logfile_top_uint (markov_disable);
6667 logfile_top_uint (markov_threshold);
6668 logfile_top_uint (outfile_autohex);
6669 logfile_top_uint (outfile_check_timer);
6670 logfile_top_uint (outfile_format);
6671 logfile_top_uint (potfile_disable);
6672 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6673 logfile_top_uint (powertune_enable);
6674 #endif
6675 logfile_top_uint (scrypt_tmto);
6676 logfile_top_uint (quiet);
6677 logfile_top_uint (remove);
6678 logfile_top_uint (remove_timer);
6679 logfile_top_uint (restore);
6680 logfile_top_uint (restore_disable);
6681 logfile_top_uint (restore_timer);
6682 logfile_top_uint (rp_gen);
6683 logfile_top_uint (rp_gen_func_max);
6684 logfile_top_uint (rp_gen_func_min);
6685 logfile_top_uint (rp_gen_seed);
6686 logfile_top_uint (runtime);
6687 logfile_top_uint (segment_size);
6688 logfile_top_uint (show);
6689 logfile_top_uint (status);
6690 logfile_top_uint (status_automat);
6691 logfile_top_uint (status_timer);
6692 logfile_top_uint (usage);
6693 logfile_top_uint (username);
6694 logfile_top_uint (version);
6695 logfile_top_uint (weak_hash_threshold);
6696 logfile_top_uint (workload_profile);
6697 logfile_top_uint64 (limit);
6698 logfile_top_uint64 (skip);
6699 logfile_top_char (separator);
6700 logfile_top_string (cpu_affinity);
6701 logfile_top_string (custom_charset_1);
6702 logfile_top_string (custom_charset_2);
6703 logfile_top_string (custom_charset_3);
6704 logfile_top_string (custom_charset_4);
6705 logfile_top_string (debug_file);
6706 logfile_top_string (opencl_devices);
6707 logfile_top_string (opencl_platforms);
6708 logfile_top_string (opencl_device_types);
6709 logfile_top_uint (opencl_vector_width);
6710 logfile_top_string (induction_dir);
6711 logfile_top_string (markov_hcstat);
6712 logfile_top_string (outfile);
6713 logfile_top_string (outfile_check_dir);
6714 logfile_top_string (rule_buf_l);
6715 logfile_top_string (rule_buf_r);
6716 logfile_top_string (session);
6717 logfile_top_string (truecrypt_keyfiles);
6718
6719 /**
6720 * Init OpenCL library loader
6721 */
6722
6723 if (keyspace == 0)
6724 {
6725 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6726
6727 ocl_init (ocl);
6728
6729 data.ocl = ocl;
6730 }
6731
6732 /**
6733 * OpenCL platform selection
6734 */
6735
6736 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6737
6738 /**
6739 * OpenCL device selection
6740 */
6741
6742 u32 devices_filter = setup_devices_filter (opencl_devices);
6743
6744 /**
6745 * OpenCL device type selection
6746 */
6747
6748 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6749
6750 /**
6751 * benchmark
6752 */
6753
6754 if (benchmark == 1)
6755 {
6756 /**
6757 * disable useless stuff for benchmark
6758 */
6759
6760 status_timer = 0;
6761 restore_timer = 0;
6762 restore_disable = 1;
6763 potfile_disable = 1;
6764 weak_hash_threshold = 0;
6765 gpu_temp_disable = 1;
6766
6767 data.status_timer = status_timer;
6768 data.restore_timer = restore_timer;
6769 data.restore_disable = restore_disable;
6770
6771 /**
6772 * force attack mode to be bruteforce
6773 */
6774
6775 attack_mode = ATTACK_MODE_BF;
6776 attack_kern = ATTACK_KERN_BF;
6777
6778 if (workload_profile_chgd == 0)
6779 {
6780 workload_profile = 3;
6781
6782 data.workload_profile = workload_profile;
6783 }
6784 }
6785
6786 /**
6787 * config
6788 */
6789
6790 uint hash_type = 0;
6791 uint salt_type = 0;
6792 uint attack_exec = 0;
6793 uint opts_type = 0;
6794 uint kern_type = 0;
6795 uint dgst_size = 0;
6796 uint esalt_size = 0;
6797 uint opti_type = 0;
6798 uint dgst_pos0 = -1;
6799 uint dgst_pos1 = -1;
6800 uint dgst_pos2 = -1;
6801 uint dgst_pos3 = -1;
6802
6803 int (*parse_func) (char *, uint, hash_t *);
6804 int (*sort_by_digest) (const void *, const void *);
6805
6806 uint algorithm_pos = 0;
6807 uint algorithm_max = 1;
6808
6809 uint *algorithms = default_benchmark_algorithms;
6810
6811 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6812
6813 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6814 {
6815 /*
6816 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6817 * the following algos are skipped entirely
6818 */
6819
6820 if (algorithm_pos > 0)
6821 {
6822 local_free (rd);
6823
6824 rd = init_restore (argc, argv);
6825
6826 data.rd = rd;
6827 }
6828
6829 /**
6830 * update hash_mode in case of multihash benchmark
6831 */
6832
6833 if (benchmark == 1)
6834 {
6835 if (hash_mode_chgd == 0)
6836 {
6837 hash_mode = algorithms[algorithm_pos];
6838
6839 data.hash_mode = hash_mode;
6840 }
6841
6842 quiet = 1;
6843
6844 data.quiet = quiet;
6845 }
6846
6847 switch (hash_mode)
6848 {
6849 case 0: hash_type = HASH_TYPE_MD5;
6850 salt_type = SALT_TYPE_NONE;
6851 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6852 opts_type = OPTS_TYPE_PT_GENERATE_LE
6853 | OPTS_TYPE_PT_ADD80
6854 | OPTS_TYPE_PT_ADDBITS14;
6855 kern_type = KERN_TYPE_MD5;
6856 dgst_size = DGST_SIZE_4_4;
6857 parse_func = md5_parse_hash;
6858 sort_by_digest = sort_by_digest_4_4;
6859 opti_type = OPTI_TYPE_ZERO_BYTE
6860 | OPTI_TYPE_PRECOMPUTE_INIT
6861 | OPTI_TYPE_PRECOMPUTE_MERKLE
6862 | OPTI_TYPE_MEET_IN_MIDDLE
6863 | OPTI_TYPE_EARLY_SKIP
6864 | OPTI_TYPE_NOT_ITERATED
6865 | OPTI_TYPE_NOT_SALTED
6866 | OPTI_TYPE_RAW_HASH;
6867 dgst_pos0 = 0;
6868 dgst_pos1 = 3;
6869 dgst_pos2 = 2;
6870 dgst_pos3 = 1;
6871 break;
6872
6873 case 10: hash_type = HASH_TYPE_MD5;
6874 salt_type = SALT_TYPE_INTERN;
6875 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6876 opts_type = OPTS_TYPE_PT_GENERATE_LE
6877 | OPTS_TYPE_ST_ADD80
6878 | OPTS_TYPE_ST_ADDBITS14;
6879 kern_type = KERN_TYPE_MD5_PWSLT;
6880 dgst_size = DGST_SIZE_4_4;
6881 parse_func = md5s_parse_hash;
6882 sort_by_digest = sort_by_digest_4_4;
6883 opti_type = OPTI_TYPE_ZERO_BYTE
6884 | OPTI_TYPE_PRECOMPUTE_INIT
6885 | OPTI_TYPE_PRECOMPUTE_MERKLE
6886 | OPTI_TYPE_MEET_IN_MIDDLE
6887 | OPTI_TYPE_EARLY_SKIP
6888 | OPTI_TYPE_NOT_ITERATED
6889 | OPTI_TYPE_APPENDED_SALT
6890 | OPTI_TYPE_RAW_HASH;
6891 dgst_pos0 = 0;
6892 dgst_pos1 = 3;
6893 dgst_pos2 = 2;
6894 dgst_pos3 = 1;
6895 break;
6896
6897 case 11: hash_type = HASH_TYPE_MD5;
6898 salt_type = SALT_TYPE_INTERN;
6899 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6900 opts_type = OPTS_TYPE_PT_GENERATE_LE
6901 | OPTS_TYPE_ST_ADD80
6902 | OPTS_TYPE_ST_ADDBITS14;
6903 kern_type = KERN_TYPE_MD5_PWSLT;
6904 dgst_size = DGST_SIZE_4_4;
6905 parse_func = joomla_parse_hash;
6906 sort_by_digest = sort_by_digest_4_4;
6907 opti_type = OPTI_TYPE_ZERO_BYTE
6908 | OPTI_TYPE_PRECOMPUTE_INIT
6909 | OPTI_TYPE_PRECOMPUTE_MERKLE
6910 | OPTI_TYPE_MEET_IN_MIDDLE
6911 | OPTI_TYPE_EARLY_SKIP
6912 | OPTI_TYPE_NOT_ITERATED
6913 | OPTI_TYPE_APPENDED_SALT
6914 | OPTI_TYPE_RAW_HASH;
6915 dgst_pos0 = 0;
6916 dgst_pos1 = 3;
6917 dgst_pos2 = 2;
6918 dgst_pos3 = 1;
6919 break;
6920
6921 case 12: hash_type = HASH_TYPE_MD5;
6922 salt_type = SALT_TYPE_INTERN;
6923 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6924 opts_type = OPTS_TYPE_PT_GENERATE_LE
6925 | OPTS_TYPE_ST_ADD80
6926 | OPTS_TYPE_ST_ADDBITS14;
6927 kern_type = KERN_TYPE_MD5_PWSLT;
6928 dgst_size = DGST_SIZE_4_4;
6929 parse_func = postgresql_parse_hash;
6930 sort_by_digest = sort_by_digest_4_4;
6931 opti_type = OPTI_TYPE_ZERO_BYTE
6932 | OPTI_TYPE_PRECOMPUTE_INIT
6933 | OPTI_TYPE_PRECOMPUTE_MERKLE
6934 | OPTI_TYPE_MEET_IN_MIDDLE
6935 | OPTI_TYPE_EARLY_SKIP
6936 | OPTI_TYPE_NOT_ITERATED
6937 | OPTI_TYPE_APPENDED_SALT
6938 | OPTI_TYPE_RAW_HASH;
6939 dgst_pos0 = 0;
6940 dgst_pos1 = 3;
6941 dgst_pos2 = 2;
6942 dgst_pos3 = 1;
6943 break;
6944
6945 case 20: hash_type = HASH_TYPE_MD5;
6946 salt_type = SALT_TYPE_INTERN;
6947 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6948 opts_type = OPTS_TYPE_PT_GENERATE_LE
6949 | OPTS_TYPE_PT_ADD80
6950 | OPTS_TYPE_PT_ADDBITS14;
6951 kern_type = KERN_TYPE_MD5_SLTPW;
6952 dgst_size = DGST_SIZE_4_4;
6953 parse_func = md5s_parse_hash;
6954 sort_by_digest = sort_by_digest_4_4;
6955 opti_type = OPTI_TYPE_ZERO_BYTE
6956 | OPTI_TYPE_PRECOMPUTE_INIT
6957 | OPTI_TYPE_PRECOMPUTE_MERKLE
6958 | OPTI_TYPE_EARLY_SKIP
6959 | OPTI_TYPE_NOT_ITERATED
6960 | OPTI_TYPE_PREPENDED_SALT
6961 | OPTI_TYPE_RAW_HASH;
6962 dgst_pos0 = 0;
6963 dgst_pos1 = 3;
6964 dgst_pos2 = 2;
6965 dgst_pos3 = 1;
6966 break;
6967
6968 case 21: hash_type = HASH_TYPE_MD5;
6969 salt_type = SALT_TYPE_INTERN;
6970 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6971 opts_type = OPTS_TYPE_PT_GENERATE_LE
6972 | OPTS_TYPE_PT_ADD80
6973 | OPTS_TYPE_PT_ADDBITS14;
6974 kern_type = KERN_TYPE_MD5_SLTPW;
6975 dgst_size = DGST_SIZE_4_4;
6976 parse_func = osc_parse_hash;
6977 sort_by_digest = sort_by_digest_4_4;
6978 opti_type = OPTI_TYPE_ZERO_BYTE
6979 | OPTI_TYPE_PRECOMPUTE_INIT
6980 | OPTI_TYPE_PRECOMPUTE_MERKLE
6981 | OPTI_TYPE_EARLY_SKIP
6982 | OPTI_TYPE_NOT_ITERATED
6983 | OPTI_TYPE_PREPENDED_SALT
6984 | OPTI_TYPE_RAW_HASH;
6985 dgst_pos0 = 0;
6986 dgst_pos1 = 3;
6987 dgst_pos2 = 2;
6988 dgst_pos3 = 1;
6989 break;
6990
6991 case 22: hash_type = HASH_TYPE_MD5;
6992 salt_type = SALT_TYPE_EMBEDDED;
6993 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6994 opts_type = OPTS_TYPE_PT_GENERATE_LE
6995 | OPTS_TYPE_PT_ADD80
6996 | OPTS_TYPE_PT_ADDBITS14;
6997 kern_type = KERN_TYPE_MD5_SLTPW;
6998 dgst_size = DGST_SIZE_4_4;
6999 parse_func = netscreen_parse_hash;
7000 sort_by_digest = sort_by_digest_4_4;
7001 opti_type = OPTI_TYPE_ZERO_BYTE
7002 | OPTI_TYPE_PRECOMPUTE_INIT
7003 | OPTI_TYPE_PRECOMPUTE_MERKLE
7004 | OPTI_TYPE_EARLY_SKIP
7005 | OPTI_TYPE_NOT_ITERATED
7006 | OPTI_TYPE_PREPENDED_SALT
7007 | OPTI_TYPE_RAW_HASH;
7008 dgst_pos0 = 0;
7009 dgst_pos1 = 3;
7010 dgst_pos2 = 2;
7011 dgst_pos3 = 1;
7012 break;
7013
7014 case 23: hash_type = HASH_TYPE_MD5;
7015 salt_type = SALT_TYPE_EMBEDDED;
7016 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7017 opts_type = OPTS_TYPE_PT_GENERATE_LE
7018 | OPTS_TYPE_PT_ADD80
7019 | OPTS_TYPE_PT_ADDBITS14;
7020 kern_type = KERN_TYPE_MD5_SLTPW;
7021 dgst_size = DGST_SIZE_4_4;
7022 parse_func = skype_parse_hash;
7023 sort_by_digest = sort_by_digest_4_4;
7024 opti_type = OPTI_TYPE_ZERO_BYTE
7025 | OPTI_TYPE_PRECOMPUTE_INIT
7026 | OPTI_TYPE_PRECOMPUTE_MERKLE
7027 | OPTI_TYPE_EARLY_SKIP
7028 | OPTI_TYPE_NOT_ITERATED
7029 | OPTI_TYPE_PREPENDED_SALT
7030 | OPTI_TYPE_RAW_HASH;
7031 dgst_pos0 = 0;
7032 dgst_pos1 = 3;
7033 dgst_pos2 = 2;
7034 dgst_pos3 = 1;
7035 break;
7036
7037 case 30: hash_type = HASH_TYPE_MD5;
7038 salt_type = SALT_TYPE_INTERN;
7039 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7040 opts_type = OPTS_TYPE_PT_GENERATE_LE
7041 | OPTS_TYPE_PT_UNICODE
7042 | OPTS_TYPE_ST_ADD80
7043 | OPTS_TYPE_ST_ADDBITS14;
7044 kern_type = KERN_TYPE_MD5_PWUSLT;
7045 dgst_size = DGST_SIZE_4_4;
7046 parse_func = md5s_parse_hash;
7047 sort_by_digest = sort_by_digest_4_4;
7048 opti_type = OPTI_TYPE_ZERO_BYTE
7049 | OPTI_TYPE_PRECOMPUTE_INIT
7050 | OPTI_TYPE_PRECOMPUTE_MERKLE
7051 | OPTI_TYPE_MEET_IN_MIDDLE
7052 | OPTI_TYPE_EARLY_SKIP
7053 | OPTI_TYPE_NOT_ITERATED
7054 | OPTI_TYPE_APPENDED_SALT
7055 | OPTI_TYPE_RAW_HASH;
7056 dgst_pos0 = 0;
7057 dgst_pos1 = 3;
7058 dgst_pos2 = 2;
7059 dgst_pos3 = 1;
7060 break;
7061
7062 case 40: hash_type = HASH_TYPE_MD5;
7063 salt_type = SALT_TYPE_INTERN;
7064 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7065 opts_type = OPTS_TYPE_PT_GENERATE_LE
7066 | OPTS_TYPE_PT_ADD80
7067 | OPTS_TYPE_PT_ADDBITS14
7068 | OPTS_TYPE_PT_UNICODE;
7069 kern_type = KERN_TYPE_MD5_SLTPWU;
7070 dgst_size = DGST_SIZE_4_4;
7071 parse_func = md5s_parse_hash;
7072 sort_by_digest = sort_by_digest_4_4;
7073 opti_type = OPTI_TYPE_ZERO_BYTE
7074 | OPTI_TYPE_PRECOMPUTE_INIT
7075 | OPTI_TYPE_PRECOMPUTE_MERKLE
7076 | OPTI_TYPE_EARLY_SKIP
7077 | OPTI_TYPE_NOT_ITERATED
7078 | OPTI_TYPE_PREPENDED_SALT
7079 | OPTI_TYPE_RAW_HASH;
7080 dgst_pos0 = 0;
7081 dgst_pos1 = 3;
7082 dgst_pos2 = 2;
7083 dgst_pos3 = 1;
7084 break;
7085
7086 case 50: hash_type = HASH_TYPE_MD5;
7087 salt_type = SALT_TYPE_INTERN;
7088 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7089 opts_type = OPTS_TYPE_PT_GENERATE_LE
7090 | OPTS_TYPE_ST_ADD80
7091 | OPTS_TYPE_ST_ADDBITS14;
7092 kern_type = KERN_TYPE_HMACMD5_PW;
7093 dgst_size = DGST_SIZE_4_4;
7094 parse_func = hmacmd5_parse_hash;
7095 sort_by_digest = sort_by_digest_4_4;
7096 opti_type = OPTI_TYPE_ZERO_BYTE
7097 | OPTI_TYPE_NOT_ITERATED;
7098 dgst_pos0 = 0;
7099 dgst_pos1 = 3;
7100 dgst_pos2 = 2;
7101 dgst_pos3 = 1;
7102 break;
7103
7104 case 60: hash_type = HASH_TYPE_MD5;
7105 salt_type = SALT_TYPE_INTERN;
7106 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7107 opts_type = OPTS_TYPE_PT_GENERATE_LE
7108 | OPTS_TYPE_PT_ADD80
7109 | OPTS_TYPE_PT_ADDBITS14;
7110 kern_type = KERN_TYPE_HMACMD5_SLT;
7111 dgst_size = DGST_SIZE_4_4;
7112 parse_func = hmacmd5_parse_hash;
7113 sort_by_digest = sort_by_digest_4_4;
7114 opti_type = OPTI_TYPE_ZERO_BYTE
7115 | OPTI_TYPE_NOT_ITERATED;
7116 dgst_pos0 = 0;
7117 dgst_pos1 = 3;
7118 dgst_pos2 = 2;
7119 dgst_pos3 = 1;
7120 break;
7121
7122 case 100: hash_type = HASH_TYPE_SHA1;
7123 salt_type = SALT_TYPE_NONE;
7124 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7125 opts_type = OPTS_TYPE_PT_GENERATE_BE
7126 | OPTS_TYPE_PT_ADD80
7127 | OPTS_TYPE_PT_ADDBITS15;
7128 kern_type = KERN_TYPE_SHA1;
7129 dgst_size = DGST_SIZE_4_5;
7130 parse_func = sha1_parse_hash;
7131 sort_by_digest = sort_by_digest_4_5;
7132 opti_type = OPTI_TYPE_ZERO_BYTE
7133 | OPTI_TYPE_PRECOMPUTE_INIT
7134 | OPTI_TYPE_PRECOMPUTE_MERKLE
7135 | OPTI_TYPE_EARLY_SKIP
7136 | OPTI_TYPE_NOT_ITERATED
7137 | OPTI_TYPE_NOT_SALTED
7138 | OPTI_TYPE_RAW_HASH;
7139 dgst_pos0 = 3;
7140 dgst_pos1 = 4;
7141 dgst_pos2 = 2;
7142 dgst_pos3 = 1;
7143 break;
7144
7145 case 101: hash_type = HASH_TYPE_SHA1;
7146 salt_type = SALT_TYPE_NONE;
7147 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7148 opts_type = OPTS_TYPE_PT_GENERATE_BE
7149 | OPTS_TYPE_PT_ADD80
7150 | OPTS_TYPE_PT_ADDBITS15;
7151 kern_type = KERN_TYPE_SHA1;
7152 dgst_size = DGST_SIZE_4_5;
7153 parse_func = sha1b64_parse_hash;
7154 sort_by_digest = sort_by_digest_4_5;
7155 opti_type = OPTI_TYPE_ZERO_BYTE
7156 | OPTI_TYPE_PRECOMPUTE_INIT
7157 | OPTI_TYPE_PRECOMPUTE_MERKLE
7158 | OPTI_TYPE_EARLY_SKIP
7159 | OPTI_TYPE_NOT_ITERATED
7160 | OPTI_TYPE_NOT_SALTED
7161 | OPTI_TYPE_RAW_HASH;
7162 dgst_pos0 = 3;
7163 dgst_pos1 = 4;
7164 dgst_pos2 = 2;
7165 dgst_pos3 = 1;
7166 break;
7167
7168 case 110: hash_type = HASH_TYPE_SHA1;
7169 salt_type = SALT_TYPE_INTERN;
7170 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7171 opts_type = OPTS_TYPE_PT_GENERATE_BE
7172 | OPTS_TYPE_ST_ADD80
7173 | OPTS_TYPE_ST_ADDBITS15;
7174 kern_type = KERN_TYPE_SHA1_PWSLT;
7175 dgst_size = DGST_SIZE_4_5;
7176 parse_func = sha1s_parse_hash;
7177 sort_by_digest = sort_by_digest_4_5;
7178 opti_type = OPTI_TYPE_ZERO_BYTE
7179 | OPTI_TYPE_PRECOMPUTE_INIT
7180 | OPTI_TYPE_PRECOMPUTE_MERKLE
7181 | OPTI_TYPE_EARLY_SKIP
7182 | OPTI_TYPE_NOT_ITERATED
7183 | OPTI_TYPE_APPENDED_SALT
7184 | OPTI_TYPE_RAW_HASH;
7185 dgst_pos0 = 3;
7186 dgst_pos1 = 4;
7187 dgst_pos2 = 2;
7188 dgst_pos3 = 1;
7189 break;
7190
7191 case 111: hash_type = HASH_TYPE_SHA1;
7192 salt_type = SALT_TYPE_EMBEDDED;
7193 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7194 opts_type = OPTS_TYPE_PT_GENERATE_BE
7195 | OPTS_TYPE_ST_ADD80
7196 | OPTS_TYPE_ST_ADDBITS15;
7197 kern_type = KERN_TYPE_SHA1_PWSLT;
7198 dgst_size = DGST_SIZE_4_5;
7199 parse_func = sha1b64s_parse_hash;
7200 sort_by_digest = sort_by_digest_4_5;
7201 opti_type = OPTI_TYPE_ZERO_BYTE
7202 | OPTI_TYPE_PRECOMPUTE_INIT
7203 | OPTI_TYPE_PRECOMPUTE_MERKLE
7204 | OPTI_TYPE_EARLY_SKIP
7205 | OPTI_TYPE_NOT_ITERATED
7206 | OPTI_TYPE_APPENDED_SALT
7207 | OPTI_TYPE_RAW_HASH;
7208 dgst_pos0 = 3;
7209 dgst_pos1 = 4;
7210 dgst_pos2 = 2;
7211 dgst_pos3 = 1;
7212 break;
7213
7214 case 112: hash_type = HASH_TYPE_SHA1;
7215 salt_type = SALT_TYPE_INTERN;
7216 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7217 opts_type = OPTS_TYPE_PT_GENERATE_BE
7218 | OPTS_TYPE_ST_ADD80
7219 | OPTS_TYPE_ST_ADDBITS15
7220 | OPTS_TYPE_ST_HEX;
7221 kern_type = KERN_TYPE_SHA1_PWSLT;
7222 dgst_size = DGST_SIZE_4_5;
7223 parse_func = oracles_parse_hash;
7224 sort_by_digest = sort_by_digest_4_5;
7225 opti_type = OPTI_TYPE_ZERO_BYTE
7226 | OPTI_TYPE_PRECOMPUTE_INIT
7227 | OPTI_TYPE_PRECOMPUTE_MERKLE
7228 | OPTI_TYPE_EARLY_SKIP
7229 | OPTI_TYPE_NOT_ITERATED
7230 | OPTI_TYPE_APPENDED_SALT
7231 | OPTI_TYPE_RAW_HASH;
7232 dgst_pos0 = 3;
7233 dgst_pos1 = 4;
7234 dgst_pos2 = 2;
7235 dgst_pos3 = 1;
7236 break;
7237
7238 case 120: hash_type = HASH_TYPE_SHA1;
7239 salt_type = SALT_TYPE_INTERN;
7240 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7241 opts_type = OPTS_TYPE_PT_GENERATE_BE
7242 | OPTS_TYPE_PT_ADD80
7243 | OPTS_TYPE_PT_ADDBITS15;
7244 kern_type = KERN_TYPE_SHA1_SLTPW;
7245 dgst_size = DGST_SIZE_4_5;
7246 parse_func = sha1s_parse_hash;
7247 sort_by_digest = sort_by_digest_4_5;
7248 opti_type = OPTI_TYPE_ZERO_BYTE
7249 | OPTI_TYPE_PRECOMPUTE_INIT
7250 | OPTI_TYPE_PRECOMPUTE_MERKLE
7251 | OPTI_TYPE_EARLY_SKIP
7252 | OPTI_TYPE_NOT_ITERATED
7253 | OPTI_TYPE_PREPENDED_SALT
7254 | OPTI_TYPE_RAW_HASH;
7255 dgst_pos0 = 3;
7256 dgst_pos1 = 4;
7257 dgst_pos2 = 2;
7258 dgst_pos3 = 1;
7259 break;
7260
7261 case 121: hash_type = HASH_TYPE_SHA1;
7262 salt_type = SALT_TYPE_INTERN;
7263 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7264 opts_type = OPTS_TYPE_PT_GENERATE_BE
7265 | OPTS_TYPE_PT_ADD80
7266 | OPTS_TYPE_PT_ADDBITS15
7267 | OPTS_TYPE_ST_LOWER;
7268 kern_type = KERN_TYPE_SHA1_SLTPW;
7269 dgst_size = DGST_SIZE_4_5;
7270 parse_func = smf_parse_hash;
7271 sort_by_digest = sort_by_digest_4_5;
7272 opti_type = OPTI_TYPE_ZERO_BYTE
7273 | OPTI_TYPE_PRECOMPUTE_INIT
7274 | OPTI_TYPE_PRECOMPUTE_MERKLE
7275 | OPTI_TYPE_EARLY_SKIP
7276 | OPTI_TYPE_NOT_ITERATED
7277 | OPTI_TYPE_PREPENDED_SALT
7278 | OPTI_TYPE_RAW_HASH;
7279 dgst_pos0 = 3;
7280 dgst_pos1 = 4;
7281 dgst_pos2 = 2;
7282 dgst_pos3 = 1;
7283 break;
7284
7285 case 122: hash_type = HASH_TYPE_SHA1;
7286 salt_type = SALT_TYPE_EMBEDDED;
7287 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7288 opts_type = OPTS_TYPE_PT_GENERATE_BE
7289 | OPTS_TYPE_PT_ADD80
7290 | OPTS_TYPE_PT_ADDBITS15
7291 | OPTS_TYPE_ST_HEX;
7292 kern_type = KERN_TYPE_SHA1_SLTPW;
7293 dgst_size = DGST_SIZE_4_5;
7294 parse_func = osx1_parse_hash;
7295 sort_by_digest = sort_by_digest_4_5;
7296 opti_type = OPTI_TYPE_ZERO_BYTE
7297 | OPTI_TYPE_PRECOMPUTE_INIT
7298 | OPTI_TYPE_PRECOMPUTE_MERKLE
7299 | OPTI_TYPE_EARLY_SKIP
7300 | OPTI_TYPE_NOT_ITERATED
7301 | OPTI_TYPE_PREPENDED_SALT
7302 | OPTI_TYPE_RAW_HASH;
7303 dgst_pos0 = 3;
7304 dgst_pos1 = 4;
7305 dgst_pos2 = 2;
7306 dgst_pos3 = 1;
7307 break;
7308
7309 case 124: hash_type = HASH_TYPE_SHA1;
7310 salt_type = SALT_TYPE_EMBEDDED;
7311 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7312 opts_type = OPTS_TYPE_PT_GENERATE_BE
7313 | OPTS_TYPE_PT_ADD80
7314 | OPTS_TYPE_PT_ADDBITS15;
7315 kern_type = KERN_TYPE_SHA1_SLTPW;
7316 dgst_size = DGST_SIZE_4_5;
7317 parse_func = djangosha1_parse_hash;
7318 sort_by_digest = sort_by_digest_4_5;
7319 opti_type = OPTI_TYPE_ZERO_BYTE
7320 | OPTI_TYPE_PRECOMPUTE_INIT
7321 | OPTI_TYPE_PRECOMPUTE_MERKLE
7322 | OPTI_TYPE_EARLY_SKIP
7323 | OPTI_TYPE_NOT_ITERATED
7324 | OPTI_TYPE_PREPENDED_SALT
7325 | OPTI_TYPE_RAW_HASH;
7326 dgst_pos0 = 3;
7327 dgst_pos1 = 4;
7328 dgst_pos2 = 2;
7329 dgst_pos3 = 1;
7330 break;
7331
7332 case 130: hash_type = HASH_TYPE_SHA1;
7333 salt_type = SALT_TYPE_INTERN;
7334 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7335 opts_type = OPTS_TYPE_PT_GENERATE_BE
7336 | OPTS_TYPE_PT_UNICODE
7337 | OPTS_TYPE_ST_ADD80
7338 | OPTS_TYPE_ST_ADDBITS15;
7339 kern_type = KERN_TYPE_SHA1_PWUSLT;
7340 dgst_size = DGST_SIZE_4_5;
7341 parse_func = sha1s_parse_hash;
7342 sort_by_digest = sort_by_digest_4_5;
7343 opti_type = OPTI_TYPE_ZERO_BYTE
7344 | OPTI_TYPE_PRECOMPUTE_INIT
7345 | OPTI_TYPE_PRECOMPUTE_MERKLE
7346 | OPTI_TYPE_EARLY_SKIP
7347 | OPTI_TYPE_NOT_ITERATED
7348 | OPTI_TYPE_APPENDED_SALT
7349 | OPTI_TYPE_RAW_HASH;
7350 dgst_pos0 = 3;
7351 dgst_pos1 = 4;
7352 dgst_pos2 = 2;
7353 dgst_pos3 = 1;
7354 break;
7355
7356 case 131: hash_type = HASH_TYPE_SHA1;
7357 salt_type = SALT_TYPE_EMBEDDED;
7358 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7359 opts_type = OPTS_TYPE_PT_GENERATE_BE
7360 | OPTS_TYPE_PT_UNICODE
7361 | OPTS_TYPE_PT_UPPER
7362 | OPTS_TYPE_ST_ADD80
7363 | OPTS_TYPE_ST_ADDBITS15
7364 | OPTS_TYPE_ST_HEX;
7365 kern_type = KERN_TYPE_SHA1_PWUSLT;
7366 dgst_size = DGST_SIZE_4_5;
7367 parse_func = mssql2000_parse_hash;
7368 sort_by_digest = sort_by_digest_4_5;
7369 opti_type = OPTI_TYPE_ZERO_BYTE
7370 | OPTI_TYPE_PRECOMPUTE_INIT
7371 | OPTI_TYPE_PRECOMPUTE_MERKLE
7372 | OPTI_TYPE_EARLY_SKIP
7373 | OPTI_TYPE_NOT_ITERATED
7374 | OPTI_TYPE_APPENDED_SALT
7375 | OPTI_TYPE_RAW_HASH;
7376 dgst_pos0 = 3;
7377 dgst_pos1 = 4;
7378 dgst_pos2 = 2;
7379 dgst_pos3 = 1;
7380 break;
7381
7382 case 132: hash_type = HASH_TYPE_SHA1;
7383 salt_type = SALT_TYPE_EMBEDDED;
7384 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7385 opts_type = OPTS_TYPE_PT_GENERATE_BE
7386 | OPTS_TYPE_PT_UNICODE
7387 | OPTS_TYPE_ST_ADD80
7388 | OPTS_TYPE_ST_ADDBITS15
7389 | OPTS_TYPE_ST_HEX;
7390 kern_type = KERN_TYPE_SHA1_PWUSLT;
7391 dgst_size = DGST_SIZE_4_5;
7392 parse_func = mssql2005_parse_hash;
7393 sort_by_digest = sort_by_digest_4_5;
7394 opti_type = OPTI_TYPE_ZERO_BYTE
7395 | OPTI_TYPE_PRECOMPUTE_INIT
7396 | OPTI_TYPE_PRECOMPUTE_MERKLE
7397 | OPTI_TYPE_EARLY_SKIP
7398 | OPTI_TYPE_NOT_ITERATED
7399 | OPTI_TYPE_APPENDED_SALT
7400 | OPTI_TYPE_RAW_HASH;
7401 dgst_pos0 = 3;
7402 dgst_pos1 = 4;
7403 dgst_pos2 = 2;
7404 dgst_pos3 = 1;
7405 break;
7406
7407 case 133: hash_type = HASH_TYPE_SHA1;
7408 salt_type = SALT_TYPE_EMBEDDED;
7409 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7410 opts_type = OPTS_TYPE_PT_GENERATE_BE
7411 | OPTS_TYPE_PT_UNICODE
7412 | OPTS_TYPE_ST_ADD80
7413 | OPTS_TYPE_ST_ADDBITS15;
7414 kern_type = KERN_TYPE_SHA1_PWUSLT;
7415 dgst_size = DGST_SIZE_4_5;
7416 parse_func = peoplesoft_parse_hash;
7417 sort_by_digest = sort_by_digest_4_5;
7418 opti_type = OPTI_TYPE_ZERO_BYTE
7419 | OPTI_TYPE_PRECOMPUTE_INIT
7420 | OPTI_TYPE_PRECOMPUTE_MERKLE
7421 | OPTI_TYPE_EARLY_SKIP
7422 | OPTI_TYPE_NOT_ITERATED
7423 | OPTI_TYPE_APPENDED_SALT
7424 | OPTI_TYPE_RAW_HASH;
7425 dgst_pos0 = 3;
7426 dgst_pos1 = 4;
7427 dgst_pos2 = 2;
7428 dgst_pos3 = 1;
7429 break;
7430
7431 case 140: hash_type = HASH_TYPE_SHA1;
7432 salt_type = SALT_TYPE_INTERN;
7433 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7434 opts_type = OPTS_TYPE_PT_GENERATE_BE
7435 | OPTS_TYPE_PT_ADD80
7436 | OPTS_TYPE_PT_ADDBITS15
7437 | OPTS_TYPE_PT_UNICODE;
7438 kern_type = KERN_TYPE_SHA1_SLTPWU;
7439 dgst_size = DGST_SIZE_4_5;
7440 parse_func = sha1s_parse_hash;
7441 sort_by_digest = sort_by_digest_4_5;
7442 opti_type = OPTI_TYPE_ZERO_BYTE
7443 | OPTI_TYPE_PRECOMPUTE_INIT
7444 | OPTI_TYPE_PRECOMPUTE_MERKLE
7445 | OPTI_TYPE_EARLY_SKIP
7446 | OPTI_TYPE_NOT_ITERATED
7447 | OPTI_TYPE_PREPENDED_SALT
7448 | OPTI_TYPE_RAW_HASH;
7449 dgst_pos0 = 3;
7450 dgst_pos1 = 4;
7451 dgst_pos2 = 2;
7452 dgst_pos3 = 1;
7453 break;
7454
7455 case 141: hash_type = HASH_TYPE_SHA1;
7456 salt_type = SALT_TYPE_EMBEDDED;
7457 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7458 opts_type = OPTS_TYPE_PT_GENERATE_BE
7459 | OPTS_TYPE_PT_ADD80
7460 | OPTS_TYPE_PT_ADDBITS15
7461 | OPTS_TYPE_PT_UNICODE
7462 | OPTS_TYPE_ST_BASE64;
7463 kern_type = KERN_TYPE_SHA1_SLTPWU;
7464 dgst_size = DGST_SIZE_4_5;
7465 parse_func = episerver_parse_hash;
7466 sort_by_digest = sort_by_digest_4_5;
7467 opti_type = OPTI_TYPE_ZERO_BYTE
7468 | OPTI_TYPE_PRECOMPUTE_INIT
7469 | OPTI_TYPE_PRECOMPUTE_MERKLE
7470 | OPTI_TYPE_EARLY_SKIP
7471 | OPTI_TYPE_NOT_ITERATED
7472 | OPTI_TYPE_PREPENDED_SALT
7473 | OPTI_TYPE_RAW_HASH;
7474 dgst_pos0 = 3;
7475 dgst_pos1 = 4;
7476 dgst_pos2 = 2;
7477 dgst_pos3 = 1;
7478 break;
7479
7480 case 150: hash_type = HASH_TYPE_SHA1;
7481 salt_type = SALT_TYPE_INTERN;
7482 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7483 opts_type = OPTS_TYPE_PT_GENERATE_BE
7484 | OPTS_TYPE_ST_ADD80
7485 | OPTS_TYPE_ST_ADDBITS15;
7486 kern_type = KERN_TYPE_HMACSHA1_PW;
7487 dgst_size = DGST_SIZE_4_5;
7488 parse_func = hmacsha1_parse_hash;
7489 sort_by_digest = sort_by_digest_4_5;
7490 opti_type = OPTI_TYPE_ZERO_BYTE
7491 | OPTI_TYPE_NOT_ITERATED;
7492 dgst_pos0 = 3;
7493 dgst_pos1 = 4;
7494 dgst_pos2 = 2;
7495 dgst_pos3 = 1;
7496 break;
7497
7498 case 160: hash_type = HASH_TYPE_SHA1;
7499 salt_type = SALT_TYPE_INTERN;
7500 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7501 opts_type = OPTS_TYPE_PT_GENERATE_BE
7502 | OPTS_TYPE_PT_ADD80
7503 | OPTS_TYPE_PT_ADDBITS15;
7504 kern_type = KERN_TYPE_HMACSHA1_SLT;
7505 dgst_size = DGST_SIZE_4_5;
7506 parse_func = hmacsha1_parse_hash;
7507 sort_by_digest = sort_by_digest_4_5;
7508 opti_type = OPTI_TYPE_ZERO_BYTE
7509 | OPTI_TYPE_NOT_ITERATED;
7510 dgst_pos0 = 3;
7511 dgst_pos1 = 4;
7512 dgst_pos2 = 2;
7513 dgst_pos3 = 1;
7514 break;
7515
7516 case 190: hash_type = HASH_TYPE_SHA1;
7517 salt_type = SALT_TYPE_NONE;
7518 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7519 opts_type = OPTS_TYPE_PT_GENERATE_BE
7520 | OPTS_TYPE_PT_ADD80
7521 | OPTS_TYPE_PT_ADDBITS15;
7522 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7523 dgst_size = DGST_SIZE_4_5;
7524 parse_func = sha1linkedin_parse_hash;
7525 sort_by_digest = sort_by_digest_4_5;
7526 opti_type = OPTI_TYPE_ZERO_BYTE
7527 | OPTI_TYPE_PRECOMPUTE_INIT
7528 | OPTI_TYPE_EARLY_SKIP
7529 | OPTI_TYPE_NOT_ITERATED
7530 | OPTI_TYPE_NOT_SALTED;
7531 dgst_pos0 = 0;
7532 dgst_pos1 = 4;
7533 dgst_pos2 = 3;
7534 dgst_pos3 = 2;
7535 break;
7536
7537 case 200: hash_type = HASH_TYPE_MYSQL;
7538 salt_type = SALT_TYPE_NONE;
7539 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7540 opts_type = 0;
7541 kern_type = KERN_TYPE_MYSQL;
7542 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7543 parse_func = mysql323_parse_hash;
7544 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7545 opti_type = OPTI_TYPE_ZERO_BYTE;
7546 dgst_pos0 = 0;
7547 dgst_pos1 = 1;
7548 dgst_pos2 = 2;
7549 dgst_pos3 = 3;
7550 break;
7551
7552 case 300: hash_type = HASH_TYPE_SHA1;
7553 salt_type = SALT_TYPE_NONE;
7554 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7555 opts_type = OPTS_TYPE_PT_GENERATE_BE
7556 | OPTS_TYPE_PT_ADD80
7557 | OPTS_TYPE_PT_ADDBITS15;
7558 kern_type = KERN_TYPE_MYSQL41;
7559 dgst_size = DGST_SIZE_4_5;
7560 parse_func = sha1_parse_hash;
7561 sort_by_digest = sort_by_digest_4_5;
7562 opti_type = OPTI_TYPE_ZERO_BYTE
7563 | OPTI_TYPE_PRECOMPUTE_INIT
7564 | OPTI_TYPE_PRECOMPUTE_MERKLE
7565 | OPTI_TYPE_EARLY_SKIP
7566 | OPTI_TYPE_NOT_ITERATED
7567 | OPTI_TYPE_NOT_SALTED;
7568 dgst_pos0 = 3;
7569 dgst_pos1 = 4;
7570 dgst_pos2 = 2;
7571 dgst_pos3 = 1;
7572 break;
7573
7574 case 400: hash_type = HASH_TYPE_MD5;
7575 salt_type = SALT_TYPE_EMBEDDED;
7576 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7577 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7578 kern_type = KERN_TYPE_PHPASS;
7579 dgst_size = DGST_SIZE_4_4;
7580 parse_func = phpass_parse_hash;
7581 sort_by_digest = sort_by_digest_4_4;
7582 opti_type = OPTI_TYPE_ZERO_BYTE;
7583 dgst_pos0 = 0;
7584 dgst_pos1 = 1;
7585 dgst_pos2 = 2;
7586 dgst_pos3 = 3;
7587 break;
7588
7589 case 500: hash_type = HASH_TYPE_MD5;
7590 salt_type = SALT_TYPE_EMBEDDED;
7591 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7592 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7593 kern_type = KERN_TYPE_MD5CRYPT;
7594 dgst_size = DGST_SIZE_4_4;
7595 parse_func = md5crypt_parse_hash;
7596 sort_by_digest = sort_by_digest_4_4;
7597 opti_type = OPTI_TYPE_ZERO_BYTE;
7598 dgst_pos0 = 0;
7599 dgst_pos1 = 1;
7600 dgst_pos2 = 2;
7601 dgst_pos3 = 3;
7602 break;
7603
7604 case 501: hash_type = HASH_TYPE_MD5;
7605 salt_type = SALT_TYPE_EMBEDDED;
7606 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7607 opts_type = OPTS_TYPE_PT_GENERATE_LE
7608 | OPTS_TYPE_HASH_COPY;
7609 kern_type = KERN_TYPE_MD5CRYPT;
7610 dgst_size = DGST_SIZE_4_4;
7611 parse_func = juniper_parse_hash;
7612 sort_by_digest = sort_by_digest_4_4;
7613 opti_type = OPTI_TYPE_ZERO_BYTE;
7614 dgst_pos0 = 0;
7615 dgst_pos1 = 1;
7616 dgst_pos2 = 2;
7617 dgst_pos3 = 3;
7618 break;
7619
7620 case 900: hash_type = HASH_TYPE_MD4;
7621 salt_type = SALT_TYPE_NONE;
7622 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7623 opts_type = OPTS_TYPE_PT_GENERATE_LE
7624 | OPTS_TYPE_PT_ADD80
7625 | OPTS_TYPE_PT_ADDBITS14;
7626 kern_type = KERN_TYPE_MD4;
7627 dgst_size = DGST_SIZE_4_4;
7628 parse_func = md4_parse_hash;
7629 sort_by_digest = sort_by_digest_4_4;
7630 opti_type = OPTI_TYPE_ZERO_BYTE
7631 | OPTI_TYPE_PRECOMPUTE_INIT
7632 | OPTI_TYPE_PRECOMPUTE_MERKLE
7633 | OPTI_TYPE_MEET_IN_MIDDLE
7634 | OPTI_TYPE_EARLY_SKIP
7635 | OPTI_TYPE_NOT_ITERATED
7636 | OPTI_TYPE_NOT_SALTED
7637 | OPTI_TYPE_RAW_HASH;
7638 dgst_pos0 = 0;
7639 dgst_pos1 = 3;
7640 dgst_pos2 = 2;
7641 dgst_pos3 = 1;
7642 break;
7643
7644 case 1000: hash_type = HASH_TYPE_MD4;
7645 salt_type = SALT_TYPE_NONE;
7646 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7647 opts_type = OPTS_TYPE_PT_GENERATE_LE
7648 | OPTS_TYPE_PT_ADD80
7649 | OPTS_TYPE_PT_ADDBITS14
7650 | OPTS_TYPE_PT_UNICODE;
7651 kern_type = KERN_TYPE_MD4_PWU;
7652 dgst_size = DGST_SIZE_4_4;
7653 parse_func = md4_parse_hash;
7654 sort_by_digest = sort_by_digest_4_4;
7655 opti_type = OPTI_TYPE_ZERO_BYTE
7656 | OPTI_TYPE_PRECOMPUTE_INIT
7657 | OPTI_TYPE_PRECOMPUTE_MERKLE
7658 | OPTI_TYPE_MEET_IN_MIDDLE
7659 | OPTI_TYPE_EARLY_SKIP
7660 | OPTI_TYPE_NOT_ITERATED
7661 | OPTI_TYPE_NOT_SALTED
7662 | OPTI_TYPE_RAW_HASH;
7663 dgst_pos0 = 0;
7664 dgst_pos1 = 3;
7665 dgst_pos2 = 2;
7666 dgst_pos3 = 1;
7667 break;
7668
7669 case 1100: hash_type = HASH_TYPE_MD4;
7670 salt_type = SALT_TYPE_INTERN;
7671 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7672 opts_type = OPTS_TYPE_PT_GENERATE_LE
7673 | OPTS_TYPE_PT_ADD80
7674 | OPTS_TYPE_PT_ADDBITS14
7675 | OPTS_TYPE_PT_UNICODE
7676 | OPTS_TYPE_ST_ADD80
7677 | OPTS_TYPE_ST_UNICODE
7678 | OPTS_TYPE_ST_LOWER;
7679 kern_type = KERN_TYPE_MD44_PWUSLT;
7680 dgst_size = DGST_SIZE_4_4;
7681 parse_func = dcc_parse_hash;
7682 sort_by_digest = sort_by_digest_4_4;
7683 opti_type = OPTI_TYPE_ZERO_BYTE
7684 | OPTI_TYPE_PRECOMPUTE_INIT
7685 | OPTI_TYPE_PRECOMPUTE_MERKLE
7686 | OPTI_TYPE_EARLY_SKIP
7687 | OPTI_TYPE_NOT_ITERATED;
7688 dgst_pos0 = 0;
7689 dgst_pos1 = 3;
7690 dgst_pos2 = 2;
7691 dgst_pos3 = 1;
7692 break;
7693
7694 case 1400: hash_type = HASH_TYPE_SHA256;
7695 salt_type = SALT_TYPE_NONE;
7696 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7697 opts_type = OPTS_TYPE_PT_GENERATE_BE
7698 | OPTS_TYPE_PT_ADD80
7699 | OPTS_TYPE_PT_ADDBITS15;
7700 kern_type = KERN_TYPE_SHA256;
7701 dgst_size = DGST_SIZE_4_8;
7702 parse_func = sha256_parse_hash;
7703 sort_by_digest = sort_by_digest_4_8;
7704 opti_type = OPTI_TYPE_ZERO_BYTE
7705 | OPTI_TYPE_PRECOMPUTE_INIT
7706 | OPTI_TYPE_PRECOMPUTE_MERKLE
7707 | OPTI_TYPE_EARLY_SKIP
7708 | OPTI_TYPE_NOT_ITERATED
7709 | OPTI_TYPE_NOT_SALTED
7710 | OPTI_TYPE_RAW_HASH;
7711 dgst_pos0 = 3;
7712 dgst_pos1 = 7;
7713 dgst_pos2 = 2;
7714 dgst_pos3 = 6;
7715 break;
7716
7717 case 1410: hash_type = HASH_TYPE_SHA256;
7718 salt_type = SALT_TYPE_INTERN;
7719 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7720 opts_type = OPTS_TYPE_PT_GENERATE_BE
7721 | OPTS_TYPE_ST_ADD80
7722 | OPTS_TYPE_ST_ADDBITS15;
7723 kern_type = KERN_TYPE_SHA256_PWSLT;
7724 dgst_size = DGST_SIZE_4_8;
7725 parse_func = sha256s_parse_hash;
7726 sort_by_digest = sort_by_digest_4_8;
7727 opti_type = OPTI_TYPE_ZERO_BYTE
7728 | OPTI_TYPE_PRECOMPUTE_INIT
7729 | OPTI_TYPE_PRECOMPUTE_MERKLE
7730 | OPTI_TYPE_EARLY_SKIP
7731 | OPTI_TYPE_NOT_ITERATED
7732 | OPTI_TYPE_APPENDED_SALT
7733 | OPTI_TYPE_RAW_HASH;
7734 dgst_pos0 = 3;
7735 dgst_pos1 = 7;
7736 dgst_pos2 = 2;
7737 dgst_pos3 = 6;
7738 break;
7739
7740 case 1420: hash_type = HASH_TYPE_SHA256;
7741 salt_type = SALT_TYPE_INTERN;
7742 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7743 opts_type = OPTS_TYPE_PT_GENERATE_BE
7744 | OPTS_TYPE_PT_ADD80
7745 | OPTS_TYPE_PT_ADDBITS15;
7746 kern_type = KERN_TYPE_SHA256_SLTPW;
7747 dgst_size = DGST_SIZE_4_8;
7748 parse_func = sha256s_parse_hash;
7749 sort_by_digest = sort_by_digest_4_8;
7750 opti_type = OPTI_TYPE_ZERO_BYTE
7751 | OPTI_TYPE_PRECOMPUTE_INIT
7752 | OPTI_TYPE_PRECOMPUTE_MERKLE
7753 | OPTI_TYPE_EARLY_SKIP
7754 | OPTI_TYPE_NOT_ITERATED
7755 | OPTI_TYPE_PREPENDED_SALT
7756 | OPTI_TYPE_RAW_HASH;
7757 dgst_pos0 = 3;
7758 dgst_pos1 = 7;
7759 dgst_pos2 = 2;
7760 dgst_pos3 = 6;
7761 break;
7762
7763 case 1421: hash_type = HASH_TYPE_SHA256;
7764 salt_type = SALT_TYPE_EMBEDDED;
7765 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7766 opts_type = OPTS_TYPE_PT_GENERATE_BE
7767 | OPTS_TYPE_PT_ADD80
7768 | OPTS_TYPE_PT_ADDBITS15;
7769 kern_type = KERN_TYPE_SHA256_SLTPW;
7770 dgst_size = DGST_SIZE_4_8;
7771 parse_func = hmailserver_parse_hash;
7772 sort_by_digest = sort_by_digest_4_8;
7773 opti_type = OPTI_TYPE_ZERO_BYTE
7774 | OPTI_TYPE_PRECOMPUTE_INIT
7775 | OPTI_TYPE_PRECOMPUTE_MERKLE
7776 | OPTI_TYPE_EARLY_SKIP
7777 | OPTI_TYPE_NOT_ITERATED
7778 | OPTI_TYPE_PREPENDED_SALT
7779 | OPTI_TYPE_RAW_HASH;
7780 dgst_pos0 = 3;
7781 dgst_pos1 = 7;
7782 dgst_pos2 = 2;
7783 dgst_pos3 = 6;
7784 break;
7785
7786 case 1430: hash_type = HASH_TYPE_SHA256;
7787 salt_type = SALT_TYPE_INTERN;
7788 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7789 opts_type = OPTS_TYPE_PT_GENERATE_BE
7790 | OPTS_TYPE_PT_UNICODE
7791 | OPTS_TYPE_ST_ADD80
7792 | OPTS_TYPE_ST_ADDBITS15;
7793 kern_type = KERN_TYPE_SHA256_PWUSLT;
7794 dgst_size = DGST_SIZE_4_8;
7795 parse_func = sha256s_parse_hash;
7796 sort_by_digest = sort_by_digest_4_8;
7797 opti_type = OPTI_TYPE_ZERO_BYTE
7798 | OPTI_TYPE_PRECOMPUTE_INIT
7799 | OPTI_TYPE_PRECOMPUTE_MERKLE
7800 | OPTI_TYPE_EARLY_SKIP
7801 | OPTI_TYPE_NOT_ITERATED
7802 | OPTI_TYPE_APPENDED_SALT
7803 | OPTI_TYPE_RAW_HASH;
7804 dgst_pos0 = 3;
7805 dgst_pos1 = 7;
7806 dgst_pos2 = 2;
7807 dgst_pos3 = 6;
7808 break;
7809
7810 case 1440: hash_type = HASH_TYPE_SHA256;
7811 salt_type = SALT_TYPE_INTERN;
7812 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7813 opts_type = OPTS_TYPE_PT_GENERATE_BE
7814 | OPTS_TYPE_PT_ADD80
7815 | OPTS_TYPE_PT_ADDBITS15
7816 | OPTS_TYPE_PT_UNICODE;
7817 kern_type = KERN_TYPE_SHA256_SLTPWU;
7818 dgst_size = DGST_SIZE_4_8;
7819 parse_func = sha256s_parse_hash;
7820 sort_by_digest = sort_by_digest_4_8;
7821 opti_type = OPTI_TYPE_ZERO_BYTE
7822 | OPTI_TYPE_PRECOMPUTE_INIT
7823 | OPTI_TYPE_PRECOMPUTE_MERKLE
7824 | OPTI_TYPE_EARLY_SKIP
7825 | OPTI_TYPE_NOT_ITERATED
7826 | OPTI_TYPE_PREPENDED_SALT
7827 | OPTI_TYPE_RAW_HASH;
7828 dgst_pos0 = 3;
7829 dgst_pos1 = 7;
7830 dgst_pos2 = 2;
7831 dgst_pos3 = 6;
7832 break;
7833
7834 case 1441: hash_type = HASH_TYPE_SHA256;
7835 salt_type = SALT_TYPE_EMBEDDED;
7836 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7837 opts_type = OPTS_TYPE_PT_GENERATE_BE
7838 | OPTS_TYPE_PT_ADD80
7839 | OPTS_TYPE_PT_ADDBITS15
7840 | OPTS_TYPE_PT_UNICODE
7841 | OPTS_TYPE_ST_BASE64;
7842 kern_type = KERN_TYPE_SHA256_SLTPWU;
7843 dgst_size = DGST_SIZE_4_8;
7844 parse_func = episerver4_parse_hash;
7845 sort_by_digest = sort_by_digest_4_8;
7846 opti_type = OPTI_TYPE_ZERO_BYTE
7847 | OPTI_TYPE_PRECOMPUTE_INIT
7848 | OPTI_TYPE_PRECOMPUTE_MERKLE
7849 | OPTI_TYPE_EARLY_SKIP
7850 | OPTI_TYPE_NOT_ITERATED
7851 | OPTI_TYPE_PREPENDED_SALT
7852 | OPTI_TYPE_RAW_HASH;
7853 dgst_pos0 = 3;
7854 dgst_pos1 = 7;
7855 dgst_pos2 = 2;
7856 dgst_pos3 = 6;
7857 break;
7858
7859 case 1450: hash_type = HASH_TYPE_SHA256;
7860 salt_type = SALT_TYPE_INTERN;
7861 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7862 opts_type = OPTS_TYPE_PT_GENERATE_BE
7863 | OPTS_TYPE_ST_ADD80;
7864 kern_type = KERN_TYPE_HMACSHA256_PW;
7865 dgst_size = DGST_SIZE_4_8;
7866 parse_func = hmacsha256_parse_hash;
7867 sort_by_digest = sort_by_digest_4_8;
7868 opti_type = OPTI_TYPE_ZERO_BYTE
7869 | OPTI_TYPE_NOT_ITERATED;
7870 dgst_pos0 = 3;
7871 dgst_pos1 = 7;
7872 dgst_pos2 = 2;
7873 dgst_pos3 = 6;
7874 break;
7875
7876 case 1460: hash_type = HASH_TYPE_SHA256;
7877 salt_type = SALT_TYPE_INTERN;
7878 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7879 opts_type = OPTS_TYPE_PT_GENERATE_BE
7880 | OPTS_TYPE_PT_ADD80
7881 | OPTS_TYPE_PT_ADDBITS15;
7882 kern_type = KERN_TYPE_HMACSHA256_SLT;
7883 dgst_size = DGST_SIZE_4_8;
7884 parse_func = hmacsha256_parse_hash;
7885 sort_by_digest = sort_by_digest_4_8;
7886 opti_type = OPTI_TYPE_ZERO_BYTE
7887 | OPTI_TYPE_NOT_ITERATED;
7888 dgst_pos0 = 3;
7889 dgst_pos1 = 7;
7890 dgst_pos2 = 2;
7891 dgst_pos3 = 6;
7892 break;
7893
7894 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7895 salt_type = SALT_TYPE_EMBEDDED;
7896 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7897 opts_type = OPTS_TYPE_PT_GENERATE_LE
7898 | OPTS_TYPE_PT_BITSLICE;
7899 kern_type = KERN_TYPE_DESCRYPT;
7900 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7901 parse_func = descrypt_parse_hash;
7902 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7903 opti_type = OPTI_TYPE_ZERO_BYTE
7904 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7905 dgst_pos0 = 0;
7906 dgst_pos1 = 1;
7907 dgst_pos2 = 2;
7908 dgst_pos3 = 3;
7909 break;
7910
7911 case 1600: hash_type = HASH_TYPE_MD5;
7912 salt_type = SALT_TYPE_EMBEDDED;
7913 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7914 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7915 kern_type = KERN_TYPE_APR1CRYPT;
7916 dgst_size = DGST_SIZE_4_4;
7917 parse_func = md5apr1_parse_hash;
7918 sort_by_digest = sort_by_digest_4_4;
7919 opti_type = OPTI_TYPE_ZERO_BYTE;
7920 dgst_pos0 = 0;
7921 dgst_pos1 = 1;
7922 dgst_pos2 = 2;
7923 dgst_pos3 = 3;
7924 break;
7925
7926 case 1700: hash_type = HASH_TYPE_SHA512;
7927 salt_type = SALT_TYPE_NONE;
7928 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7929 opts_type = OPTS_TYPE_PT_GENERATE_BE
7930 | OPTS_TYPE_PT_ADD80
7931 | OPTS_TYPE_PT_ADDBITS15;
7932 kern_type = KERN_TYPE_SHA512;
7933 dgst_size = DGST_SIZE_8_8;
7934 parse_func = sha512_parse_hash;
7935 sort_by_digest = sort_by_digest_8_8;
7936 opti_type = OPTI_TYPE_ZERO_BYTE
7937 | OPTI_TYPE_PRECOMPUTE_INIT
7938 | OPTI_TYPE_PRECOMPUTE_MERKLE
7939 | OPTI_TYPE_EARLY_SKIP
7940 | OPTI_TYPE_NOT_ITERATED
7941 | OPTI_TYPE_NOT_SALTED
7942 | OPTI_TYPE_USES_BITS_64
7943 | OPTI_TYPE_RAW_HASH;
7944 dgst_pos0 = 14;
7945 dgst_pos1 = 15;
7946 dgst_pos2 = 6;
7947 dgst_pos3 = 7;
7948 break;
7949
7950 case 1710: hash_type = HASH_TYPE_SHA512;
7951 salt_type = SALT_TYPE_INTERN;
7952 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7953 opts_type = OPTS_TYPE_PT_GENERATE_BE
7954 | OPTS_TYPE_ST_ADD80
7955 | OPTS_TYPE_ST_ADDBITS15;
7956 kern_type = KERN_TYPE_SHA512_PWSLT;
7957 dgst_size = DGST_SIZE_8_8;
7958 parse_func = sha512s_parse_hash;
7959 sort_by_digest = sort_by_digest_8_8;
7960 opti_type = OPTI_TYPE_ZERO_BYTE
7961 | OPTI_TYPE_PRECOMPUTE_INIT
7962 | OPTI_TYPE_PRECOMPUTE_MERKLE
7963 | OPTI_TYPE_EARLY_SKIP
7964 | OPTI_TYPE_NOT_ITERATED
7965 | OPTI_TYPE_APPENDED_SALT
7966 | OPTI_TYPE_USES_BITS_64
7967 | OPTI_TYPE_RAW_HASH;
7968 dgst_pos0 = 14;
7969 dgst_pos1 = 15;
7970 dgst_pos2 = 6;
7971 dgst_pos3 = 7;
7972 break;
7973
7974 case 1711: hash_type = HASH_TYPE_SHA512;
7975 salt_type = SALT_TYPE_EMBEDDED;
7976 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7977 opts_type = OPTS_TYPE_PT_GENERATE_BE
7978 | OPTS_TYPE_ST_ADD80
7979 | OPTS_TYPE_ST_ADDBITS15;
7980 kern_type = KERN_TYPE_SHA512_PWSLT;
7981 dgst_size = DGST_SIZE_8_8;
7982 parse_func = sha512b64s_parse_hash;
7983 sort_by_digest = sort_by_digest_8_8;
7984 opti_type = OPTI_TYPE_ZERO_BYTE
7985 | OPTI_TYPE_PRECOMPUTE_INIT
7986 | OPTI_TYPE_PRECOMPUTE_MERKLE
7987 | OPTI_TYPE_EARLY_SKIP
7988 | OPTI_TYPE_NOT_ITERATED
7989 | OPTI_TYPE_APPENDED_SALT
7990 | OPTI_TYPE_USES_BITS_64
7991 | OPTI_TYPE_RAW_HASH;
7992 dgst_pos0 = 14;
7993 dgst_pos1 = 15;
7994 dgst_pos2 = 6;
7995 dgst_pos3 = 7;
7996 break;
7997
7998 case 1720: hash_type = HASH_TYPE_SHA512;
7999 salt_type = SALT_TYPE_INTERN;
8000 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8001 opts_type = OPTS_TYPE_PT_GENERATE_BE
8002 | OPTS_TYPE_PT_ADD80
8003 | OPTS_TYPE_PT_ADDBITS15;
8004 kern_type = KERN_TYPE_SHA512_SLTPW;
8005 dgst_size = DGST_SIZE_8_8;
8006 parse_func = sha512s_parse_hash;
8007 sort_by_digest = sort_by_digest_8_8;
8008 opti_type = OPTI_TYPE_ZERO_BYTE
8009 | OPTI_TYPE_PRECOMPUTE_INIT
8010 | OPTI_TYPE_PRECOMPUTE_MERKLE
8011 | OPTI_TYPE_EARLY_SKIP
8012 | OPTI_TYPE_NOT_ITERATED
8013 | OPTI_TYPE_PREPENDED_SALT
8014 | OPTI_TYPE_USES_BITS_64
8015 | OPTI_TYPE_RAW_HASH;
8016 dgst_pos0 = 14;
8017 dgst_pos1 = 15;
8018 dgst_pos2 = 6;
8019 dgst_pos3 = 7;
8020 break;
8021
8022 case 1722: hash_type = HASH_TYPE_SHA512;
8023 salt_type = SALT_TYPE_EMBEDDED;
8024 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8025 opts_type = OPTS_TYPE_PT_GENERATE_BE
8026 | OPTS_TYPE_PT_ADD80
8027 | OPTS_TYPE_PT_ADDBITS15
8028 | OPTS_TYPE_ST_HEX;
8029 kern_type = KERN_TYPE_SHA512_SLTPW;
8030 dgst_size = DGST_SIZE_8_8;
8031 parse_func = osx512_parse_hash;
8032 sort_by_digest = sort_by_digest_8_8;
8033 opti_type = OPTI_TYPE_ZERO_BYTE
8034 | OPTI_TYPE_PRECOMPUTE_INIT
8035 | OPTI_TYPE_PRECOMPUTE_MERKLE
8036 | OPTI_TYPE_EARLY_SKIP
8037 | OPTI_TYPE_NOT_ITERATED
8038 | OPTI_TYPE_PREPENDED_SALT
8039 | OPTI_TYPE_USES_BITS_64
8040 | OPTI_TYPE_RAW_HASH;
8041 dgst_pos0 = 14;
8042 dgst_pos1 = 15;
8043 dgst_pos2 = 6;
8044 dgst_pos3 = 7;
8045 break;
8046
8047 case 1730: hash_type = HASH_TYPE_SHA512;
8048 salt_type = SALT_TYPE_INTERN;
8049 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8050 opts_type = OPTS_TYPE_PT_GENERATE_BE
8051 | OPTS_TYPE_PT_UNICODE
8052 | OPTS_TYPE_ST_ADD80
8053 | OPTS_TYPE_ST_ADDBITS15;
8054 kern_type = KERN_TYPE_SHA512_PWSLTU;
8055 dgst_size = DGST_SIZE_8_8;
8056 parse_func = sha512s_parse_hash;
8057 sort_by_digest = sort_by_digest_8_8;
8058 opti_type = OPTI_TYPE_ZERO_BYTE
8059 | OPTI_TYPE_PRECOMPUTE_INIT
8060 | OPTI_TYPE_PRECOMPUTE_MERKLE
8061 | OPTI_TYPE_EARLY_SKIP
8062 | OPTI_TYPE_NOT_ITERATED
8063 | OPTI_TYPE_APPENDED_SALT
8064 | OPTI_TYPE_USES_BITS_64
8065 | OPTI_TYPE_RAW_HASH;
8066 dgst_pos0 = 14;
8067 dgst_pos1 = 15;
8068 dgst_pos2 = 6;
8069 dgst_pos3 = 7;
8070 break;
8071
8072 case 1731: hash_type = HASH_TYPE_SHA512;
8073 salt_type = SALT_TYPE_EMBEDDED;
8074 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8075 opts_type = OPTS_TYPE_PT_GENERATE_BE
8076 | OPTS_TYPE_PT_UNICODE
8077 | OPTS_TYPE_ST_ADD80
8078 | OPTS_TYPE_ST_ADDBITS15
8079 | OPTS_TYPE_ST_HEX;
8080 kern_type = KERN_TYPE_SHA512_PWSLTU;
8081 dgst_size = DGST_SIZE_8_8;
8082 parse_func = mssql2012_parse_hash;
8083 sort_by_digest = sort_by_digest_8_8;
8084 opti_type = OPTI_TYPE_ZERO_BYTE
8085 | OPTI_TYPE_PRECOMPUTE_INIT
8086 | OPTI_TYPE_PRECOMPUTE_MERKLE
8087 | OPTI_TYPE_EARLY_SKIP
8088 | OPTI_TYPE_NOT_ITERATED
8089 | OPTI_TYPE_APPENDED_SALT
8090 | OPTI_TYPE_USES_BITS_64
8091 | OPTI_TYPE_RAW_HASH;
8092 dgst_pos0 = 14;
8093 dgst_pos1 = 15;
8094 dgst_pos2 = 6;
8095 dgst_pos3 = 7;
8096 break;
8097
8098 case 1740: hash_type = HASH_TYPE_SHA512;
8099 salt_type = SALT_TYPE_INTERN;
8100 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8101 opts_type = OPTS_TYPE_PT_GENERATE_BE
8102 | OPTS_TYPE_PT_ADD80
8103 | OPTS_TYPE_PT_ADDBITS15
8104 | OPTS_TYPE_PT_UNICODE;
8105 kern_type = KERN_TYPE_SHA512_SLTPWU;
8106 dgst_size = DGST_SIZE_8_8;
8107 parse_func = sha512s_parse_hash;
8108 sort_by_digest = sort_by_digest_8_8;
8109 opti_type = OPTI_TYPE_ZERO_BYTE
8110 | OPTI_TYPE_PRECOMPUTE_INIT
8111 | OPTI_TYPE_PRECOMPUTE_MERKLE
8112 | OPTI_TYPE_EARLY_SKIP
8113 | OPTI_TYPE_NOT_ITERATED
8114 | OPTI_TYPE_PREPENDED_SALT
8115 | OPTI_TYPE_USES_BITS_64
8116 | OPTI_TYPE_RAW_HASH;
8117 dgst_pos0 = 14;
8118 dgst_pos1 = 15;
8119 dgst_pos2 = 6;
8120 dgst_pos3 = 7;
8121 break;
8122
8123 case 1750: hash_type = HASH_TYPE_SHA512;
8124 salt_type = SALT_TYPE_INTERN;
8125 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8126 opts_type = OPTS_TYPE_PT_GENERATE_BE
8127 | OPTS_TYPE_ST_ADD80;
8128 kern_type = KERN_TYPE_HMACSHA512_PW;
8129 dgst_size = DGST_SIZE_8_8;
8130 parse_func = hmacsha512_parse_hash;
8131 sort_by_digest = sort_by_digest_8_8;
8132 opti_type = OPTI_TYPE_ZERO_BYTE
8133 | OPTI_TYPE_USES_BITS_64
8134 | OPTI_TYPE_NOT_ITERATED;
8135 dgst_pos0 = 14;
8136 dgst_pos1 = 15;
8137 dgst_pos2 = 6;
8138 dgst_pos3 = 7;
8139 break;
8140
8141 case 1760: hash_type = HASH_TYPE_SHA512;
8142 salt_type = SALT_TYPE_INTERN;
8143 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8144 opts_type = OPTS_TYPE_PT_GENERATE_BE
8145 | OPTS_TYPE_PT_ADD80
8146 | OPTS_TYPE_PT_ADDBITS15;
8147 kern_type = KERN_TYPE_HMACSHA512_SLT;
8148 dgst_size = DGST_SIZE_8_8;
8149 parse_func = hmacsha512_parse_hash;
8150 sort_by_digest = sort_by_digest_8_8;
8151 opti_type = OPTI_TYPE_ZERO_BYTE
8152 | OPTI_TYPE_USES_BITS_64
8153 | OPTI_TYPE_NOT_ITERATED;
8154 dgst_pos0 = 14;
8155 dgst_pos1 = 15;
8156 dgst_pos2 = 6;
8157 dgst_pos3 = 7;
8158 break;
8159
8160 case 1800: hash_type = HASH_TYPE_SHA512;
8161 salt_type = SALT_TYPE_EMBEDDED;
8162 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8163 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8164 kern_type = KERN_TYPE_SHA512CRYPT;
8165 dgst_size = DGST_SIZE_8_8;
8166 parse_func = sha512crypt_parse_hash;
8167 sort_by_digest = sort_by_digest_8_8;
8168 opti_type = OPTI_TYPE_ZERO_BYTE
8169 | OPTI_TYPE_USES_BITS_64;
8170 dgst_pos0 = 0;
8171 dgst_pos1 = 1;
8172 dgst_pos2 = 2;
8173 dgst_pos3 = 3;
8174 break;
8175
8176 case 2100: hash_type = HASH_TYPE_DCC2;
8177 salt_type = SALT_TYPE_EMBEDDED;
8178 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8179 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8180 | OPTS_TYPE_ST_LOWER
8181 | OPTS_TYPE_ST_UNICODE;
8182 kern_type = KERN_TYPE_DCC2;
8183 dgst_size = DGST_SIZE_4_4;
8184 parse_func = dcc2_parse_hash;
8185 sort_by_digest = sort_by_digest_4_4;
8186 opti_type = OPTI_TYPE_ZERO_BYTE;
8187 dgst_pos0 = 0;
8188 dgst_pos1 = 1;
8189 dgst_pos2 = 2;
8190 dgst_pos3 = 3;
8191 break;
8192
8193 case 2400: hash_type = HASH_TYPE_MD5;
8194 salt_type = SALT_TYPE_NONE;
8195 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8196 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8197 kern_type = KERN_TYPE_MD5PIX;
8198 dgst_size = DGST_SIZE_4_4;
8199 parse_func = md5pix_parse_hash;
8200 sort_by_digest = sort_by_digest_4_4;
8201 opti_type = OPTI_TYPE_ZERO_BYTE
8202 | OPTI_TYPE_PRECOMPUTE_INIT
8203 | OPTI_TYPE_PRECOMPUTE_MERKLE
8204 | OPTI_TYPE_EARLY_SKIP
8205 | OPTI_TYPE_NOT_ITERATED
8206 | OPTI_TYPE_NOT_SALTED;
8207 dgst_pos0 = 0;
8208 dgst_pos1 = 3;
8209 dgst_pos2 = 2;
8210 dgst_pos3 = 1;
8211 break;
8212
8213 case 2410: hash_type = HASH_TYPE_MD5;
8214 salt_type = SALT_TYPE_INTERN;
8215 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8216 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8217 kern_type = KERN_TYPE_MD5ASA;
8218 dgst_size = DGST_SIZE_4_4;
8219 parse_func = md5asa_parse_hash;
8220 sort_by_digest = sort_by_digest_4_4;
8221 opti_type = OPTI_TYPE_ZERO_BYTE
8222 | OPTI_TYPE_PRECOMPUTE_INIT
8223 | OPTI_TYPE_PRECOMPUTE_MERKLE
8224 | OPTI_TYPE_EARLY_SKIP
8225 | OPTI_TYPE_NOT_ITERATED;
8226 dgst_pos0 = 0;
8227 dgst_pos1 = 3;
8228 dgst_pos2 = 2;
8229 dgst_pos3 = 1;
8230 break;
8231
8232 case 2500: hash_type = HASH_TYPE_WPA;
8233 salt_type = SALT_TYPE_EMBEDDED;
8234 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8235 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8236 kern_type = KERN_TYPE_WPA;
8237 dgst_size = DGST_SIZE_4_4;
8238 parse_func = wpa_parse_hash;
8239 sort_by_digest = sort_by_digest_4_4;
8240 opti_type = OPTI_TYPE_ZERO_BYTE;
8241 dgst_pos0 = 0;
8242 dgst_pos1 = 1;
8243 dgst_pos2 = 2;
8244 dgst_pos3 = 3;
8245 break;
8246
8247 case 2600: hash_type = HASH_TYPE_MD5;
8248 salt_type = SALT_TYPE_VIRTUAL;
8249 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8250 opts_type = OPTS_TYPE_PT_GENERATE_LE
8251 | OPTS_TYPE_PT_ADD80
8252 | OPTS_TYPE_PT_ADDBITS14
8253 | OPTS_TYPE_ST_ADD80;
8254 kern_type = KERN_TYPE_MD55_PWSLT1;
8255 dgst_size = DGST_SIZE_4_4;
8256 parse_func = md5md5_parse_hash;
8257 sort_by_digest = sort_by_digest_4_4;
8258 opti_type = OPTI_TYPE_ZERO_BYTE
8259 | OPTI_TYPE_PRECOMPUTE_INIT
8260 | OPTI_TYPE_PRECOMPUTE_MERKLE
8261 | OPTI_TYPE_EARLY_SKIP;
8262 dgst_pos0 = 0;
8263 dgst_pos1 = 3;
8264 dgst_pos2 = 2;
8265 dgst_pos3 = 1;
8266 break;
8267
8268 case 2611: hash_type = HASH_TYPE_MD5;
8269 salt_type = SALT_TYPE_INTERN;
8270 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8271 opts_type = OPTS_TYPE_PT_GENERATE_LE
8272 | OPTS_TYPE_PT_ADD80
8273 | OPTS_TYPE_PT_ADDBITS14
8274 | OPTS_TYPE_ST_ADD80;
8275 kern_type = KERN_TYPE_MD55_PWSLT1;
8276 dgst_size = DGST_SIZE_4_4;
8277 parse_func = vb3_parse_hash;
8278 sort_by_digest = sort_by_digest_4_4;
8279 opti_type = OPTI_TYPE_ZERO_BYTE
8280 | OPTI_TYPE_PRECOMPUTE_INIT
8281 | OPTI_TYPE_PRECOMPUTE_MERKLE
8282 | OPTI_TYPE_EARLY_SKIP;
8283 dgst_pos0 = 0;
8284 dgst_pos1 = 3;
8285 dgst_pos2 = 2;
8286 dgst_pos3 = 1;
8287 break;
8288
8289 case 2612: hash_type = HASH_TYPE_MD5;
8290 salt_type = SALT_TYPE_EMBEDDED;
8291 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8292 opts_type = OPTS_TYPE_PT_GENERATE_LE
8293 | OPTS_TYPE_PT_ADD80
8294 | OPTS_TYPE_PT_ADDBITS14
8295 | OPTS_TYPE_ST_ADD80
8296 | OPTS_TYPE_ST_HEX;
8297 kern_type = KERN_TYPE_MD55_PWSLT1;
8298 dgst_size = DGST_SIZE_4_4;
8299 parse_func = phps_parse_hash;
8300 sort_by_digest = sort_by_digest_4_4;
8301 opti_type = OPTI_TYPE_ZERO_BYTE
8302 | OPTI_TYPE_PRECOMPUTE_INIT
8303 | OPTI_TYPE_PRECOMPUTE_MERKLE
8304 | OPTI_TYPE_EARLY_SKIP;
8305 dgst_pos0 = 0;
8306 dgst_pos1 = 3;
8307 dgst_pos2 = 2;
8308 dgst_pos3 = 1;
8309 break;
8310
8311 case 2711: hash_type = HASH_TYPE_MD5;
8312 salt_type = SALT_TYPE_INTERN;
8313 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8314 opts_type = OPTS_TYPE_PT_GENERATE_LE
8315 | OPTS_TYPE_PT_ADD80
8316 | OPTS_TYPE_PT_ADDBITS14
8317 | OPTS_TYPE_ST_ADD80;
8318 kern_type = KERN_TYPE_MD55_PWSLT2;
8319 dgst_size = DGST_SIZE_4_4;
8320 parse_func = vb30_parse_hash;
8321 sort_by_digest = sort_by_digest_4_4;
8322 opti_type = OPTI_TYPE_ZERO_BYTE
8323 | OPTI_TYPE_PRECOMPUTE_INIT
8324 | OPTI_TYPE_EARLY_SKIP;
8325 dgst_pos0 = 0;
8326 dgst_pos1 = 3;
8327 dgst_pos2 = 2;
8328 dgst_pos3 = 1;
8329 break;
8330
8331 case 2811: hash_type = HASH_TYPE_MD5;
8332 salt_type = SALT_TYPE_INTERN;
8333 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8334 opts_type = OPTS_TYPE_PT_GENERATE_LE
8335 | OPTS_TYPE_PT_ADD80
8336 | OPTS_TYPE_PT_ADDBITS14;
8337 kern_type = KERN_TYPE_MD55_SLTPW;
8338 dgst_size = DGST_SIZE_4_4;
8339 parse_func = ipb2_parse_hash;
8340 sort_by_digest = sort_by_digest_4_4;
8341 opti_type = OPTI_TYPE_ZERO_BYTE
8342 | OPTI_TYPE_PRECOMPUTE_INIT
8343 | OPTI_TYPE_EARLY_SKIP;
8344 dgst_pos0 = 0;
8345 dgst_pos1 = 3;
8346 dgst_pos2 = 2;
8347 dgst_pos3 = 1;
8348 break;
8349
8350 case 3000: hash_type = HASH_TYPE_LM;
8351 salt_type = SALT_TYPE_NONE;
8352 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8353 opts_type = OPTS_TYPE_PT_GENERATE_LE
8354 | OPTS_TYPE_PT_UPPER
8355 | OPTS_TYPE_PT_BITSLICE;
8356 kern_type = KERN_TYPE_LM;
8357 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8358 parse_func = lm_parse_hash;
8359 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8360 opti_type = OPTI_TYPE_ZERO_BYTE
8361 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8362 dgst_pos0 = 0;
8363 dgst_pos1 = 1;
8364 dgst_pos2 = 2;
8365 dgst_pos3 = 3;
8366 break;
8367
8368 case 3100: hash_type = HASH_TYPE_ORACLEH;
8369 salt_type = SALT_TYPE_INTERN;
8370 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8371 opts_type = OPTS_TYPE_PT_GENERATE_LE
8372 | OPTS_TYPE_PT_UPPER
8373 | OPTS_TYPE_ST_UPPER;
8374 kern_type = KERN_TYPE_ORACLEH;
8375 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8376 parse_func = oracleh_parse_hash;
8377 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8378 opti_type = OPTI_TYPE_ZERO_BYTE;
8379 dgst_pos0 = 0;
8380 dgst_pos1 = 1;
8381 dgst_pos2 = 2;
8382 dgst_pos3 = 3;
8383 break;
8384
8385 case 3200: hash_type = HASH_TYPE_BCRYPT;
8386 salt_type = SALT_TYPE_EMBEDDED;
8387 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8388 opts_type = OPTS_TYPE_PT_GENERATE_LE
8389 | OPTS_TYPE_ST_GENERATE_LE;
8390 kern_type = KERN_TYPE_BCRYPT;
8391 dgst_size = DGST_SIZE_4_6;
8392 parse_func = bcrypt_parse_hash;
8393 sort_by_digest = sort_by_digest_4_6;
8394 opti_type = OPTI_TYPE_ZERO_BYTE;
8395 dgst_pos0 = 0;
8396 dgst_pos1 = 1;
8397 dgst_pos2 = 2;
8398 dgst_pos3 = 3;
8399 break;
8400
8401 case 3710: hash_type = HASH_TYPE_MD5;
8402 salt_type = SALT_TYPE_INTERN;
8403 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8404 opts_type = OPTS_TYPE_PT_GENERATE_LE
8405 | OPTS_TYPE_PT_ADD80
8406 | OPTS_TYPE_PT_ADDBITS14;
8407 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8408 dgst_size = DGST_SIZE_4_4;
8409 parse_func = md5s_parse_hash;
8410 sort_by_digest = sort_by_digest_4_4;
8411 opti_type = OPTI_TYPE_ZERO_BYTE
8412 | OPTI_TYPE_PRECOMPUTE_INIT
8413 | OPTI_TYPE_PRECOMPUTE_MERKLE
8414 | OPTI_TYPE_EARLY_SKIP;
8415 dgst_pos0 = 0;
8416 dgst_pos1 = 3;
8417 dgst_pos2 = 2;
8418 dgst_pos3 = 1;
8419 break;
8420
8421 case 3711: hash_type = HASH_TYPE_MD5;
8422 salt_type = SALT_TYPE_EMBEDDED;
8423 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8424 opts_type = OPTS_TYPE_PT_GENERATE_LE
8425 | OPTS_TYPE_PT_ADD80
8426 | OPTS_TYPE_PT_ADDBITS14;
8427 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8428 dgst_size = DGST_SIZE_4_4;
8429 parse_func = mediawiki_b_parse_hash;
8430 sort_by_digest = sort_by_digest_4_4;
8431 opti_type = OPTI_TYPE_ZERO_BYTE
8432 | OPTI_TYPE_PRECOMPUTE_INIT
8433 | OPTI_TYPE_PRECOMPUTE_MERKLE
8434 | OPTI_TYPE_EARLY_SKIP;
8435 dgst_pos0 = 0;
8436 dgst_pos1 = 3;
8437 dgst_pos2 = 2;
8438 dgst_pos3 = 1;
8439 break;
8440
8441 case 3800: hash_type = HASH_TYPE_MD5;
8442 salt_type = SALT_TYPE_INTERN;
8443 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8444 opts_type = OPTS_TYPE_PT_GENERATE_LE
8445 | OPTS_TYPE_ST_ADDBITS14;
8446 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8447 dgst_size = DGST_SIZE_4_4;
8448 parse_func = md5s_parse_hash;
8449 sort_by_digest = sort_by_digest_4_4;
8450 opti_type = OPTI_TYPE_ZERO_BYTE
8451 | OPTI_TYPE_PRECOMPUTE_INIT
8452 | OPTI_TYPE_PRECOMPUTE_MERKLE
8453 | OPTI_TYPE_EARLY_SKIP
8454 | OPTI_TYPE_NOT_ITERATED
8455 | OPTI_TYPE_RAW_HASH;
8456 dgst_pos0 = 0;
8457 dgst_pos1 = 3;
8458 dgst_pos2 = 2;
8459 dgst_pos3 = 1;
8460 break;
8461
8462 case 4300: hash_type = HASH_TYPE_MD5;
8463 salt_type = SALT_TYPE_VIRTUAL;
8464 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8465 opts_type = OPTS_TYPE_PT_GENERATE_LE
8466 | OPTS_TYPE_PT_ADD80
8467 | OPTS_TYPE_PT_ADDBITS14
8468 | OPTS_TYPE_ST_ADD80;
8469 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8470 dgst_size = DGST_SIZE_4_4;
8471 parse_func = md5md5_parse_hash;
8472 sort_by_digest = sort_by_digest_4_4;
8473 opti_type = OPTI_TYPE_ZERO_BYTE
8474 | OPTI_TYPE_PRECOMPUTE_INIT
8475 | OPTI_TYPE_PRECOMPUTE_MERKLE
8476 | OPTI_TYPE_EARLY_SKIP;
8477 dgst_pos0 = 0;
8478 dgst_pos1 = 3;
8479 dgst_pos2 = 2;
8480 dgst_pos3 = 1;
8481 break;
8482
8483
8484 case 4400: hash_type = HASH_TYPE_MD5;
8485 salt_type = SALT_TYPE_NONE;
8486 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8487 opts_type = OPTS_TYPE_PT_GENERATE_BE
8488 | OPTS_TYPE_PT_ADD80
8489 | OPTS_TYPE_PT_ADDBITS15;
8490 kern_type = KERN_TYPE_MD5_SHA1;
8491 dgst_size = DGST_SIZE_4_4;
8492 parse_func = md5_parse_hash;
8493 sort_by_digest = sort_by_digest_4_4;
8494 opti_type = OPTI_TYPE_ZERO_BYTE
8495 | OPTI_TYPE_PRECOMPUTE_INIT
8496 | OPTI_TYPE_PRECOMPUTE_MERKLE
8497 | OPTI_TYPE_EARLY_SKIP
8498 | OPTI_TYPE_NOT_ITERATED
8499 | OPTI_TYPE_NOT_SALTED
8500 | OPTI_TYPE_RAW_HASH;
8501 dgst_pos0 = 0;
8502 dgst_pos1 = 3;
8503 dgst_pos2 = 2;
8504 dgst_pos3 = 1;
8505 break;
8506
8507 case 4500: hash_type = HASH_TYPE_SHA1;
8508 salt_type = SALT_TYPE_NONE;
8509 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8510 opts_type = OPTS_TYPE_PT_GENERATE_BE
8511 | OPTS_TYPE_PT_ADD80
8512 | OPTS_TYPE_PT_ADDBITS15;
8513 kern_type = KERN_TYPE_SHA11;
8514 dgst_size = DGST_SIZE_4_5;
8515 parse_func = sha1_parse_hash;
8516 sort_by_digest = sort_by_digest_4_5;
8517 opti_type = OPTI_TYPE_ZERO_BYTE
8518 | OPTI_TYPE_PRECOMPUTE_INIT
8519 | OPTI_TYPE_PRECOMPUTE_MERKLE
8520 | OPTI_TYPE_EARLY_SKIP
8521 | OPTI_TYPE_NOT_SALTED;
8522 dgst_pos0 = 3;
8523 dgst_pos1 = 4;
8524 dgst_pos2 = 2;
8525 dgst_pos3 = 1;
8526 break;
8527
8528 case 4700: hash_type = HASH_TYPE_SHA1;
8529 salt_type = SALT_TYPE_NONE;
8530 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8531 opts_type = OPTS_TYPE_PT_GENERATE_LE
8532 | OPTS_TYPE_PT_ADD80
8533 | OPTS_TYPE_PT_ADDBITS14;
8534 kern_type = KERN_TYPE_SHA1_MD5;
8535 dgst_size = DGST_SIZE_4_5;
8536 parse_func = sha1_parse_hash;
8537 sort_by_digest = sort_by_digest_4_5;
8538 opti_type = OPTI_TYPE_ZERO_BYTE
8539 | OPTI_TYPE_PRECOMPUTE_INIT
8540 | OPTI_TYPE_PRECOMPUTE_MERKLE
8541 | OPTI_TYPE_EARLY_SKIP
8542 | OPTI_TYPE_NOT_ITERATED
8543 | OPTI_TYPE_NOT_SALTED
8544 | OPTI_TYPE_RAW_HASH;
8545 dgst_pos0 = 3;
8546 dgst_pos1 = 4;
8547 dgst_pos2 = 2;
8548 dgst_pos3 = 1;
8549 break;
8550
8551 case 4800: hash_type = HASH_TYPE_MD5;
8552 salt_type = SALT_TYPE_EMBEDDED;
8553 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8554 opts_type = OPTS_TYPE_PT_GENERATE_LE
8555 | OPTS_TYPE_PT_ADDBITS14;
8556 kern_type = KERN_TYPE_MD5_CHAP;
8557 dgst_size = DGST_SIZE_4_4;
8558 parse_func = chap_parse_hash;
8559 sort_by_digest = sort_by_digest_4_4;
8560 opti_type = OPTI_TYPE_ZERO_BYTE
8561 | OPTI_TYPE_PRECOMPUTE_INIT
8562 | OPTI_TYPE_PRECOMPUTE_MERKLE
8563 | OPTI_TYPE_MEET_IN_MIDDLE
8564 | OPTI_TYPE_EARLY_SKIP
8565 | OPTI_TYPE_NOT_ITERATED
8566 | OPTI_TYPE_RAW_HASH;
8567 dgst_pos0 = 0;
8568 dgst_pos1 = 3;
8569 dgst_pos2 = 2;
8570 dgst_pos3 = 1;
8571 break;
8572
8573 case 4900: hash_type = HASH_TYPE_SHA1;
8574 salt_type = SALT_TYPE_INTERN;
8575 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8576 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8577 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8578 dgst_size = DGST_SIZE_4_5;
8579 parse_func = sha1s_parse_hash;
8580 sort_by_digest = sort_by_digest_4_5;
8581 opti_type = OPTI_TYPE_ZERO_BYTE
8582 | OPTI_TYPE_PRECOMPUTE_INIT
8583 | OPTI_TYPE_PRECOMPUTE_MERKLE
8584 | OPTI_TYPE_EARLY_SKIP;
8585 dgst_pos0 = 3;
8586 dgst_pos1 = 4;
8587 dgst_pos2 = 2;
8588 dgst_pos3 = 1;
8589 break;
8590
8591 case 5000: hash_type = HASH_TYPE_KECCAK;
8592 salt_type = SALT_TYPE_EMBEDDED;
8593 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8594 opts_type = OPTS_TYPE_PT_GENERATE_LE
8595 | OPTS_TYPE_PT_ADD01;
8596 kern_type = KERN_TYPE_KECCAK;
8597 dgst_size = DGST_SIZE_8_25;
8598 parse_func = keccak_parse_hash;
8599 sort_by_digest = sort_by_digest_8_25;
8600 opti_type = OPTI_TYPE_ZERO_BYTE
8601 | OPTI_TYPE_USES_BITS_64
8602 | OPTI_TYPE_RAW_HASH;
8603 dgst_pos0 = 2;
8604 dgst_pos1 = 3;
8605 dgst_pos2 = 4;
8606 dgst_pos3 = 5;
8607 break;
8608
8609 case 5100: hash_type = HASH_TYPE_MD5H;
8610 salt_type = SALT_TYPE_NONE;
8611 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8612 opts_type = OPTS_TYPE_PT_GENERATE_LE
8613 | OPTS_TYPE_PT_ADD80
8614 | OPTS_TYPE_PT_ADDBITS14;
8615 kern_type = KERN_TYPE_MD5H;
8616 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8617 parse_func = md5half_parse_hash;
8618 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8619 opti_type = OPTI_TYPE_ZERO_BYTE
8620 | OPTI_TYPE_RAW_HASH;
8621 dgst_pos0 = 0;
8622 dgst_pos1 = 1;
8623 dgst_pos2 = 2;
8624 dgst_pos3 = 3;
8625 break;
8626
8627 case 5200: hash_type = HASH_TYPE_SHA256;
8628 salt_type = SALT_TYPE_EMBEDDED;
8629 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8630 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8631 kern_type = KERN_TYPE_PSAFE3;
8632 dgst_size = DGST_SIZE_4_8;
8633 parse_func = psafe3_parse_hash;
8634 sort_by_digest = sort_by_digest_4_8;
8635 opti_type = OPTI_TYPE_ZERO_BYTE;
8636 dgst_pos0 = 0;
8637 dgst_pos1 = 1;
8638 dgst_pos2 = 2;
8639 dgst_pos3 = 3;
8640 break;
8641
8642 case 5300: hash_type = HASH_TYPE_MD5;
8643 salt_type = SALT_TYPE_EMBEDDED;
8644 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8645 opts_type = OPTS_TYPE_PT_GENERATE_LE
8646 | OPTS_TYPE_ST_ADD80;
8647 kern_type = KERN_TYPE_IKEPSK_MD5;
8648 dgst_size = DGST_SIZE_4_4;
8649 parse_func = ikepsk_md5_parse_hash;
8650 sort_by_digest = sort_by_digest_4_4;
8651 opti_type = OPTI_TYPE_ZERO_BYTE;
8652 dgst_pos0 = 0;
8653 dgst_pos1 = 3;
8654 dgst_pos2 = 2;
8655 dgst_pos3 = 1;
8656 break;
8657
8658 case 5400: hash_type = HASH_TYPE_SHA1;
8659 salt_type = SALT_TYPE_EMBEDDED;
8660 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8661 opts_type = OPTS_TYPE_PT_GENERATE_BE
8662 | OPTS_TYPE_ST_ADD80;
8663 kern_type = KERN_TYPE_IKEPSK_SHA1;
8664 dgst_size = DGST_SIZE_4_5;
8665 parse_func = ikepsk_sha1_parse_hash;
8666 sort_by_digest = sort_by_digest_4_5;
8667 opti_type = OPTI_TYPE_ZERO_BYTE;
8668 dgst_pos0 = 3;
8669 dgst_pos1 = 4;
8670 dgst_pos2 = 2;
8671 dgst_pos3 = 1;
8672 break;
8673
8674 case 5500: hash_type = HASH_TYPE_NETNTLM;
8675 salt_type = SALT_TYPE_EMBEDDED;
8676 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8677 opts_type = OPTS_TYPE_PT_GENERATE_LE
8678 | OPTS_TYPE_PT_ADD80
8679 | OPTS_TYPE_PT_ADDBITS14
8680 | OPTS_TYPE_PT_UNICODE
8681 | OPTS_TYPE_ST_HEX;
8682 kern_type = KERN_TYPE_NETNTLMv1;
8683 dgst_size = DGST_SIZE_4_4;
8684 parse_func = netntlmv1_parse_hash;
8685 sort_by_digest = sort_by_digest_4_4;
8686 opti_type = OPTI_TYPE_ZERO_BYTE
8687 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8688 dgst_pos0 = 0;
8689 dgst_pos1 = 1;
8690 dgst_pos2 = 2;
8691 dgst_pos3 = 3;
8692 break;
8693
8694 case 5600: hash_type = HASH_TYPE_MD5;
8695 salt_type = SALT_TYPE_EMBEDDED;
8696 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8697 opts_type = OPTS_TYPE_PT_GENERATE_LE
8698 | OPTS_TYPE_PT_ADD80
8699 | OPTS_TYPE_PT_ADDBITS14
8700 | OPTS_TYPE_PT_UNICODE;
8701 kern_type = KERN_TYPE_NETNTLMv2;
8702 dgst_size = DGST_SIZE_4_4;
8703 parse_func = netntlmv2_parse_hash;
8704 sort_by_digest = sort_by_digest_4_4;
8705 opti_type = OPTI_TYPE_ZERO_BYTE;
8706 dgst_pos0 = 0;
8707 dgst_pos1 = 3;
8708 dgst_pos2 = 2;
8709 dgst_pos3 = 1;
8710 break;
8711
8712 case 5700: hash_type = HASH_TYPE_SHA256;
8713 salt_type = SALT_TYPE_NONE;
8714 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8715 opts_type = OPTS_TYPE_PT_GENERATE_BE
8716 | OPTS_TYPE_PT_ADD80
8717 | OPTS_TYPE_PT_ADDBITS15;
8718 kern_type = KERN_TYPE_SHA256;
8719 dgst_size = DGST_SIZE_4_8;
8720 parse_func = cisco4_parse_hash;
8721 sort_by_digest = sort_by_digest_4_8;
8722 opti_type = OPTI_TYPE_ZERO_BYTE
8723 | OPTI_TYPE_PRECOMPUTE_INIT
8724 | OPTI_TYPE_PRECOMPUTE_MERKLE
8725 | OPTI_TYPE_EARLY_SKIP
8726 | OPTI_TYPE_NOT_ITERATED
8727 | OPTI_TYPE_NOT_SALTED
8728 | OPTI_TYPE_RAW_HASH;
8729 dgst_pos0 = 3;
8730 dgst_pos1 = 7;
8731 dgst_pos2 = 2;
8732 dgst_pos3 = 6;
8733 break;
8734
8735 case 5800: hash_type = HASH_TYPE_SHA1;
8736 salt_type = SALT_TYPE_INTERN;
8737 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8738 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8739 | OPTS_TYPE_ST_ADD80;
8740 kern_type = KERN_TYPE_ANDROIDPIN;
8741 dgst_size = DGST_SIZE_4_5;
8742 parse_func = androidpin_parse_hash;
8743 sort_by_digest = sort_by_digest_4_5;
8744 opti_type = OPTI_TYPE_ZERO_BYTE;
8745 dgst_pos0 = 0;
8746 dgst_pos1 = 1;
8747 dgst_pos2 = 2;
8748 dgst_pos3 = 3;
8749 break;
8750
8751 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8752 salt_type = SALT_TYPE_NONE;
8753 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8754 opts_type = OPTS_TYPE_PT_GENERATE_LE
8755 | OPTS_TYPE_PT_ADD80;
8756 kern_type = KERN_TYPE_RIPEMD160;
8757 dgst_size = DGST_SIZE_4_5;
8758 parse_func = ripemd160_parse_hash;
8759 sort_by_digest = sort_by_digest_4_5;
8760 opti_type = OPTI_TYPE_ZERO_BYTE;
8761 dgst_pos0 = 0;
8762 dgst_pos1 = 1;
8763 dgst_pos2 = 2;
8764 dgst_pos3 = 3;
8765 break;
8766
8767 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8768 salt_type = SALT_TYPE_NONE;
8769 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8770 opts_type = OPTS_TYPE_PT_GENERATE_BE
8771 | OPTS_TYPE_PT_ADD80;
8772 kern_type = KERN_TYPE_WHIRLPOOL;
8773 dgst_size = DGST_SIZE_4_16;
8774 parse_func = whirlpool_parse_hash;
8775 sort_by_digest = sort_by_digest_4_16;
8776 opti_type = OPTI_TYPE_ZERO_BYTE;
8777 dgst_pos0 = 0;
8778 dgst_pos1 = 1;
8779 dgst_pos2 = 2;
8780 dgst_pos3 = 3;
8781 break;
8782
8783 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8784 salt_type = SALT_TYPE_EMBEDDED;
8785 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8786 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8787 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8788 dgst_size = DGST_SIZE_4_5;
8789 parse_func = truecrypt_parse_hash_2k;
8790 sort_by_digest = sort_by_digest_4_5;
8791 opti_type = OPTI_TYPE_ZERO_BYTE;
8792 dgst_pos0 = 0;
8793 dgst_pos1 = 1;
8794 dgst_pos2 = 2;
8795 dgst_pos3 = 3;
8796 break;
8797
8798 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8799 salt_type = SALT_TYPE_EMBEDDED;
8800 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8801 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8802 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8803 dgst_size = DGST_SIZE_4_5;
8804 parse_func = truecrypt_parse_hash_2k;
8805 sort_by_digest = sort_by_digest_4_5;
8806 opti_type = OPTI_TYPE_ZERO_BYTE;
8807 dgst_pos0 = 0;
8808 dgst_pos1 = 1;
8809 dgst_pos2 = 2;
8810 dgst_pos3 = 3;
8811 break;
8812
8813 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8814 salt_type = SALT_TYPE_EMBEDDED;
8815 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8816 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8817 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8818 dgst_size = DGST_SIZE_4_5;
8819 parse_func = truecrypt_parse_hash_2k;
8820 sort_by_digest = sort_by_digest_4_5;
8821 opti_type = OPTI_TYPE_ZERO_BYTE;
8822 dgst_pos0 = 0;
8823 dgst_pos1 = 1;
8824 dgst_pos2 = 2;
8825 dgst_pos3 = 3;
8826 break;
8827
8828 case 6221: hash_type = HASH_TYPE_SHA512;
8829 salt_type = SALT_TYPE_EMBEDDED;
8830 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8831 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8832 kern_type = KERN_TYPE_TCSHA512_XTS512;
8833 dgst_size = DGST_SIZE_8_8;
8834 parse_func = truecrypt_parse_hash_1k;
8835 sort_by_digest = sort_by_digest_8_8;
8836 opti_type = OPTI_TYPE_ZERO_BYTE
8837 | OPTI_TYPE_USES_BITS_64;
8838 dgst_pos0 = 0;
8839 dgst_pos1 = 1;
8840 dgst_pos2 = 2;
8841 dgst_pos3 = 3;
8842 break;
8843
8844 case 6222: hash_type = HASH_TYPE_SHA512;
8845 salt_type = SALT_TYPE_EMBEDDED;
8846 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8847 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8848 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8849 dgst_size = DGST_SIZE_8_8;
8850 parse_func = truecrypt_parse_hash_1k;
8851 sort_by_digest = sort_by_digest_8_8;
8852 opti_type = OPTI_TYPE_ZERO_BYTE
8853 | OPTI_TYPE_USES_BITS_64;
8854 dgst_pos0 = 0;
8855 dgst_pos1 = 1;
8856 dgst_pos2 = 2;
8857 dgst_pos3 = 3;
8858 break;
8859
8860 case 6223: hash_type = HASH_TYPE_SHA512;
8861 salt_type = SALT_TYPE_EMBEDDED;
8862 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8863 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8864 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8865 dgst_size = DGST_SIZE_8_8;
8866 parse_func = truecrypt_parse_hash_1k;
8867 sort_by_digest = sort_by_digest_8_8;
8868 opti_type = OPTI_TYPE_ZERO_BYTE
8869 | OPTI_TYPE_USES_BITS_64;
8870 dgst_pos0 = 0;
8871 dgst_pos1 = 1;
8872 dgst_pos2 = 2;
8873 dgst_pos3 = 3;
8874 break;
8875
8876 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8877 salt_type = SALT_TYPE_EMBEDDED;
8878 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8879 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8880 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8881 dgst_size = DGST_SIZE_4_8;
8882 parse_func = truecrypt_parse_hash_1k;
8883 sort_by_digest = sort_by_digest_4_8;
8884 opti_type = OPTI_TYPE_ZERO_BYTE;
8885 dgst_pos0 = 0;
8886 dgst_pos1 = 1;
8887 dgst_pos2 = 2;
8888 dgst_pos3 = 3;
8889 break;
8890
8891 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8892 salt_type = SALT_TYPE_EMBEDDED;
8893 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8894 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8895 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8896 dgst_size = DGST_SIZE_4_8;
8897 parse_func = truecrypt_parse_hash_1k;
8898 sort_by_digest = sort_by_digest_4_8;
8899 opti_type = OPTI_TYPE_ZERO_BYTE;
8900 dgst_pos0 = 0;
8901 dgst_pos1 = 1;
8902 dgst_pos2 = 2;
8903 dgst_pos3 = 3;
8904 break;
8905
8906 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8907 salt_type = SALT_TYPE_EMBEDDED;
8908 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8909 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8910 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8911 dgst_size = DGST_SIZE_4_8;
8912 parse_func = truecrypt_parse_hash_1k;
8913 sort_by_digest = sort_by_digest_4_8;
8914 opti_type = OPTI_TYPE_ZERO_BYTE;
8915 dgst_pos0 = 0;
8916 dgst_pos1 = 1;
8917 dgst_pos2 = 2;
8918 dgst_pos3 = 3;
8919 break;
8920
8921 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8922 salt_type = SALT_TYPE_EMBEDDED;
8923 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8924 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8925 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8926 dgst_size = DGST_SIZE_4_5;
8927 parse_func = truecrypt_parse_hash_1k;
8928 sort_by_digest = sort_by_digest_4_5;
8929 opti_type = OPTI_TYPE_ZERO_BYTE;
8930 dgst_pos0 = 0;
8931 dgst_pos1 = 1;
8932 dgst_pos2 = 2;
8933 dgst_pos3 = 3;
8934 break;
8935
8936 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8937 salt_type = SALT_TYPE_EMBEDDED;
8938 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8939 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8940 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8941 dgst_size = DGST_SIZE_4_5;
8942 parse_func = truecrypt_parse_hash_1k;
8943 sort_by_digest = sort_by_digest_4_5;
8944 opti_type = OPTI_TYPE_ZERO_BYTE;
8945 dgst_pos0 = 0;
8946 dgst_pos1 = 1;
8947 dgst_pos2 = 2;
8948 dgst_pos3 = 3;
8949 break;
8950
8951 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8952 salt_type = SALT_TYPE_EMBEDDED;
8953 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8954 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8955 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8956 dgst_size = DGST_SIZE_4_5;
8957 parse_func = truecrypt_parse_hash_1k;
8958 sort_by_digest = sort_by_digest_4_5;
8959 opti_type = OPTI_TYPE_ZERO_BYTE;
8960 dgst_pos0 = 0;
8961 dgst_pos1 = 1;
8962 dgst_pos2 = 2;
8963 dgst_pos3 = 3;
8964 break;
8965
8966 case 6300: hash_type = HASH_TYPE_MD5;
8967 salt_type = SALT_TYPE_EMBEDDED;
8968 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8969 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8970 kern_type = KERN_TYPE_MD5AIX;
8971 dgst_size = DGST_SIZE_4_4;
8972 parse_func = md5aix_parse_hash;
8973 sort_by_digest = sort_by_digest_4_4;
8974 opti_type = OPTI_TYPE_ZERO_BYTE;
8975 dgst_pos0 = 0;
8976 dgst_pos1 = 1;
8977 dgst_pos2 = 2;
8978 dgst_pos3 = 3;
8979 break;
8980
8981 case 6400: hash_type = HASH_TYPE_SHA256;
8982 salt_type = SALT_TYPE_EMBEDDED;
8983 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8984 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8985 kern_type = KERN_TYPE_SHA256AIX;
8986 dgst_size = DGST_SIZE_4_8;
8987 parse_func = sha256aix_parse_hash;
8988 sort_by_digest = sort_by_digest_4_8;
8989 opti_type = OPTI_TYPE_ZERO_BYTE;
8990 dgst_pos0 = 0;
8991 dgst_pos1 = 1;
8992 dgst_pos2 = 2;
8993 dgst_pos3 = 3;
8994 break;
8995
8996 case 6500: hash_type = HASH_TYPE_SHA512;
8997 salt_type = SALT_TYPE_EMBEDDED;
8998 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8999 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9000 kern_type = KERN_TYPE_SHA512AIX;
9001 dgst_size = DGST_SIZE_8_8;
9002 parse_func = sha512aix_parse_hash;
9003 sort_by_digest = sort_by_digest_8_8;
9004 opti_type = OPTI_TYPE_ZERO_BYTE
9005 | OPTI_TYPE_USES_BITS_64;
9006 dgst_pos0 = 0;
9007 dgst_pos1 = 1;
9008 dgst_pos2 = 2;
9009 dgst_pos3 = 3;
9010 break;
9011
9012 case 6600: hash_type = HASH_TYPE_AES;
9013 salt_type = SALT_TYPE_EMBEDDED;
9014 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9015 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9016 kern_type = KERN_TYPE_AGILEKEY;
9017 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9018 parse_func = agilekey_parse_hash;
9019 sort_by_digest = sort_by_digest_4_5;
9020 opti_type = OPTI_TYPE_ZERO_BYTE;
9021 dgst_pos0 = 0;
9022 dgst_pos1 = 1;
9023 dgst_pos2 = 2;
9024 dgst_pos3 = 3;
9025 break;
9026
9027 case 6700: hash_type = HASH_TYPE_SHA1;
9028 salt_type = SALT_TYPE_EMBEDDED;
9029 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9030 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9031 kern_type = KERN_TYPE_SHA1AIX;
9032 dgst_size = DGST_SIZE_4_5;
9033 parse_func = sha1aix_parse_hash;
9034 sort_by_digest = sort_by_digest_4_5;
9035 opti_type = OPTI_TYPE_ZERO_BYTE;
9036 dgst_pos0 = 0;
9037 dgst_pos1 = 1;
9038 dgst_pos2 = 2;
9039 dgst_pos3 = 3;
9040 break;
9041
9042 case 6800: hash_type = HASH_TYPE_AES;
9043 salt_type = SALT_TYPE_EMBEDDED;
9044 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9045 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9046 kern_type = KERN_TYPE_LASTPASS;
9047 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9048 parse_func = lastpass_parse_hash;
9049 sort_by_digest = sort_by_digest_4_8;
9050 opti_type = OPTI_TYPE_ZERO_BYTE;
9051 dgst_pos0 = 0;
9052 dgst_pos1 = 1;
9053 dgst_pos2 = 2;
9054 dgst_pos3 = 3;
9055 break;
9056
9057 case 6900: hash_type = HASH_TYPE_GOST;
9058 salt_type = SALT_TYPE_NONE;
9059 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9060 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9061 kern_type = KERN_TYPE_GOST;
9062 dgst_size = DGST_SIZE_4_8;
9063 parse_func = gost_parse_hash;
9064 sort_by_digest = sort_by_digest_4_8;
9065 opti_type = OPTI_TYPE_ZERO_BYTE;
9066 dgst_pos0 = 0;
9067 dgst_pos1 = 1;
9068 dgst_pos2 = 2;
9069 dgst_pos3 = 3;
9070 break;
9071
9072 case 7100: hash_type = HASH_TYPE_SHA512;
9073 salt_type = SALT_TYPE_EMBEDDED;
9074 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9075 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9076 kern_type = KERN_TYPE_PBKDF2_SHA512;
9077 dgst_size = DGST_SIZE_8_16;
9078 parse_func = sha512osx_parse_hash;
9079 sort_by_digest = sort_by_digest_8_16;
9080 opti_type = OPTI_TYPE_ZERO_BYTE
9081 | OPTI_TYPE_USES_BITS_64;
9082 dgst_pos0 = 0;
9083 dgst_pos1 = 1;
9084 dgst_pos2 = 2;
9085 dgst_pos3 = 3;
9086 break;
9087
9088 case 7200: hash_type = HASH_TYPE_SHA512;
9089 salt_type = SALT_TYPE_EMBEDDED;
9090 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9091 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9092 kern_type = KERN_TYPE_PBKDF2_SHA512;
9093 dgst_size = DGST_SIZE_8_16;
9094 parse_func = sha512grub_parse_hash;
9095 sort_by_digest = sort_by_digest_8_16;
9096 opti_type = OPTI_TYPE_ZERO_BYTE
9097 | OPTI_TYPE_USES_BITS_64;
9098 dgst_pos0 = 0;
9099 dgst_pos1 = 1;
9100 dgst_pos2 = 2;
9101 dgst_pos3 = 3;
9102 break;
9103
9104 case 7300: hash_type = HASH_TYPE_SHA1;
9105 salt_type = SALT_TYPE_EMBEDDED;
9106 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9107 opts_type = OPTS_TYPE_PT_GENERATE_BE
9108 | OPTS_TYPE_ST_ADD80
9109 | OPTS_TYPE_ST_ADDBITS15;
9110 kern_type = KERN_TYPE_RAKP;
9111 dgst_size = DGST_SIZE_4_5;
9112 parse_func = rakp_parse_hash;
9113 sort_by_digest = sort_by_digest_4_5;
9114 opti_type = OPTI_TYPE_ZERO_BYTE
9115 | OPTI_TYPE_NOT_ITERATED;
9116 dgst_pos0 = 3;
9117 dgst_pos1 = 4;
9118 dgst_pos2 = 2;
9119 dgst_pos3 = 1;
9120 break;
9121
9122 case 7400: hash_type = HASH_TYPE_SHA256;
9123 salt_type = SALT_TYPE_EMBEDDED;
9124 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9125 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9126 kern_type = KERN_TYPE_SHA256CRYPT;
9127 dgst_size = DGST_SIZE_4_8;
9128 parse_func = sha256crypt_parse_hash;
9129 sort_by_digest = sort_by_digest_4_8;
9130 opti_type = OPTI_TYPE_ZERO_BYTE;
9131 dgst_pos0 = 0;
9132 dgst_pos1 = 1;
9133 dgst_pos2 = 2;
9134 dgst_pos3 = 3;
9135 break;
9136
9137 case 7500: hash_type = HASH_TYPE_KRB5PA;
9138 salt_type = SALT_TYPE_EMBEDDED;
9139 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9140 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9141 kern_type = KERN_TYPE_KRB5PA;
9142 dgst_size = DGST_SIZE_4_4;
9143 parse_func = krb5pa_parse_hash;
9144 sort_by_digest = sort_by_digest_4_4;
9145 opti_type = OPTI_TYPE_ZERO_BYTE
9146 | OPTI_TYPE_NOT_ITERATED;
9147 dgst_pos0 = 0;
9148 dgst_pos1 = 1;
9149 dgst_pos2 = 2;
9150 dgst_pos3 = 3;
9151 break;
9152
9153 case 7600: hash_type = HASH_TYPE_SHA1;
9154 salt_type = SALT_TYPE_INTERN;
9155 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9156 opts_type = OPTS_TYPE_PT_GENERATE_BE
9157 | OPTS_TYPE_PT_ADD80
9158 | OPTS_TYPE_PT_ADDBITS15;
9159 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9160 dgst_size = DGST_SIZE_4_5;
9161 parse_func = redmine_parse_hash;
9162 sort_by_digest = sort_by_digest_4_5;
9163 opti_type = OPTI_TYPE_ZERO_BYTE
9164 | OPTI_TYPE_PRECOMPUTE_INIT
9165 | OPTI_TYPE_EARLY_SKIP
9166 | OPTI_TYPE_NOT_ITERATED
9167 | OPTI_TYPE_PREPENDED_SALT;
9168 dgst_pos0 = 3;
9169 dgst_pos1 = 4;
9170 dgst_pos2 = 2;
9171 dgst_pos3 = 1;
9172 break;
9173
9174 case 7700: hash_type = HASH_TYPE_SAPB;
9175 salt_type = SALT_TYPE_EMBEDDED;
9176 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9177 opts_type = OPTS_TYPE_PT_GENERATE_LE
9178 | OPTS_TYPE_PT_UPPER
9179 | OPTS_TYPE_ST_UPPER;
9180 kern_type = KERN_TYPE_SAPB;
9181 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9182 parse_func = sapb_parse_hash;
9183 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9184 opti_type = OPTI_TYPE_ZERO_BYTE
9185 | OPTI_TYPE_PRECOMPUTE_INIT
9186 | OPTI_TYPE_NOT_ITERATED;
9187 dgst_pos0 = 0;
9188 dgst_pos1 = 1;
9189 dgst_pos2 = 2;
9190 dgst_pos3 = 3;
9191 break;
9192
9193 case 7800: hash_type = HASH_TYPE_SAPG;
9194 salt_type = SALT_TYPE_EMBEDDED;
9195 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9196 opts_type = OPTS_TYPE_PT_GENERATE_BE
9197 | OPTS_TYPE_ST_ADD80
9198 | OPTS_TYPE_ST_UPPER;
9199 kern_type = KERN_TYPE_SAPG;
9200 dgst_size = DGST_SIZE_4_5;
9201 parse_func = sapg_parse_hash;
9202 sort_by_digest = sort_by_digest_4_5;
9203 opti_type = OPTI_TYPE_ZERO_BYTE
9204 | OPTI_TYPE_PRECOMPUTE_INIT
9205 | OPTI_TYPE_NOT_ITERATED;
9206 dgst_pos0 = 3;
9207 dgst_pos1 = 4;
9208 dgst_pos2 = 2;
9209 dgst_pos3 = 1;
9210 break;
9211
9212 case 7900: hash_type = HASH_TYPE_SHA512;
9213 salt_type = SALT_TYPE_EMBEDDED;
9214 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9215 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9216 kern_type = KERN_TYPE_DRUPAL7;
9217 dgst_size = DGST_SIZE_8_8;
9218 parse_func = drupal7_parse_hash;
9219 sort_by_digest = sort_by_digest_8_8;
9220 opti_type = OPTI_TYPE_ZERO_BYTE
9221 | OPTI_TYPE_USES_BITS_64;
9222 dgst_pos0 = 0;
9223 dgst_pos1 = 1;
9224 dgst_pos2 = 2;
9225 dgst_pos3 = 3;
9226 break;
9227
9228 case 8000: hash_type = HASH_TYPE_SHA256;
9229 salt_type = SALT_TYPE_EMBEDDED;
9230 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9231 opts_type = OPTS_TYPE_PT_GENERATE_BE
9232 | OPTS_TYPE_PT_UNICODE
9233 | OPTS_TYPE_ST_ADD80
9234 | OPTS_TYPE_ST_HEX;
9235 kern_type = KERN_TYPE_SYBASEASE;
9236 dgst_size = DGST_SIZE_4_8;
9237 parse_func = sybasease_parse_hash;
9238 sort_by_digest = sort_by_digest_4_8;
9239 opti_type = OPTI_TYPE_ZERO_BYTE
9240 | OPTI_TYPE_PRECOMPUTE_INIT
9241 | OPTI_TYPE_EARLY_SKIP
9242 | OPTI_TYPE_NOT_ITERATED
9243 | OPTI_TYPE_RAW_HASH;
9244 dgst_pos0 = 3;
9245 dgst_pos1 = 7;
9246 dgst_pos2 = 2;
9247 dgst_pos3 = 6;
9248 break;
9249
9250 case 8100: hash_type = HASH_TYPE_SHA1;
9251 salt_type = SALT_TYPE_EMBEDDED;
9252 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9253 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9254 kern_type = KERN_TYPE_NETSCALER;
9255 dgst_size = DGST_SIZE_4_5;
9256 parse_func = netscaler_parse_hash;
9257 sort_by_digest = sort_by_digest_4_5;
9258 opti_type = OPTI_TYPE_ZERO_BYTE
9259 | OPTI_TYPE_PRECOMPUTE_INIT
9260 | OPTI_TYPE_PRECOMPUTE_MERKLE
9261 | OPTI_TYPE_EARLY_SKIP
9262 | OPTI_TYPE_NOT_ITERATED
9263 | OPTI_TYPE_PREPENDED_SALT
9264 | OPTI_TYPE_RAW_HASH;
9265 dgst_pos0 = 3;
9266 dgst_pos1 = 4;
9267 dgst_pos2 = 2;
9268 dgst_pos3 = 1;
9269 break;
9270
9271 case 8200: hash_type = HASH_TYPE_SHA256;
9272 salt_type = SALT_TYPE_EMBEDDED;
9273 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9274 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9275 kern_type = KERN_TYPE_CLOUDKEY;
9276 dgst_size = DGST_SIZE_4_8;
9277 parse_func = cloudkey_parse_hash;
9278 sort_by_digest = sort_by_digest_4_8;
9279 opti_type = OPTI_TYPE_ZERO_BYTE;
9280 dgst_pos0 = 0;
9281 dgst_pos1 = 1;
9282 dgst_pos2 = 2;
9283 dgst_pos3 = 3;
9284 break;
9285
9286 case 8300: hash_type = HASH_TYPE_SHA1;
9287 salt_type = SALT_TYPE_EMBEDDED;
9288 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9289 opts_type = OPTS_TYPE_PT_GENERATE_LE
9290 | OPTS_TYPE_ST_HEX
9291 | OPTS_TYPE_ST_ADD80;
9292 kern_type = KERN_TYPE_NSEC3;
9293 dgst_size = DGST_SIZE_4_5;
9294 parse_func = nsec3_parse_hash;
9295 sort_by_digest = sort_by_digest_4_5;
9296 opti_type = OPTI_TYPE_ZERO_BYTE;
9297 dgst_pos0 = 3;
9298 dgst_pos1 = 4;
9299 dgst_pos2 = 2;
9300 dgst_pos3 = 1;
9301 break;
9302
9303 case 8400: hash_type = HASH_TYPE_SHA1;
9304 salt_type = SALT_TYPE_INTERN;
9305 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9306 opts_type = OPTS_TYPE_PT_GENERATE_BE
9307 | OPTS_TYPE_PT_ADD80
9308 | OPTS_TYPE_PT_ADDBITS15;
9309 kern_type = KERN_TYPE_WBB3;
9310 dgst_size = DGST_SIZE_4_5;
9311 parse_func = wbb3_parse_hash;
9312 sort_by_digest = sort_by_digest_4_5;
9313 opti_type = OPTI_TYPE_ZERO_BYTE
9314 | OPTI_TYPE_PRECOMPUTE_INIT
9315 | OPTI_TYPE_NOT_ITERATED;
9316 dgst_pos0 = 3;
9317 dgst_pos1 = 4;
9318 dgst_pos2 = 2;
9319 dgst_pos3 = 1;
9320 break;
9321
9322 case 8500: hash_type = HASH_TYPE_DESRACF;
9323 salt_type = SALT_TYPE_EMBEDDED;
9324 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9325 opts_type = OPTS_TYPE_PT_GENERATE_LE
9326 | OPTS_TYPE_ST_UPPER;
9327 kern_type = KERN_TYPE_RACF;
9328 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9329 parse_func = racf_parse_hash;
9330 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9331 opti_type = OPTI_TYPE_ZERO_BYTE
9332 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9333 dgst_pos0 = 0;
9334 dgst_pos1 = 1;
9335 dgst_pos2 = 2;
9336 dgst_pos3 = 3;
9337 break;
9338
9339 case 8600: hash_type = HASH_TYPE_LOTUS5;
9340 salt_type = SALT_TYPE_NONE;
9341 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9342 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9343 kern_type = KERN_TYPE_LOTUS5;
9344 dgst_size = DGST_SIZE_4_4;
9345 parse_func = lotus5_parse_hash;
9346 sort_by_digest = sort_by_digest_4_4;
9347 opti_type = OPTI_TYPE_EARLY_SKIP
9348 | OPTI_TYPE_NOT_ITERATED
9349 | OPTI_TYPE_NOT_SALTED
9350 | OPTI_TYPE_RAW_HASH;
9351 dgst_pos0 = 0;
9352 dgst_pos1 = 1;
9353 dgst_pos2 = 2;
9354 dgst_pos3 = 3;
9355 break;
9356
9357 case 8700: hash_type = HASH_TYPE_LOTUS6;
9358 salt_type = SALT_TYPE_EMBEDDED;
9359 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9360 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9361 kern_type = KERN_TYPE_LOTUS6;
9362 dgst_size = DGST_SIZE_4_4;
9363 parse_func = lotus6_parse_hash;
9364 sort_by_digest = sort_by_digest_4_4;
9365 opti_type = OPTI_TYPE_EARLY_SKIP
9366 | OPTI_TYPE_NOT_ITERATED
9367 | OPTI_TYPE_RAW_HASH;
9368 dgst_pos0 = 0;
9369 dgst_pos1 = 1;
9370 dgst_pos2 = 2;
9371 dgst_pos3 = 3;
9372 break;
9373
9374 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9375 salt_type = SALT_TYPE_EMBEDDED;
9376 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9377 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9378 kern_type = KERN_TYPE_ANDROIDFDE;
9379 dgst_size = DGST_SIZE_4_4;
9380 parse_func = androidfde_parse_hash;
9381 sort_by_digest = sort_by_digest_4_4;
9382 opti_type = OPTI_TYPE_ZERO_BYTE;
9383 dgst_pos0 = 0;
9384 dgst_pos1 = 1;
9385 dgst_pos2 = 2;
9386 dgst_pos3 = 3;
9387 break;
9388
9389 case 8900: hash_type = HASH_TYPE_SCRYPT;
9390 salt_type = SALT_TYPE_EMBEDDED;
9391 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9392 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9393 kern_type = KERN_TYPE_SCRYPT;
9394 dgst_size = DGST_SIZE_4_8;
9395 parse_func = scrypt_parse_hash;
9396 sort_by_digest = sort_by_digest_4_8;
9397 opti_type = OPTI_TYPE_ZERO_BYTE;
9398 dgst_pos0 = 0;
9399 dgst_pos1 = 1;
9400 dgst_pos2 = 2;
9401 dgst_pos3 = 3;
9402 break;
9403
9404 case 9000: hash_type = HASH_TYPE_SHA1;
9405 salt_type = SALT_TYPE_EMBEDDED;
9406 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9407 opts_type = OPTS_TYPE_PT_GENERATE_LE
9408 | OPTS_TYPE_ST_GENERATE_LE;
9409 kern_type = KERN_TYPE_PSAFE2;
9410 dgst_size = DGST_SIZE_4_5;
9411 parse_func = psafe2_parse_hash;
9412 sort_by_digest = sort_by_digest_4_5;
9413 opti_type = OPTI_TYPE_ZERO_BYTE;
9414 dgst_pos0 = 0;
9415 dgst_pos1 = 1;
9416 dgst_pos2 = 2;
9417 dgst_pos3 = 3;
9418 break;
9419
9420 case 9100: hash_type = HASH_TYPE_LOTUS8;
9421 salt_type = SALT_TYPE_EMBEDDED;
9422 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9423 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9424 kern_type = KERN_TYPE_LOTUS8;
9425 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9426 parse_func = lotus8_parse_hash;
9427 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9428 opti_type = OPTI_TYPE_ZERO_BYTE;
9429 dgst_pos0 = 0;
9430 dgst_pos1 = 1;
9431 dgst_pos2 = 2;
9432 dgst_pos3 = 3;
9433 break;
9434
9435 case 9200: hash_type = HASH_TYPE_SHA256;
9436 salt_type = SALT_TYPE_EMBEDDED;
9437 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9438 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9439 kern_type = KERN_TYPE_PBKDF2_SHA256;
9440 dgst_size = DGST_SIZE_4_32;
9441 parse_func = cisco8_parse_hash;
9442 sort_by_digest = sort_by_digest_4_32;
9443 opti_type = OPTI_TYPE_ZERO_BYTE;
9444 dgst_pos0 = 0;
9445 dgst_pos1 = 1;
9446 dgst_pos2 = 2;
9447 dgst_pos3 = 3;
9448 break;
9449
9450 case 9300: hash_type = HASH_TYPE_SCRYPT;
9451 salt_type = SALT_TYPE_EMBEDDED;
9452 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9453 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9454 kern_type = KERN_TYPE_SCRYPT;
9455 dgst_size = DGST_SIZE_4_8;
9456 parse_func = cisco9_parse_hash;
9457 sort_by_digest = sort_by_digest_4_8;
9458 opti_type = OPTI_TYPE_ZERO_BYTE;
9459 dgst_pos0 = 0;
9460 dgst_pos1 = 1;
9461 dgst_pos2 = 2;
9462 dgst_pos3 = 3;
9463 break;
9464
9465 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9466 salt_type = SALT_TYPE_EMBEDDED;
9467 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9468 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9469 kern_type = KERN_TYPE_OFFICE2007;
9470 dgst_size = DGST_SIZE_4_4;
9471 parse_func = office2007_parse_hash;
9472 sort_by_digest = sort_by_digest_4_4;
9473 opti_type = OPTI_TYPE_ZERO_BYTE;
9474 dgst_pos0 = 0;
9475 dgst_pos1 = 1;
9476 dgst_pos2 = 2;
9477 dgst_pos3 = 3;
9478 break;
9479
9480 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9481 salt_type = SALT_TYPE_EMBEDDED;
9482 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9483 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9484 kern_type = KERN_TYPE_OFFICE2010;
9485 dgst_size = DGST_SIZE_4_4;
9486 parse_func = office2010_parse_hash;
9487 sort_by_digest = sort_by_digest_4_4;
9488 opti_type = OPTI_TYPE_ZERO_BYTE;
9489 dgst_pos0 = 0;
9490 dgst_pos1 = 1;
9491 dgst_pos2 = 2;
9492 dgst_pos3 = 3;
9493 break;
9494
9495 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9496 salt_type = SALT_TYPE_EMBEDDED;
9497 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9498 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9499 kern_type = KERN_TYPE_OFFICE2013;
9500 dgst_size = DGST_SIZE_4_4;
9501 parse_func = office2013_parse_hash;
9502 sort_by_digest = sort_by_digest_4_4;
9503 opti_type = OPTI_TYPE_ZERO_BYTE;
9504 dgst_pos0 = 0;
9505 dgst_pos1 = 1;
9506 dgst_pos2 = 2;
9507 dgst_pos3 = 3;
9508 break;
9509
9510 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9511 salt_type = SALT_TYPE_EMBEDDED;
9512 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9513 opts_type = OPTS_TYPE_PT_GENERATE_LE
9514 | OPTS_TYPE_PT_ADD80
9515 | OPTS_TYPE_PT_UNICODE;
9516 kern_type = KERN_TYPE_OLDOFFICE01;
9517 dgst_size = DGST_SIZE_4_4;
9518 parse_func = oldoffice01_parse_hash;
9519 sort_by_digest = sort_by_digest_4_4;
9520 opti_type = OPTI_TYPE_ZERO_BYTE
9521 | OPTI_TYPE_PRECOMPUTE_INIT
9522 | OPTI_TYPE_NOT_ITERATED;
9523 dgst_pos0 = 0;
9524 dgst_pos1 = 1;
9525 dgst_pos2 = 2;
9526 dgst_pos3 = 3;
9527 break;
9528
9529 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9530 salt_type = SALT_TYPE_EMBEDDED;
9531 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9532 opts_type = OPTS_TYPE_PT_GENERATE_LE
9533 | OPTS_TYPE_PT_ADD80;
9534 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9535 dgst_size = DGST_SIZE_4_4;
9536 parse_func = oldoffice01cm1_parse_hash;
9537 sort_by_digest = sort_by_digest_4_4;
9538 opti_type = OPTI_TYPE_ZERO_BYTE
9539 | OPTI_TYPE_PRECOMPUTE_INIT
9540 | OPTI_TYPE_NOT_ITERATED;
9541 dgst_pos0 = 0;
9542 dgst_pos1 = 1;
9543 dgst_pos2 = 2;
9544 dgst_pos3 = 3;
9545 break;
9546
9547 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9548 salt_type = SALT_TYPE_EMBEDDED;
9549 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9550 opts_type = OPTS_TYPE_PT_GENERATE_LE
9551 | OPTS_TYPE_PT_ADD80
9552 | OPTS_TYPE_PT_UNICODE
9553 | OPTS_TYPE_PT_NEVERCRACK;
9554 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9555 dgst_size = DGST_SIZE_4_4;
9556 parse_func = oldoffice01cm2_parse_hash;
9557 sort_by_digest = sort_by_digest_4_4;
9558 opti_type = OPTI_TYPE_ZERO_BYTE
9559 | OPTI_TYPE_PRECOMPUTE_INIT
9560 | OPTI_TYPE_NOT_ITERATED;
9561 dgst_pos0 = 0;
9562 dgst_pos1 = 1;
9563 dgst_pos2 = 2;
9564 dgst_pos3 = 3;
9565 break;
9566
9567 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9568 salt_type = SALT_TYPE_EMBEDDED;
9569 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9570 opts_type = OPTS_TYPE_PT_GENERATE_BE
9571 | OPTS_TYPE_PT_ADD80
9572 | OPTS_TYPE_PT_UNICODE;
9573 kern_type = KERN_TYPE_OLDOFFICE34;
9574 dgst_size = DGST_SIZE_4_4;
9575 parse_func = oldoffice34_parse_hash;
9576 sort_by_digest = sort_by_digest_4_4;
9577 opti_type = OPTI_TYPE_ZERO_BYTE
9578 | OPTI_TYPE_PRECOMPUTE_INIT
9579 | OPTI_TYPE_NOT_ITERATED;
9580 dgst_pos0 = 0;
9581 dgst_pos1 = 1;
9582 dgst_pos2 = 2;
9583 dgst_pos3 = 3;
9584 break;
9585
9586 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9587 salt_type = SALT_TYPE_EMBEDDED;
9588 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9589 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9590 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9591 dgst_size = DGST_SIZE_4_4;
9592 parse_func = oldoffice34cm1_parse_hash;
9593 sort_by_digest = sort_by_digest_4_4;
9594 opti_type = OPTI_TYPE_ZERO_BYTE
9595 | OPTI_TYPE_PRECOMPUTE_INIT
9596 | OPTI_TYPE_NOT_ITERATED;
9597 dgst_pos0 = 0;
9598 dgst_pos1 = 1;
9599 dgst_pos2 = 2;
9600 dgst_pos3 = 3;
9601 break;
9602
9603 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9604 salt_type = SALT_TYPE_EMBEDDED;
9605 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9606 opts_type = OPTS_TYPE_PT_GENERATE_BE
9607 | OPTS_TYPE_PT_ADD80
9608 | OPTS_TYPE_PT_UNICODE
9609 | OPTS_TYPE_PT_NEVERCRACK;
9610 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9611 dgst_size = DGST_SIZE_4_4;
9612 parse_func = oldoffice34cm2_parse_hash;
9613 sort_by_digest = sort_by_digest_4_4;
9614 opti_type = OPTI_TYPE_ZERO_BYTE
9615 | OPTI_TYPE_PRECOMPUTE_INIT
9616 | OPTI_TYPE_NOT_ITERATED;
9617 dgst_pos0 = 0;
9618 dgst_pos1 = 1;
9619 dgst_pos2 = 2;
9620 dgst_pos3 = 3;
9621 break;
9622
9623 case 9900: hash_type = HASH_TYPE_MD5;
9624 salt_type = SALT_TYPE_NONE;
9625 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9626 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9627 kern_type = KERN_TYPE_RADMIN2;
9628 dgst_size = DGST_SIZE_4_4;
9629 parse_func = radmin2_parse_hash;
9630 sort_by_digest = sort_by_digest_4_4;
9631 opti_type = OPTI_TYPE_ZERO_BYTE
9632 | OPTI_TYPE_PRECOMPUTE_INIT
9633 | OPTI_TYPE_EARLY_SKIP
9634 | OPTI_TYPE_NOT_ITERATED
9635 | OPTI_TYPE_NOT_SALTED;
9636 dgst_pos0 = 0;
9637 dgst_pos1 = 3;
9638 dgst_pos2 = 2;
9639 dgst_pos3 = 1;
9640 break;
9641
9642 case 10000: hash_type = HASH_TYPE_SHA256;
9643 salt_type = SALT_TYPE_EMBEDDED;
9644 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9645 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9646 kern_type = KERN_TYPE_PBKDF2_SHA256;
9647 dgst_size = DGST_SIZE_4_32;
9648 parse_func = djangopbkdf2_parse_hash;
9649 sort_by_digest = sort_by_digest_4_32;
9650 opti_type = OPTI_TYPE_ZERO_BYTE;
9651 dgst_pos0 = 0;
9652 dgst_pos1 = 1;
9653 dgst_pos2 = 2;
9654 dgst_pos3 = 3;
9655 break;
9656
9657 case 10100: hash_type = HASH_TYPE_SIPHASH;
9658 salt_type = SALT_TYPE_EMBEDDED;
9659 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9660 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9661 kern_type = KERN_TYPE_SIPHASH;
9662 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9663 parse_func = siphash_parse_hash;
9664 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9665 opti_type = OPTI_TYPE_ZERO_BYTE
9666 | OPTI_TYPE_NOT_ITERATED
9667 | OPTI_TYPE_RAW_HASH;
9668 dgst_pos0 = 0;
9669 dgst_pos1 = 1;
9670 dgst_pos2 = 2;
9671 dgst_pos3 = 3;
9672 break;
9673
9674 case 10200: hash_type = HASH_TYPE_MD5;
9675 salt_type = SALT_TYPE_EMBEDDED;
9676 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9677 opts_type = OPTS_TYPE_PT_GENERATE_LE
9678 | OPTS_TYPE_ST_ADD80
9679 | OPTS_TYPE_ST_ADDBITS14;
9680 kern_type = KERN_TYPE_HMACMD5_PW;
9681 dgst_size = DGST_SIZE_4_4;
9682 parse_func = crammd5_parse_hash;
9683 sort_by_digest = sort_by_digest_4_4;
9684 opti_type = OPTI_TYPE_ZERO_BYTE
9685 | OPTI_TYPE_NOT_ITERATED;
9686 dgst_pos0 = 0;
9687 dgst_pos1 = 3;
9688 dgst_pos2 = 2;
9689 dgst_pos3 = 1;
9690 break;
9691
9692 case 10300: hash_type = HASH_TYPE_SHA1;
9693 salt_type = SALT_TYPE_EMBEDDED;
9694 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9695 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9696 kern_type = KERN_TYPE_SAPH_SHA1;
9697 dgst_size = DGST_SIZE_4_5;
9698 parse_func = saph_sha1_parse_hash;
9699 sort_by_digest = sort_by_digest_4_5;
9700 opti_type = OPTI_TYPE_ZERO_BYTE;
9701 dgst_pos0 = 0;
9702 dgst_pos1 = 1;
9703 dgst_pos2 = 2;
9704 dgst_pos3 = 3;
9705 break;
9706
9707 case 10400: hash_type = HASH_TYPE_PDFU16;
9708 salt_type = SALT_TYPE_EMBEDDED;
9709 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9710 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9711 kern_type = KERN_TYPE_PDF11;
9712 dgst_size = DGST_SIZE_4_4;
9713 parse_func = pdf11_parse_hash;
9714 sort_by_digest = sort_by_digest_4_4;
9715 opti_type = OPTI_TYPE_ZERO_BYTE
9716 | OPTI_TYPE_NOT_ITERATED;
9717 dgst_pos0 = 0;
9718 dgst_pos1 = 1;
9719 dgst_pos2 = 2;
9720 dgst_pos3 = 3;
9721 break;
9722
9723 case 10410: hash_type = HASH_TYPE_PDFU16;
9724 salt_type = SALT_TYPE_EMBEDDED;
9725 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9726 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9727 kern_type = KERN_TYPE_PDF11CM1;
9728 dgst_size = DGST_SIZE_4_4;
9729 parse_func = pdf11cm1_parse_hash;
9730 sort_by_digest = sort_by_digest_4_4;
9731 opti_type = OPTI_TYPE_ZERO_BYTE
9732 | OPTI_TYPE_NOT_ITERATED;
9733 dgst_pos0 = 0;
9734 dgst_pos1 = 1;
9735 dgst_pos2 = 2;
9736 dgst_pos3 = 3;
9737 break;
9738
9739 case 10420: hash_type = HASH_TYPE_PDFU16;
9740 salt_type = SALT_TYPE_EMBEDDED;
9741 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9742 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9743 kern_type = KERN_TYPE_PDF11CM2;
9744 dgst_size = DGST_SIZE_4_4;
9745 parse_func = pdf11cm2_parse_hash;
9746 sort_by_digest = sort_by_digest_4_4;
9747 opti_type = OPTI_TYPE_ZERO_BYTE
9748 | OPTI_TYPE_NOT_ITERATED;
9749 dgst_pos0 = 0;
9750 dgst_pos1 = 1;
9751 dgst_pos2 = 2;
9752 dgst_pos3 = 3;
9753 break;
9754
9755 case 10500: hash_type = HASH_TYPE_PDFU16;
9756 salt_type = SALT_TYPE_EMBEDDED;
9757 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9758 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9759 kern_type = KERN_TYPE_PDF14;
9760 dgst_size = DGST_SIZE_4_4;
9761 parse_func = pdf14_parse_hash;
9762 sort_by_digest = sort_by_digest_4_4;
9763 opti_type = OPTI_TYPE_ZERO_BYTE
9764 | OPTI_TYPE_NOT_ITERATED;
9765 dgst_pos0 = 0;
9766 dgst_pos1 = 1;
9767 dgst_pos2 = 2;
9768 dgst_pos3 = 3;
9769 break;
9770
9771 case 10600: hash_type = HASH_TYPE_SHA256;
9772 salt_type = SALT_TYPE_EMBEDDED;
9773 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9774 opts_type = OPTS_TYPE_PT_GENERATE_BE
9775 | OPTS_TYPE_ST_ADD80
9776 | OPTS_TYPE_ST_ADDBITS15
9777 | OPTS_TYPE_HASH_COPY;
9778 kern_type = KERN_TYPE_SHA256_PWSLT;
9779 dgst_size = DGST_SIZE_4_8;
9780 parse_func = pdf17l3_parse_hash;
9781 sort_by_digest = sort_by_digest_4_8;
9782 opti_type = OPTI_TYPE_ZERO_BYTE
9783 | OPTI_TYPE_PRECOMPUTE_INIT
9784 | OPTI_TYPE_PRECOMPUTE_MERKLE
9785 | OPTI_TYPE_EARLY_SKIP
9786 | OPTI_TYPE_NOT_ITERATED
9787 | OPTI_TYPE_APPENDED_SALT
9788 | OPTI_TYPE_RAW_HASH;
9789 dgst_pos0 = 3;
9790 dgst_pos1 = 7;
9791 dgst_pos2 = 2;
9792 dgst_pos3 = 6;
9793 break;
9794
9795 case 10700: hash_type = HASH_TYPE_PDFU32;
9796 salt_type = SALT_TYPE_EMBEDDED;
9797 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9798 opts_type = OPTS_TYPE_PT_GENERATE_LE
9799 | OPTS_TYPE_HASH_COPY;
9800 kern_type = KERN_TYPE_PDF17L8;
9801 dgst_size = DGST_SIZE_4_8;
9802 parse_func = pdf17l8_parse_hash;
9803 sort_by_digest = sort_by_digest_4_8;
9804 opti_type = OPTI_TYPE_ZERO_BYTE
9805 | OPTI_TYPE_NOT_ITERATED;
9806 dgst_pos0 = 0;
9807 dgst_pos1 = 1;
9808 dgst_pos2 = 2;
9809 dgst_pos3 = 3;
9810 break;
9811
9812 case 10800: hash_type = HASH_TYPE_SHA384;
9813 salt_type = SALT_TYPE_NONE;
9814 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9815 opts_type = OPTS_TYPE_PT_GENERATE_BE
9816 | OPTS_TYPE_PT_ADD80
9817 | OPTS_TYPE_PT_ADDBITS15;
9818 kern_type = KERN_TYPE_SHA384;
9819 dgst_size = DGST_SIZE_8_8;
9820 parse_func = sha384_parse_hash;
9821 sort_by_digest = sort_by_digest_8_8;
9822 opti_type = OPTI_TYPE_ZERO_BYTE
9823 | OPTI_TYPE_PRECOMPUTE_INIT
9824 | OPTI_TYPE_PRECOMPUTE_MERKLE
9825 | OPTI_TYPE_EARLY_SKIP
9826 | OPTI_TYPE_NOT_ITERATED
9827 | OPTI_TYPE_NOT_SALTED
9828 | OPTI_TYPE_USES_BITS_64
9829 | OPTI_TYPE_RAW_HASH;
9830 dgst_pos0 = 6;
9831 dgst_pos1 = 7;
9832 dgst_pos2 = 4;
9833 dgst_pos3 = 5;
9834 break;
9835
9836 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9837 salt_type = SALT_TYPE_EMBEDDED;
9838 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9839 opts_type = OPTS_TYPE_PT_GENERATE_LE
9840 | OPTS_TYPE_ST_BASE64
9841 | OPTS_TYPE_HASH_COPY;
9842 kern_type = KERN_TYPE_PBKDF2_SHA256;
9843 dgst_size = DGST_SIZE_4_32;
9844 parse_func = pbkdf2_sha256_parse_hash;
9845 sort_by_digest = sort_by_digest_4_32;
9846 opti_type = OPTI_TYPE_ZERO_BYTE;
9847 dgst_pos0 = 0;
9848 dgst_pos1 = 1;
9849 dgst_pos2 = 2;
9850 dgst_pos3 = 3;
9851 break;
9852
9853 case 11000: hash_type = HASH_TYPE_MD5;
9854 salt_type = SALT_TYPE_INTERN;
9855 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9856 opts_type = OPTS_TYPE_PT_GENERATE_LE
9857 | OPTS_TYPE_PT_ADD80;
9858 kern_type = KERN_TYPE_PRESTASHOP;
9859 dgst_size = DGST_SIZE_4_4;
9860 parse_func = prestashop_parse_hash;
9861 sort_by_digest = sort_by_digest_4_4;
9862 opti_type = OPTI_TYPE_ZERO_BYTE
9863 | OPTI_TYPE_PRECOMPUTE_INIT
9864 | OPTI_TYPE_NOT_ITERATED
9865 | OPTI_TYPE_PREPENDED_SALT;
9866 dgst_pos0 = 0;
9867 dgst_pos1 = 3;
9868 dgst_pos2 = 2;
9869 dgst_pos3 = 1;
9870 break;
9871
9872 case 11100: hash_type = HASH_TYPE_MD5;
9873 salt_type = SALT_TYPE_EMBEDDED;
9874 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9875 opts_type = OPTS_TYPE_PT_GENERATE_LE
9876 | OPTS_TYPE_ST_ADD80;
9877 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9878 dgst_size = DGST_SIZE_4_4;
9879 parse_func = postgresql_auth_parse_hash;
9880 sort_by_digest = sort_by_digest_4_4;
9881 opti_type = OPTI_TYPE_ZERO_BYTE
9882 | OPTI_TYPE_PRECOMPUTE_INIT
9883 | OPTI_TYPE_PRECOMPUTE_MERKLE
9884 | OPTI_TYPE_EARLY_SKIP;
9885 dgst_pos0 = 0;
9886 dgst_pos1 = 3;
9887 dgst_pos2 = 2;
9888 dgst_pos3 = 1;
9889 break;
9890
9891 case 11200: hash_type = HASH_TYPE_SHA1;
9892 salt_type = SALT_TYPE_EMBEDDED;
9893 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9894 opts_type = OPTS_TYPE_PT_GENERATE_BE
9895 | OPTS_TYPE_PT_ADD80
9896 | OPTS_TYPE_ST_HEX;
9897 kern_type = KERN_TYPE_MYSQL_AUTH;
9898 dgst_size = DGST_SIZE_4_5;
9899 parse_func = mysql_auth_parse_hash;
9900 sort_by_digest = sort_by_digest_4_5;
9901 opti_type = OPTI_TYPE_ZERO_BYTE
9902 | OPTI_TYPE_EARLY_SKIP;
9903 dgst_pos0 = 3;
9904 dgst_pos1 = 4;
9905 dgst_pos2 = 2;
9906 dgst_pos3 = 1;
9907 break;
9908
9909 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9910 salt_type = SALT_TYPE_EMBEDDED;
9911 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9912 opts_type = OPTS_TYPE_PT_GENERATE_LE
9913 | OPTS_TYPE_ST_HEX
9914 | OPTS_TYPE_ST_ADD80;
9915 kern_type = KERN_TYPE_BITCOIN_WALLET;
9916 dgst_size = DGST_SIZE_4_4;
9917 parse_func = bitcoin_wallet_parse_hash;
9918 sort_by_digest = sort_by_digest_4_4;
9919 opti_type = OPTI_TYPE_ZERO_BYTE;
9920 dgst_pos0 = 0;
9921 dgst_pos1 = 1;
9922 dgst_pos2 = 2;
9923 dgst_pos3 = 3;
9924 break;
9925
9926 case 11400: hash_type = HASH_TYPE_MD5;
9927 salt_type = SALT_TYPE_EMBEDDED;
9928 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9929 opts_type = OPTS_TYPE_PT_GENERATE_LE
9930 | OPTS_TYPE_PT_ADD80
9931 | OPTS_TYPE_HASH_COPY;
9932 kern_type = KERN_TYPE_SIP_AUTH;
9933 dgst_size = DGST_SIZE_4_4;
9934 parse_func = sip_auth_parse_hash;
9935 sort_by_digest = sort_by_digest_4_4;
9936 opti_type = OPTI_TYPE_ZERO_BYTE;
9937 dgst_pos0 = 0;
9938 dgst_pos1 = 3;
9939 dgst_pos2 = 2;
9940 dgst_pos3 = 1;
9941 break;
9942
9943 case 11500: hash_type = HASH_TYPE_CRC32;
9944 salt_type = SALT_TYPE_INTERN;
9945 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9946 opts_type = OPTS_TYPE_PT_GENERATE_LE
9947 | OPTS_TYPE_ST_GENERATE_LE
9948 | OPTS_TYPE_ST_HEX;
9949 kern_type = KERN_TYPE_CRC32;
9950 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9951 parse_func = crc32_parse_hash;
9952 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9953 opti_type = OPTI_TYPE_ZERO_BYTE;
9954 dgst_pos0 = 0;
9955 dgst_pos1 = 1;
9956 dgst_pos2 = 2;
9957 dgst_pos3 = 3;
9958 break;
9959
9960 case 11600: hash_type = HASH_TYPE_AES;
9961 salt_type = SALT_TYPE_EMBEDDED;
9962 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9963 opts_type = OPTS_TYPE_PT_GENERATE_LE
9964 | OPTS_TYPE_PT_NEVERCRACK;
9965 kern_type = KERN_TYPE_SEVEN_ZIP;
9966 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9967 parse_func = seven_zip_parse_hash;
9968 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9969 opti_type = OPTI_TYPE_ZERO_BYTE;
9970 dgst_pos0 = 0;
9971 dgst_pos1 = 1;
9972 dgst_pos2 = 2;
9973 dgst_pos3 = 3;
9974 break;
9975
9976 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9977 salt_type = SALT_TYPE_NONE;
9978 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9979 opts_type = OPTS_TYPE_PT_GENERATE_LE
9980 | OPTS_TYPE_PT_ADD01;
9981 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9982 dgst_size = DGST_SIZE_4_8;
9983 parse_func = gost2012sbog_256_parse_hash;
9984 sort_by_digest = sort_by_digest_4_8;
9985 opti_type = OPTI_TYPE_ZERO_BYTE;
9986 dgst_pos0 = 0;
9987 dgst_pos1 = 1;
9988 dgst_pos2 = 2;
9989 dgst_pos3 = 3;
9990 break;
9991
9992 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9993 salt_type = SALT_TYPE_NONE;
9994 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9995 opts_type = OPTS_TYPE_PT_GENERATE_LE
9996 | OPTS_TYPE_PT_ADD01;
9997 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9998 dgst_size = DGST_SIZE_4_16;
9999 parse_func = gost2012sbog_512_parse_hash;
10000 sort_by_digest = sort_by_digest_4_16;
10001 opti_type = OPTI_TYPE_ZERO_BYTE;
10002 dgst_pos0 = 0;
10003 dgst_pos1 = 1;
10004 dgst_pos2 = 2;
10005 dgst_pos3 = 3;
10006 break;
10007
10008 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10009 salt_type = SALT_TYPE_EMBEDDED;
10010 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10011 opts_type = OPTS_TYPE_PT_GENERATE_LE
10012 | OPTS_TYPE_ST_BASE64
10013 | OPTS_TYPE_HASH_COPY;
10014 kern_type = KERN_TYPE_PBKDF2_MD5;
10015 dgst_size = DGST_SIZE_4_32;
10016 parse_func = pbkdf2_md5_parse_hash;
10017 sort_by_digest = sort_by_digest_4_32;
10018 opti_type = OPTI_TYPE_ZERO_BYTE;
10019 dgst_pos0 = 0;
10020 dgst_pos1 = 1;
10021 dgst_pos2 = 2;
10022 dgst_pos3 = 3;
10023 break;
10024
10025 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10026 salt_type = SALT_TYPE_EMBEDDED;
10027 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10028 opts_type = OPTS_TYPE_PT_GENERATE_LE
10029 | OPTS_TYPE_ST_BASE64
10030 | OPTS_TYPE_HASH_COPY;
10031 kern_type = KERN_TYPE_PBKDF2_SHA1;
10032 dgst_size = DGST_SIZE_4_32;
10033 parse_func = pbkdf2_sha1_parse_hash;
10034 sort_by_digest = sort_by_digest_4_32;
10035 opti_type = OPTI_TYPE_ZERO_BYTE;
10036 dgst_pos0 = 0;
10037 dgst_pos1 = 1;
10038 dgst_pos2 = 2;
10039 dgst_pos3 = 3;
10040 break;
10041
10042 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10043 salt_type = SALT_TYPE_EMBEDDED;
10044 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10045 opts_type = OPTS_TYPE_PT_GENERATE_LE
10046 | OPTS_TYPE_ST_BASE64
10047 | OPTS_TYPE_HASH_COPY;
10048 kern_type = KERN_TYPE_PBKDF2_SHA512;
10049 dgst_size = DGST_SIZE_8_16;
10050 parse_func = pbkdf2_sha512_parse_hash;
10051 sort_by_digest = sort_by_digest_8_16;
10052 opti_type = OPTI_TYPE_ZERO_BYTE
10053 | OPTI_TYPE_USES_BITS_64;
10054 dgst_pos0 = 0;
10055 dgst_pos1 = 1;
10056 dgst_pos2 = 2;
10057 dgst_pos3 = 3;
10058 break;
10059
10060 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10061 salt_type = SALT_TYPE_EMBEDDED;
10062 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10063 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10064 kern_type = KERN_TYPE_ECRYPTFS;
10065 dgst_size = DGST_SIZE_8_8;
10066 parse_func = ecryptfs_parse_hash;
10067 sort_by_digest = sort_by_digest_8_8;
10068 opti_type = OPTI_TYPE_ZERO_BYTE
10069 | OPTI_TYPE_USES_BITS_64;
10070 dgst_pos0 = 0;
10071 dgst_pos1 = 1;
10072 dgst_pos2 = 2;
10073 dgst_pos3 = 3;
10074 break;
10075
10076 case 12300: hash_type = HASH_TYPE_ORACLET;
10077 salt_type = SALT_TYPE_EMBEDDED;
10078 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10079 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10080 kern_type = KERN_TYPE_ORACLET;
10081 dgst_size = DGST_SIZE_8_16;
10082 parse_func = oraclet_parse_hash;
10083 sort_by_digest = sort_by_digest_8_16;
10084 opti_type = OPTI_TYPE_ZERO_BYTE
10085 | OPTI_TYPE_USES_BITS_64;
10086 dgst_pos0 = 0;
10087 dgst_pos1 = 1;
10088 dgst_pos2 = 2;
10089 dgst_pos3 = 3;
10090 break;
10091
10092 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10093 salt_type = SALT_TYPE_EMBEDDED;
10094 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10095 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10096 kern_type = KERN_TYPE_BSDICRYPT;
10097 dgst_size = DGST_SIZE_4_4;
10098 parse_func = bsdicrypt_parse_hash;
10099 sort_by_digest = sort_by_digest_4_4;
10100 opti_type = OPTI_TYPE_ZERO_BYTE
10101 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10102 dgst_pos0 = 0;
10103 dgst_pos1 = 1;
10104 dgst_pos2 = 2;
10105 dgst_pos3 = 3;
10106 break;
10107
10108 case 12500: hash_type = HASH_TYPE_RAR3HP;
10109 salt_type = SALT_TYPE_EMBEDDED;
10110 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10111 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10112 kern_type = KERN_TYPE_RAR3;
10113 dgst_size = DGST_SIZE_4_4;
10114 parse_func = rar3hp_parse_hash;
10115 sort_by_digest = sort_by_digest_4_4;
10116 opti_type = OPTI_TYPE_ZERO_BYTE;
10117 dgst_pos0 = 0;
10118 dgst_pos1 = 1;
10119 dgst_pos2 = 2;
10120 dgst_pos3 = 3;
10121 break;
10122
10123 case 12600: hash_type = HASH_TYPE_SHA256;
10124 salt_type = SALT_TYPE_INTERN;
10125 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10126 opts_type = OPTS_TYPE_PT_GENERATE_BE
10127 | OPTS_TYPE_PT_ADD80;
10128 kern_type = KERN_TYPE_CF10;
10129 dgst_size = DGST_SIZE_4_8;
10130 parse_func = cf10_parse_hash;
10131 sort_by_digest = sort_by_digest_4_8;
10132 opti_type = OPTI_TYPE_ZERO_BYTE
10133 | OPTI_TYPE_PRECOMPUTE_INIT
10134 | OPTI_TYPE_EARLY_SKIP
10135 | OPTI_TYPE_NOT_ITERATED;
10136 dgst_pos0 = 3;
10137 dgst_pos1 = 7;
10138 dgst_pos2 = 2;
10139 dgst_pos3 = 6;
10140 break;
10141
10142 case 12700: hash_type = HASH_TYPE_AES;
10143 salt_type = SALT_TYPE_EMBEDDED;
10144 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10145 opts_type = OPTS_TYPE_PT_GENERATE_LE
10146 | OPTS_TYPE_HASH_COPY;
10147 kern_type = KERN_TYPE_MYWALLET;
10148 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10149 parse_func = mywallet_parse_hash;
10150 sort_by_digest = sort_by_digest_4_5;
10151 opti_type = OPTI_TYPE_ZERO_BYTE;
10152 dgst_pos0 = 0;
10153 dgst_pos1 = 1;
10154 dgst_pos2 = 2;
10155 dgst_pos3 = 3;
10156 break;
10157
10158 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10159 salt_type = SALT_TYPE_EMBEDDED;
10160 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10161 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10162 kern_type = KERN_TYPE_MS_DRSR;
10163 dgst_size = DGST_SIZE_4_8;
10164 parse_func = ms_drsr_parse_hash;
10165 sort_by_digest = sort_by_digest_4_8;
10166 opti_type = OPTI_TYPE_ZERO_BYTE;
10167 dgst_pos0 = 0;
10168 dgst_pos1 = 1;
10169 dgst_pos2 = 2;
10170 dgst_pos3 = 3;
10171 break;
10172
10173 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10174 salt_type = SALT_TYPE_EMBEDDED;
10175 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10176 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10177 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10178 dgst_size = DGST_SIZE_4_8;
10179 parse_func = androidfde_samsung_parse_hash;
10180 sort_by_digest = sort_by_digest_4_8;
10181 opti_type = OPTI_TYPE_ZERO_BYTE;
10182 dgst_pos0 = 0;
10183 dgst_pos1 = 1;
10184 dgst_pos2 = 2;
10185 dgst_pos3 = 3;
10186 break;
10187
10188 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10189 salt_type = SALT_TYPE_EMBEDDED;
10190 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10191 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10192 kern_type = KERN_TYPE_RAR5;
10193 dgst_size = DGST_SIZE_4_4;
10194 parse_func = rar5_parse_hash;
10195 sort_by_digest = sort_by_digest_4_4;
10196 opti_type = OPTI_TYPE_ZERO_BYTE;
10197 dgst_pos0 = 0;
10198 dgst_pos1 = 1;
10199 dgst_pos2 = 2;
10200 dgst_pos3 = 3;
10201 break;
10202
10203 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10204 salt_type = SALT_TYPE_EMBEDDED;
10205 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10206 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10207 kern_type = KERN_TYPE_KRB5TGS;
10208 dgst_size = DGST_SIZE_4_4;
10209 parse_func = krb5tgs_parse_hash;
10210 sort_by_digest = sort_by_digest_4_4;
10211 opti_type = OPTI_TYPE_ZERO_BYTE
10212 | OPTI_TYPE_NOT_ITERATED;
10213 dgst_pos0 = 0;
10214 dgst_pos1 = 1;
10215 dgst_pos2 = 2;
10216 dgst_pos3 = 3;
10217 break;
10218
10219 default: usage_mini_print (PROGNAME); return (-1);
10220 }
10221
10222 /**
10223 * parser
10224 */
10225
10226 data.parse_func = parse_func;
10227
10228 /**
10229 * misc stuff
10230 */
10231
10232 if (hex_salt)
10233 {
10234 if (salt_type == SALT_TYPE_INTERN)
10235 {
10236 opts_type |= OPTS_TYPE_ST_HEX;
10237 }
10238 else
10239 {
10240 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10241
10242 return (-1);
10243 }
10244 }
10245
10246 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10247 | (salt_type == SALT_TYPE_EXTERN)
10248 | (salt_type == SALT_TYPE_EMBEDDED)
10249 | (salt_type == SALT_TYPE_VIRTUAL));
10250
10251 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10252
10253 data.hash_type = hash_type;
10254 data.attack_mode = attack_mode;
10255 data.attack_kern = attack_kern;
10256 data.attack_exec = attack_exec;
10257 data.kern_type = kern_type;
10258 data.opts_type = opts_type;
10259 data.dgst_size = dgst_size;
10260 data.salt_type = salt_type;
10261 data.isSalted = isSalted;
10262 data.sort_by_digest = sort_by_digest;
10263 data.dgst_pos0 = dgst_pos0;
10264 data.dgst_pos1 = dgst_pos1;
10265 data.dgst_pos2 = dgst_pos2;
10266 data.dgst_pos3 = dgst_pos3;
10267
10268 esalt_size = 0;
10269
10270 switch (hash_mode)
10271 {
10272 case 2500: esalt_size = sizeof (wpa_t); break;
10273 case 5300: esalt_size = sizeof (ikepsk_t); break;
10274 case 5400: esalt_size = sizeof (ikepsk_t); break;
10275 case 5500: esalt_size = sizeof (netntlm_t); break;
10276 case 5600: esalt_size = sizeof (netntlm_t); break;
10277 case 6211: esalt_size = sizeof (tc_t); break;
10278 case 6212: esalt_size = sizeof (tc_t); break;
10279 case 6213: esalt_size = sizeof (tc_t); break;
10280 case 6221: esalt_size = sizeof (tc_t); break;
10281 case 6222: esalt_size = sizeof (tc_t); break;
10282 case 6223: esalt_size = sizeof (tc_t); break;
10283 case 6231: esalt_size = sizeof (tc_t); break;
10284 case 6232: esalt_size = sizeof (tc_t); break;
10285 case 6233: esalt_size = sizeof (tc_t); break;
10286 case 6241: esalt_size = sizeof (tc_t); break;
10287 case 6242: esalt_size = sizeof (tc_t); break;
10288 case 6243: esalt_size = sizeof (tc_t); break;
10289 case 6600: esalt_size = sizeof (agilekey_t); break;
10290 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10291 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10292 case 7300: esalt_size = sizeof (rakp_t); break;
10293 case 7500: esalt_size = sizeof (krb5pa_t); break;
10294 case 8200: esalt_size = sizeof (cloudkey_t); break;
10295 case 8800: esalt_size = sizeof (androidfde_t); break;
10296 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10297 case 9400: esalt_size = sizeof (office2007_t); break;
10298 case 9500: esalt_size = sizeof (office2010_t); break;
10299 case 9600: esalt_size = sizeof (office2013_t); break;
10300 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10301 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10302 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10303 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10304 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10305 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10306 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10307 case 10200: esalt_size = sizeof (cram_md5_t); break;
10308 case 10400: esalt_size = sizeof (pdf_t); break;
10309 case 10410: esalt_size = sizeof (pdf_t); break;
10310 case 10420: esalt_size = sizeof (pdf_t); break;
10311 case 10500: esalt_size = sizeof (pdf_t); break;
10312 case 10600: esalt_size = sizeof (pdf_t); break;
10313 case 10700: esalt_size = sizeof (pdf_t); break;
10314 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10315 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10316 case 11400: esalt_size = sizeof (sip_t); break;
10317 case 11600: esalt_size = sizeof (seven_zip_t); break;
10318 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10319 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10320 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10321 case 13000: esalt_size = sizeof (rar5_t); break;
10322 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10323 }
10324
10325 data.esalt_size = esalt_size;
10326
10327 /**
10328 * choose dictionary parser
10329 */
10330
10331 if (hash_type == HASH_TYPE_LM)
10332 {
10333 get_next_word_func = get_next_word_lm;
10334 }
10335 else if (opts_type & OPTS_TYPE_PT_UPPER)
10336 {
10337 get_next_word_func = get_next_word_uc;
10338 }
10339 else
10340 {
10341 get_next_word_func = get_next_word_std;
10342 }
10343
10344 /**
10345 * dictstat
10346 */
10347
10348 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10349
10350 #ifdef _POSIX
10351 size_t dictstat_nmemb = 0;
10352 #endif
10353
10354 #ifdef _WIN
10355 uint dictstat_nmemb = 0;
10356 #endif
10357
10358 char dictstat[256] = { 0 };
10359
10360 FILE *dictstat_fp = NULL;
10361
10362 if (keyspace == 0)
10363 {
10364 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10365
10366 dictstat_fp = fopen (dictstat, "rb");
10367
10368 if (dictstat_fp)
10369 {
10370 #ifdef _POSIX
10371 struct stat tmpstat;
10372
10373 fstat (fileno (dictstat_fp), &tmpstat);
10374 #endif
10375
10376 #ifdef _WIN
10377 struct stat64 tmpstat;
10378
10379 _fstat64 (fileno (dictstat_fp), &tmpstat);
10380 #endif
10381
10382 if (tmpstat.st_mtime < COMPTIME)
10383 {
10384 /* with v0.15 the format changed so we have to ensure user is using a good version
10385 since there is no version-header in the dictstat file */
10386
10387 fclose (dictstat_fp);
10388
10389 unlink (dictstat);
10390 }
10391 else
10392 {
10393 while (!feof (dictstat_fp))
10394 {
10395 dictstat_t d;
10396
10397 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10398
10399 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10400
10401 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10402 {
10403 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10404
10405 return -1;
10406 }
10407 }
10408
10409 fclose (dictstat_fp);
10410 }
10411 }
10412 }
10413
10414 /**
10415 * potfile
10416 */
10417
10418 char potfile[256] = { 0 };
10419
10420 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10421
10422 data.pot_fp = NULL;
10423
10424 FILE *out_fp = NULL;
10425 FILE *pot_fp = NULL;
10426
10427 if (show == 1 || left == 1)
10428 {
10429 pot_fp = fopen (potfile, "rb");
10430
10431 if (pot_fp == NULL)
10432 {
10433 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10434
10435 return (-1);
10436 }
10437
10438 if (outfile != NULL)
10439 {
10440 if ((out_fp = fopen (outfile, "ab")) == NULL)
10441 {
10442 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10443
10444 fclose (pot_fp);
10445
10446 return (-1);
10447 }
10448 }
10449 else
10450 {
10451 out_fp = stdout;
10452 }
10453 }
10454 else
10455 {
10456 if (potfile_disable == 0)
10457 {
10458 pot_fp = fopen (potfile, "ab");
10459
10460 if (pot_fp == NULL)
10461 {
10462 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10463
10464 return (-1);
10465 }
10466
10467 data.pot_fp = pot_fp;
10468 }
10469 }
10470
10471 pot_t *pot = NULL;
10472
10473 uint pot_cnt = 0;
10474 uint pot_avail = 0;
10475
10476 if (show == 1 || left == 1)
10477 {
10478 SUPPRESS_OUTPUT = 1;
10479
10480 pot_avail = count_lines (pot_fp);
10481
10482 rewind (pot_fp);
10483
10484 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10485
10486 uint pot_hashes_avail = 0;
10487
10488 uint line_num = 0;
10489
10490 while (!feof (pot_fp))
10491 {
10492 line_num++;
10493
10494 char line_buf[BUFSIZ] = { 0 };
10495
10496 int line_len = fgetl (pot_fp, line_buf);
10497
10498 if (line_len == 0) continue;
10499
10500 char *plain_buf = line_buf + line_len;
10501
10502 pot_t *pot_ptr = &pot[pot_cnt];
10503
10504 hash_t *hashes_buf = &pot_ptr->hash;
10505
10506 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10507 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10508
10509 if (pot_cnt == pot_hashes_avail)
10510 {
10511 uint pos = 0;
10512
10513 for (pos = 0; pos < INCR_POT; pos++)
10514 {
10515 if ((pot_cnt + pos) >= pot_avail) break;
10516
10517 pot_t *tmp_pot = &pot[pot_cnt + pos];
10518
10519 hash_t *tmp_hash = &tmp_pot->hash;
10520
10521 tmp_hash->digest = mymalloc (dgst_size);
10522
10523 if (isSalted)
10524 {
10525 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10526 }
10527
10528 if (esalt_size)
10529 {
10530 tmp_hash->esalt = mymalloc (esalt_size);
10531 }
10532
10533 pot_hashes_avail++;
10534 }
10535 }
10536
10537 int plain_len = 0;
10538
10539 int parser_status;
10540
10541 int iter = MAX_CUT_TRIES;
10542
10543 do
10544 {
10545 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10546 {
10547 if (line_buf[i] == ':')
10548 {
10549 line_len--;
10550
10551 break;
10552 }
10553 }
10554
10555 if (data.hash_mode != 2500)
10556 {
10557 parser_status = parse_func (line_buf, line_len, hashes_buf);
10558 }
10559 else
10560 {
10561 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10562
10563 if (line_len > max_salt_size)
10564 {
10565 parser_status = PARSER_GLOBAL_LENGTH;
10566 }
10567 else
10568 {
10569 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10570
10571 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10572
10573 hashes_buf->salt->salt_len = line_len;
10574
10575 parser_status = PARSER_OK;
10576 }
10577 }
10578
10579 // if NOT parsed without error, we add the ":" to the plain
10580
10581 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10582 {
10583 plain_len++;
10584 plain_buf--;
10585 }
10586
10587 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10588
10589 if (parser_status < PARSER_GLOBAL_ZERO)
10590 {
10591 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10592
10593 continue;
10594 }
10595
10596 if (plain_len >= 255) continue;
10597
10598 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10599
10600 pot_ptr->plain_len = plain_len;
10601
10602 pot_cnt++;
10603 }
10604
10605 fclose (pot_fp);
10606
10607 SUPPRESS_OUTPUT = 0;
10608
10609 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10610 }
10611
10612 /**
10613 * word len
10614 */
10615
10616 uint pw_min = PW_MIN;
10617 uint pw_max = PW_MAX;
10618
10619 switch (hash_mode)
10620 {
10621 case 400: if (pw_max > 40) pw_max = 40;
10622 break;
10623 case 500: if (pw_max > 16) pw_max = 16;
10624 break;
10625 case 1500: if (pw_max > 8) pw_max = 8;
10626 break;
10627 case 1600: if (pw_max > 16) pw_max = 16;
10628 break;
10629 case 1800: if (pw_max > 16) pw_max = 16;
10630 break;
10631 case 2100: if (pw_max > 16) pw_max = 16;
10632 break;
10633 case 2500: if (pw_min < 8) pw_min = 8;
10634 break;
10635 case 3000: if (pw_max > 7) pw_max = 7;
10636 break;
10637 case 5200: if (pw_max > 24) pw_max = 24;
10638 break;
10639 case 5800: if (pw_max > 16) pw_max = 16;
10640 break;
10641 case 6300: if (pw_max > 16) pw_max = 16;
10642 break;
10643 case 7400: if (pw_max > 16) pw_max = 16;
10644 break;
10645 case 7900: if (pw_max > 48) pw_max = 48;
10646 break;
10647 case 8500: if (pw_max > 8) pw_max = 8;
10648 break;
10649 case 8600: if (pw_max > 16) pw_max = 16;
10650 break;
10651 case 9710: pw_min = 5;
10652 pw_max = 5;
10653 break;
10654 case 9810: pw_min = 5;
10655 pw_max = 5;
10656 break;
10657 case 10410: pw_min = 5;
10658 pw_max = 5;
10659 break;
10660 case 10300: if (pw_max < 3) pw_min = 3;
10661 if (pw_max > 40) pw_max = 40;
10662 break;
10663 case 10500: if (pw_max < 3) pw_min = 3;
10664 if (pw_max > 40) pw_max = 40;
10665 break;
10666 case 10700: if (pw_max > 16) pw_max = 16;
10667 break;
10668 case 11300: if (pw_max > 40) pw_max = 40;
10669 break;
10670 case 12500: if (pw_max > 20) pw_max = 20;
10671 break;
10672 case 12800: if (pw_max > 24) pw_max = 24;
10673 break;
10674 }
10675
10676 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10677 {
10678 switch (attack_kern)
10679 {
10680 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10681 break;
10682 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10683 break;
10684 }
10685 }
10686
10687 /**
10688 * charsets : keep them together for more easy maintainnce
10689 */
10690
10691 cs_t mp_sys[6] = { { { 0 }, 0 } };
10692 cs_t mp_usr[4] = { { { 0 }, 0 } };
10693
10694 mp_setup_sys (mp_sys);
10695
10696 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10697 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10698 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10699 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10700
10701 /**
10702 * load hashes, part I: find input mode, count hashes
10703 */
10704
10705 uint hashlist_mode = 0;
10706 uint hashlist_format = HLFMT_HASHCAT;
10707
10708 uint hashes_avail = 0;
10709
10710 if (benchmark == 0)
10711 {
10712 struct stat f;
10713
10714 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10715
10716 if ((hash_mode == 2500) ||
10717 (hash_mode == 5200) ||
10718 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10719 (hash_mode == 9000))
10720 {
10721 hashlist_mode = HL_MODE_ARG;
10722
10723 char *hashfile = myargv[optind];
10724
10725 data.hashfile = hashfile;
10726
10727 logfile_top_var_string ("target", hashfile);
10728 }
10729
10730 if (hashlist_mode == HL_MODE_ARG)
10731 {
10732 if (hash_mode == 2500)
10733 {
10734 struct stat st;
10735
10736 if (stat (data.hashfile, &st) == -1)
10737 {
10738 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10739
10740 return (-1);
10741 }
10742
10743 hashes_avail = st.st_size / sizeof (hccap_t);
10744 }
10745 else
10746 {
10747 hashes_avail = 1;
10748 }
10749 }
10750 else if (hashlist_mode == HL_MODE_FILE)
10751 {
10752 char *hashfile = myargv[optind];
10753
10754 data.hashfile = hashfile;
10755
10756 logfile_top_var_string ("target", hashfile);
10757
10758 FILE *fp = NULL;
10759
10760 if ((fp = fopen (hashfile, "rb")) == NULL)
10761 {
10762 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10763
10764 return (-1);
10765 }
10766
10767 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10768
10769 hashes_avail = count_lines (fp);
10770
10771 rewind (fp);
10772
10773 if (hashes_avail == 0)
10774 {
10775 log_error ("ERROR: hashfile is empty or corrupt");
10776
10777 fclose (fp);
10778
10779 return (-1);
10780 }
10781
10782 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10783
10784 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10785 {
10786 log_error ("ERROR: remove not supported in native hashfile-format mode");
10787
10788 fclose (fp);
10789
10790 return (-1);
10791 }
10792
10793 fclose (fp);
10794 }
10795 }
10796 else
10797 {
10798 hashlist_mode = HL_MODE_ARG;
10799
10800 hashes_avail = 1;
10801 }
10802
10803 if (hash_mode == 3000) hashes_avail *= 2;
10804
10805 data.hashlist_mode = hashlist_mode;
10806 data.hashlist_format = hashlist_format;
10807
10808 logfile_top_uint (hashlist_mode);
10809 logfile_top_uint (hashlist_format);
10810
10811 /**
10812 * load hashes, part II: allocate required memory, set pointers
10813 */
10814
10815 hash_t *hashes_buf = NULL;
10816 void *digests_buf = NULL;
10817 salt_t *salts_buf = NULL;
10818 void *esalts_buf = NULL;
10819
10820 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10821
10822 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10823
10824 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10825 {
10826 u32 hash_pos;
10827
10828 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10829 {
10830 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10831
10832 hashes_buf[hash_pos].hash_info = hash_info;
10833
10834 if (username && (remove || show || left))
10835 {
10836 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10837 }
10838
10839 if (benchmark)
10840 {
10841 hash_info->orighash = (char *) mymalloc (256);
10842 }
10843 }
10844 }
10845
10846 if (isSalted)
10847 {
10848 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10849
10850 if (esalt_size)
10851 {
10852 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10853 }
10854 }
10855 else
10856 {
10857 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10858 }
10859
10860 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10861 {
10862 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10863
10864 if (isSalted)
10865 {
10866 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10867
10868 if (esalt_size)
10869 {
10870 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10871 }
10872 }
10873 else
10874 {
10875 hashes_buf[hash_pos].salt = &salts_buf[0];
10876 }
10877 }
10878
10879 /**
10880 * load hashes, part III: parse hashes or generate them if benchmark
10881 */
10882
10883 uint hashes_cnt = 0;
10884
10885 if (benchmark == 0)
10886 {
10887 if (keyspace == 1)
10888 {
10889 // useless to read hash file for keyspace, cheat a little bit w/ optind
10890 }
10891 else if (hashes_avail == 0)
10892 {
10893 }
10894 else if (hashlist_mode == HL_MODE_ARG)
10895 {
10896 char *input_buf = myargv[optind];
10897
10898 uint input_len = strlen (input_buf);
10899
10900 logfile_top_var_string ("target", input_buf);
10901
10902 char *hash_buf = NULL;
10903 int hash_len = 0;
10904
10905 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10906
10907 if (hash_len)
10908 {
10909 if (opts_type & OPTS_TYPE_HASH_COPY)
10910 {
10911 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10912
10913 hash_info_tmp->orighash = mystrdup (hash_buf);
10914 }
10915
10916 if (isSalted)
10917 {
10918 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10919 }
10920
10921 int parser_status = PARSER_OK;
10922
10923 if (hash_mode == 2500)
10924 {
10925 if (hash_len == 0)
10926 {
10927 log_error ("ERROR: hccap file not specified");
10928
10929 return (-1);
10930 }
10931
10932 hashlist_mode = HL_MODE_FILE;
10933
10934 data.hashlist_mode = hashlist_mode;
10935
10936 FILE *fp = fopen (hash_buf, "rb");
10937
10938 if (fp == NULL)
10939 {
10940 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10941
10942 return (-1);
10943 }
10944
10945 if (hashes_avail < 1)
10946 {
10947 log_error ("ERROR: hccap file is empty or corrupt");
10948
10949 fclose (fp);
10950
10951 return (-1);
10952 }
10953
10954 uint hccap_size = sizeof (hccap_t);
10955
10956 char *in = (char *) mymalloc (hccap_size);
10957
10958 while (!feof (fp))
10959 {
10960 int n = fread (in, hccap_size, 1, fp);
10961
10962 if (n != 1)
10963 {
10964 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10965
10966 break;
10967 }
10968
10969 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10970
10971 if (parser_status != PARSER_OK)
10972 {
10973 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10974
10975 continue;
10976 }
10977
10978 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10979
10980 if ((show == 1) || (left == 1))
10981 {
10982 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10983
10984 char *salt_ptr = (char *) tmp_salt->salt_buf;
10985
10986 int cur_pos = tmp_salt->salt_len;
10987 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10988
10989 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10990
10991 u8 *pke_ptr = (u8 *) wpa->pke;
10992
10993 // do the appending task
10994
10995 snprintf (salt_ptr + cur_pos,
10996 rem_len,
10997 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10998 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10999 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
11000
11001
11002 // memset () the remaining part of the salt
11003
11004 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11005 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11006
11007 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11008
11009 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11010 }
11011
11012 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);
11013 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);
11014
11015 hashes_cnt++;
11016 }
11017
11018 fclose (fp);
11019
11020 myfree (in);
11021 }
11022 else if (hash_mode == 3000)
11023 {
11024 if (hash_len == 32)
11025 {
11026 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11027
11028 hash_t *lm_hash_left = NULL;
11029
11030 if (parser_status == PARSER_OK)
11031 {
11032 lm_hash_left = &hashes_buf[hashes_cnt];
11033
11034 hashes_cnt++;
11035 }
11036 else
11037 {
11038 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11039 }
11040
11041 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11042
11043 hash_t *lm_hash_right = NULL;
11044
11045 if (parser_status == PARSER_OK)
11046 {
11047 lm_hash_right = &hashes_buf[hashes_cnt];
11048
11049 hashes_cnt++;
11050 }
11051 else
11052 {
11053 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11054 }
11055
11056 // show / left
11057
11058 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11059 {
11060 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);
11061 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);
11062 }
11063 }
11064 else
11065 {
11066 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11067
11068 if (parser_status == PARSER_OK)
11069 {
11070 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11071 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11072 }
11073
11074 if (parser_status == PARSER_OK)
11075 {
11076 hashes_cnt++;
11077 }
11078 else
11079 {
11080 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11081 }
11082 }
11083 }
11084 else
11085 {
11086 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11087
11088 if (parser_status == PARSER_OK)
11089 {
11090 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11091 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11092 }
11093
11094 if (parser_status == PARSER_OK)
11095 {
11096 hashes_cnt++;
11097 }
11098 else
11099 {
11100 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11101 }
11102 }
11103 }
11104 }
11105 else if (hashlist_mode == HL_MODE_FILE)
11106 {
11107 char *hashfile = data.hashfile;
11108
11109 FILE *fp;
11110
11111 if ((fp = fopen (hashfile, "rb")) == NULL)
11112 {
11113 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11114
11115 return (-1);
11116 }
11117
11118 uint line_num = 0;
11119
11120 while (!feof (fp))
11121 {
11122 line_num++;
11123
11124 char line_buf[BUFSIZ] = { 0 };
11125
11126 int line_len = fgetl (fp, line_buf);
11127
11128 if (line_len == 0) continue;
11129
11130 char *hash_buf = NULL;
11131 int hash_len = 0;
11132
11133 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11134
11135 if (username)
11136 {
11137 char *user_buf = NULL;
11138 int user_len = 0;
11139
11140 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11141
11142 if (remove || show)
11143 {
11144 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11145
11146 *user = (user_t *) mymalloc (sizeof (user_t));
11147
11148 user_t *user_ptr = *user;
11149
11150 if (user_buf != NULL)
11151 {
11152 user_ptr->user_name = mystrdup (user_buf);
11153 }
11154 else
11155 {
11156 user_ptr->user_name = mystrdup ("");
11157 }
11158
11159 user_ptr->user_len = user_len;
11160 }
11161 }
11162
11163 if (opts_type & OPTS_TYPE_HASH_COPY)
11164 {
11165 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11166
11167 hash_info_tmp->orighash = mystrdup (hash_buf);
11168 }
11169
11170 if (isSalted)
11171 {
11172 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11173 }
11174
11175 if (hash_mode == 3000)
11176 {
11177 if (hash_len == 32)
11178 {
11179 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11180
11181 if (parser_status < PARSER_GLOBAL_ZERO)
11182 {
11183 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11184
11185 continue;
11186 }
11187
11188 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11189
11190 hashes_cnt++;
11191
11192 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11193
11194 if (parser_status < PARSER_GLOBAL_ZERO)
11195 {
11196 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11197
11198 continue;
11199 }
11200
11201 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11202
11203 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);
11204
11205 hashes_cnt++;
11206
11207 // show / left
11208
11209 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);
11210 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);
11211 }
11212 else
11213 {
11214 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11215
11216 if (parser_status < PARSER_GLOBAL_ZERO)
11217 {
11218 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11219
11220 continue;
11221 }
11222
11223 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);
11224
11225 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11226 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11227
11228 hashes_cnt++;
11229 }
11230 }
11231 else
11232 {
11233 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11234
11235 if (parser_status < PARSER_GLOBAL_ZERO)
11236 {
11237 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11238
11239 continue;
11240 }
11241
11242 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);
11243
11244 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11245 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11246
11247 hashes_cnt++;
11248 }
11249 }
11250
11251 fclose (fp);
11252
11253 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11254
11255 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11256 }
11257 }
11258 else
11259 {
11260 if (isSalted)
11261 {
11262 hashes_buf[0].salt->salt_len = 8;
11263
11264 // special salt handling
11265
11266 switch (hash_mode)
11267 {
11268 case 1500: hashes_buf[0].salt->salt_len = 2;
11269 break;
11270 case 1731: hashes_buf[0].salt->salt_len = 4;
11271 break;
11272 case 2410: hashes_buf[0].salt->salt_len = 4;
11273 break;
11274 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11275 break;
11276 case 3100: hashes_buf[0].salt->salt_len = 1;
11277 break;
11278 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11279 break;
11280 case 5800: hashes_buf[0].salt->salt_len = 16;
11281 break;
11282 case 6800: hashes_buf[0].salt->salt_len = 32;
11283 break;
11284 case 8400: hashes_buf[0].salt->salt_len = 40;
11285 break;
11286 case 8800: hashes_buf[0].salt->salt_len = 16;
11287 break;
11288 case 8900: hashes_buf[0].salt->salt_len = 16;
11289 hashes_buf[0].salt->scrypt_N = 1024;
11290 hashes_buf[0].salt->scrypt_r = 1;
11291 hashes_buf[0].salt->scrypt_p = 1;
11292 break;
11293 case 9100: hashes_buf[0].salt->salt_len = 16;
11294 break;
11295 case 9300: hashes_buf[0].salt->salt_len = 14;
11296 hashes_buf[0].salt->scrypt_N = 16384;
11297 hashes_buf[0].salt->scrypt_r = 1;
11298 hashes_buf[0].salt->scrypt_p = 1;
11299 break;
11300 case 9400: hashes_buf[0].salt->salt_len = 16;
11301 break;
11302 case 9500: hashes_buf[0].salt->salt_len = 16;
11303 break;
11304 case 9600: hashes_buf[0].salt->salt_len = 16;
11305 break;
11306 case 9700: hashes_buf[0].salt->salt_len = 16;
11307 break;
11308 case 9710: hashes_buf[0].salt->salt_len = 16;
11309 break;
11310 case 9720: hashes_buf[0].salt->salt_len = 16;
11311 break;
11312 case 9800: hashes_buf[0].salt->salt_len = 16;
11313 break;
11314 case 9810: hashes_buf[0].salt->salt_len = 16;
11315 break;
11316 case 9820: hashes_buf[0].salt->salt_len = 16;
11317 break;
11318 case 10300: hashes_buf[0].salt->salt_len = 12;
11319 break;
11320 case 11500: hashes_buf[0].salt->salt_len = 4;
11321 break;
11322 case 11600: hashes_buf[0].salt->salt_len = 4;
11323 break;
11324 case 12400: hashes_buf[0].salt->salt_len = 4;
11325 break;
11326 case 12500: hashes_buf[0].salt->salt_len = 8;
11327 break;
11328 case 12600: hashes_buf[0].salt->salt_len = 64;
11329 break;
11330 }
11331
11332 // special esalt handling
11333
11334 switch (hash_mode)
11335 {
11336 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11337 break;
11338 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11339 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11340 break;
11341 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11342 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11343 break;
11344 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11345 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11346 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11347 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11348 break;
11349 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11350 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11351 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11352 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11353 break;
11354 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11355 break;
11356 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11357 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11358 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11359 break;
11360 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11361 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11362 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11363 break;
11364 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11365 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11366 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11367 break;
11368 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11369 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11370 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11371 break;
11372 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11373 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11374 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11375 break;
11376 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11377 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11378 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11379 break;
11380 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11381 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11382 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11383 break;
11384 }
11385 }
11386
11387 // set hashfile
11388
11389 switch (hash_mode)
11390 {
11391 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11392 break;
11393 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11394 break;
11395 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11396 break;
11397 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11398 break;
11399 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11400 break;
11401 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11402 break;
11403 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11404 break;
11405 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11406 break;
11407 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11408 break;
11409 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11410 break;
11411 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11412 break;
11413 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11414 break;
11415 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11416 break;
11417 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11418 break;
11419 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11420 break;
11421 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11422 break;
11423 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11424 break;
11425 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11426 break;
11427 }
11428
11429 // set default iterations
11430
11431 switch (hash_mode)
11432 {
11433 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11434 break;
11435 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11436 break;
11437 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11438 break;
11439 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11440 break;
11441 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11442 break;
11443 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11444 break;
11445 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11446 break;
11447 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11448 break;
11449 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11450 break;
11451 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11452 break;
11453 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11454 break;
11455 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11456 break;
11457 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11458 break;
11459 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11460 break;
11461 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11462 break;
11463 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11464 break;
11465 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11466 break;
11467 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11468 break;
11469 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11470 break;
11471 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11472 break;
11473 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11474 break;
11475 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11476 break;
11477 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11478 break;
11479 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11480 break;
11481 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11482 break;
11483 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11484 break;
11485 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11486 break;
11487 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11488 break;
11489 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11490 break;
11491 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11492 break;
11493 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11494 break;
11495 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11496 break;
11497 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11498 break;
11499 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11500 break;
11501 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11502 break;
11503 case 8900: hashes_buf[0].salt->salt_iter = 1;
11504 break;
11505 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11506 break;
11507 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11508 break;
11509 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11510 break;
11511 case 9300: hashes_buf[0].salt->salt_iter = 1;
11512 break;
11513 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11514 break;
11515 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11516 break;
11517 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11518 break;
11519 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11520 break;
11521 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11522 break;
11523 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11524 break;
11525 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11526 break;
11527 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11528 break;
11529 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11530 break;
11531 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11532 break;
11533 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11534 break;
11535 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11536 break;
11537 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11538 break;
11539 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11540 break;
11541 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11542 break;
11543 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11544 break;
11545 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11546 break;
11547 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11548 break;
11549 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11550 break;
11551 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11552 break;
11553 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11554 break;
11555 }
11556
11557 hashes_cnt = 1;
11558 }
11559
11560 if (show == 1 || left == 1)
11561 {
11562 for (uint i = 0; i < pot_cnt; i++)
11563 {
11564 pot_t *pot_ptr = &pot[i];
11565
11566 hash_t *hashes_buf = &pot_ptr->hash;
11567
11568 local_free (hashes_buf->digest);
11569
11570 if (isSalted)
11571 {
11572 local_free (hashes_buf->salt);
11573 }
11574 }
11575
11576 local_free (pot);
11577
11578 if (data.quiet == 0) log_info_nn ("");
11579
11580 return (0);
11581 }
11582
11583 if (keyspace == 0)
11584 {
11585 if (hashes_cnt == 0)
11586 {
11587 log_error ("ERROR: No hashes loaded");
11588
11589 return (-1);
11590 }
11591 }
11592
11593 /**
11594 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11595 */
11596
11597 if (data.outfile != NULL)
11598 {
11599 if (data.hashfile != NULL)
11600 {
11601 #ifdef _POSIX
11602 struct stat tmpstat_outfile;
11603 struct stat tmpstat_hashfile;
11604 #endif
11605
11606 #ifdef _WIN
11607 struct stat64 tmpstat_outfile;
11608 struct stat64 tmpstat_hashfile;
11609 #endif
11610
11611 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11612
11613 if (tmp_outfile_fp)
11614 {
11615 #ifdef _POSIX
11616 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11617 #endif
11618
11619 #ifdef _WIN
11620 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11621 #endif
11622
11623 fclose (tmp_outfile_fp);
11624 }
11625
11626 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11627
11628 if (tmp_hashfile_fp)
11629 {
11630 #ifdef _POSIX
11631 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11632 #endif
11633
11634 #ifdef _WIN
11635 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11636 #endif
11637
11638 fclose (tmp_hashfile_fp);
11639 }
11640
11641 if (tmp_outfile_fp && tmp_outfile_fp)
11642 {
11643 tmpstat_outfile.st_mode = 0;
11644 tmpstat_outfile.st_nlink = 0;
11645 tmpstat_outfile.st_uid = 0;
11646 tmpstat_outfile.st_gid = 0;
11647 tmpstat_outfile.st_rdev = 0;
11648 tmpstat_outfile.st_atime = 0;
11649
11650 tmpstat_hashfile.st_mode = 0;
11651 tmpstat_hashfile.st_nlink = 0;
11652 tmpstat_hashfile.st_uid = 0;
11653 tmpstat_hashfile.st_gid = 0;
11654 tmpstat_hashfile.st_rdev = 0;
11655 tmpstat_hashfile.st_atime = 0;
11656
11657 #ifdef _POSIX
11658 tmpstat_outfile.st_blksize = 0;
11659 tmpstat_outfile.st_blocks = 0;
11660
11661 tmpstat_hashfile.st_blksize = 0;
11662 tmpstat_hashfile.st_blocks = 0;
11663 #endif
11664
11665 #ifdef _POSIX
11666 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11667 {
11668 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11669
11670 return (-1);
11671 }
11672 #endif
11673
11674 #ifdef _WIN
11675 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11676 {
11677 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11678
11679 return (-1);
11680 }
11681 #endif
11682 }
11683 }
11684 }
11685
11686 /**
11687 * Remove duplicates
11688 */
11689
11690 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11691
11692 if (isSalted)
11693 {
11694 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11695 }
11696 else
11697 {
11698 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11699 }
11700
11701 uint hashes_cnt_orig = hashes_cnt;
11702
11703 hashes_cnt = 1;
11704
11705 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11706 {
11707 if (isSalted)
11708 {
11709 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11710 {
11711 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11712 }
11713 }
11714 else
11715 {
11716 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11717 }
11718
11719 if (hashes_pos > hashes_cnt)
11720 {
11721 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11722 }
11723
11724 hashes_cnt++;
11725 }
11726
11727 /**
11728 * Potfile removes
11729 */
11730
11731 uint potfile_remove_cracks = 0;
11732
11733 if (potfile_disable == 0)
11734 {
11735 hash_t hash_buf;
11736
11737 hash_buf.digest = mymalloc (dgst_size);
11738 hash_buf.salt = NULL;
11739 hash_buf.esalt = NULL;
11740 hash_buf.hash_info = NULL;
11741 hash_buf.cracked = 0;
11742
11743 if (isSalted)
11744 {
11745 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11746 }
11747
11748 if (esalt_size)
11749 {
11750 hash_buf.esalt = mymalloc (esalt_size);
11751 }
11752
11753 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11754
11755 // no solution for these special hash types (for instane because they use hashfile in output etc)
11756 if ((hash_mode != 5200) &&
11757 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11758 (hash_mode != 9000))
11759 {
11760 FILE *fp = fopen (potfile, "rb");
11761
11762 if (fp != NULL)
11763 {
11764 while (!feof (fp))
11765 {
11766 char line_buf[BUFSIZ] = { 0 };
11767
11768 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11769
11770 if (ptr == NULL) break;
11771
11772 int line_len = strlen (line_buf);
11773
11774 if (line_len == 0) continue;
11775
11776 int iter = MAX_CUT_TRIES;
11777
11778 for (int i = line_len - 1; i && iter; i--, line_len--)
11779 {
11780 if (line_buf[i] != ':') continue;
11781
11782 if (isSalted)
11783 {
11784 memset (hash_buf.salt, 0, sizeof (salt_t));
11785 }
11786
11787 hash_t *found = NULL;
11788
11789 if (hash_mode == 6800)
11790 {
11791 if (i < 64) // 64 = 16 * uint in salt_buf[]
11792 {
11793 // manipulate salt_buf
11794 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11795
11796 hash_buf.salt->salt_len = i;
11797
11798 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11799 }
11800 }
11801 else if (hash_mode == 2500)
11802 {
11803 if (i < 64) // 64 = 16 * uint in salt_buf[]
11804 {
11805 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11806 // manipulate salt_buf
11807
11808 // to be safe work with a copy (because of line_len loop, i etc)
11809
11810 char line_buf_cpy[BUFSIZ] = { 0 };
11811
11812 memcpy (line_buf_cpy, line_buf, i);
11813
11814 char *mac2_pos = strrchr (line_buf_cpy, ':');
11815
11816 if (mac2_pos == NULL) continue;
11817
11818 mac2_pos[0] = 0;
11819 mac2_pos++;
11820
11821 if (strlen (mac2_pos) != 12) continue;
11822
11823 char *mac1_pos = strrchr (line_buf_cpy, ':');
11824
11825 if (mac1_pos == NULL) continue;
11826
11827 mac1_pos[0] = 0;
11828 mac1_pos++;
11829
11830 if (strlen (mac1_pos) != 12) continue;
11831
11832 uint essid_length = mac1_pos - line_buf_cpy - 1;
11833
11834 // here we need the ESSID
11835 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11836
11837 hash_buf.salt->salt_len = essid_length;
11838
11839 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11840
11841 if (found)
11842 {
11843 wpa_t *wpa = (wpa_t *) found->esalt;
11844
11845 uint pke[25] = { 0 };
11846
11847 char *pke_ptr = (char *) pke;
11848
11849 for (uint i = 0; i < 25; i++)
11850 {
11851 pke[i] = byte_swap_32 (wpa->pke[i]);
11852 }
11853
11854 u8 mac1[6] = { 0 };
11855 u8 mac2[6] = { 0 };
11856
11857 memcpy (mac1, pke_ptr + 23, 6);
11858 memcpy (mac2, pke_ptr + 29, 6);
11859
11860 // compare hex string(s) vs binary MAC address(es)
11861
11862 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11863 {
11864 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11865 {
11866 found = NULL;
11867 break;
11868 }
11869 }
11870
11871 // early skip ;)
11872 if (!found) continue;
11873
11874 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11875 {
11876 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11877 {
11878 found = NULL;
11879 break;
11880 }
11881 }
11882 }
11883 }
11884 }
11885 else
11886 {
11887 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11888
11889 if (parser_status == PARSER_OK)
11890 {
11891 if (isSalted)
11892 {
11893 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11894 }
11895 else
11896 {
11897 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11898 }
11899 }
11900 }
11901
11902 if (found == NULL) continue;
11903
11904 if (!found->cracked) potfile_remove_cracks++;
11905
11906 found->cracked = 1;
11907
11908 if (found) break;
11909
11910 iter--;
11911 }
11912 }
11913
11914 fclose (fp);
11915 }
11916 }
11917
11918 if (esalt_size)
11919 {
11920 local_free (hash_buf.esalt);
11921 }
11922
11923 if (isSalted)
11924 {
11925 local_free (hash_buf.salt);
11926 }
11927
11928 local_free (hash_buf.digest);
11929 }
11930
11931 /**
11932 * Now generate all the buffers required for later
11933 */
11934
11935 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11936
11937 salt_t *salts_buf_new = NULL;
11938 void *esalts_buf_new = NULL;
11939
11940 if (isSalted)
11941 {
11942 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11943
11944 if (esalt_size)
11945 {
11946 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11947 }
11948 }
11949 else
11950 {
11951 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11952 }
11953
11954 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11955
11956 uint digests_cnt = hashes_cnt;
11957 uint digests_done = 0;
11958
11959 uint size_digests = digests_cnt * dgst_size;
11960 uint size_shown = digests_cnt * sizeof (uint);
11961
11962 uint *digests_shown = (uint *) mymalloc (size_shown);
11963 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11964
11965 uint salts_cnt = 0;
11966 uint salts_done = 0;
11967
11968 hashinfo_t **hash_info = NULL;
11969
11970 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11971 {
11972 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11973
11974 if (username && (remove || show))
11975 {
11976 uint user_pos;
11977
11978 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11979 {
11980 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11981
11982 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11983 }
11984 }
11985 }
11986
11987 uint *salts_shown = (uint *) mymalloc (size_shown);
11988
11989 salt_t *salt_buf;
11990
11991 {
11992 // copied from inner loop
11993
11994 salt_buf = &salts_buf_new[salts_cnt];
11995
11996 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11997
11998 if (esalt_size)
11999 {
12000 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12001 }
12002
12003 salt_buf->digests_cnt = 0;
12004 salt_buf->digests_done = 0;
12005 salt_buf->digests_offset = 0;
12006
12007 salts_cnt++;
12008 }
12009
12010 if (hashes_buf[0].cracked == 1)
12011 {
12012 digests_shown[0] = 1;
12013
12014 digests_done++;
12015
12016 salt_buf->digests_done++;
12017 }
12018
12019 salt_buf->digests_cnt++;
12020
12021 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12022
12023 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12024 {
12025 hash_info[0] = hashes_buf[0].hash_info;
12026 }
12027
12028 // copy from inner loop
12029
12030 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12031 {
12032 if (isSalted)
12033 {
12034 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12035 {
12036 salt_buf = &salts_buf_new[salts_cnt];
12037
12038 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12039
12040 if (esalt_size)
12041 {
12042 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12043 }
12044
12045 salt_buf->digests_cnt = 0;
12046 salt_buf->digests_done = 0;
12047 salt_buf->digests_offset = hashes_pos;
12048
12049 salts_cnt++;
12050 }
12051 }
12052
12053 if (hashes_buf[hashes_pos].cracked == 1)
12054 {
12055 digests_shown[hashes_pos] = 1;
12056
12057 digests_done++;
12058
12059 salt_buf->digests_done++;
12060 }
12061
12062 salt_buf->digests_cnt++;
12063
12064 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12065
12066 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12067 {
12068 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12069 }
12070 }
12071
12072 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12073 {
12074 salt_t *salt_buf = &salts_buf_new[salt_pos];
12075
12076 if (salt_buf->digests_done == salt_buf->digests_cnt)
12077 {
12078 salts_shown[salt_pos] = 1;
12079
12080 salts_done++;
12081 }
12082
12083 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12084 }
12085
12086 local_free (digests_buf);
12087 local_free (salts_buf);
12088 local_free (esalts_buf);
12089
12090 digests_buf = digests_buf_new;
12091 salts_buf = salts_buf_new;
12092 esalts_buf = esalts_buf_new;
12093
12094 local_free (hashes_buf);
12095
12096 /**
12097 * special modification not set from parser
12098 */
12099
12100 switch (hash_mode)
12101 {
12102 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12103 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12104 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12105 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12106 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12107 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12108 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12109 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12110 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12111 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12112 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12113 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12114 }
12115
12116 if (truecrypt_keyfiles)
12117 {
12118 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12119
12120 char *keyfiles = strdup (truecrypt_keyfiles);
12121
12122 char *keyfile = strtok (keyfiles, ",");
12123
12124 do
12125 {
12126 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12127
12128 } while ((keyfile = strtok (NULL, ",")) != NULL);
12129
12130 free (keyfiles);
12131 }
12132
12133 data.digests_cnt = digests_cnt;
12134 data.digests_done = digests_done;
12135 data.digests_buf = digests_buf;
12136 data.digests_shown = digests_shown;
12137 data.digests_shown_tmp = digests_shown_tmp;
12138
12139 data.salts_cnt = salts_cnt;
12140 data.salts_done = salts_done;
12141 data.salts_buf = salts_buf;
12142 data.salts_shown = salts_shown;
12143
12144 data.esalts_buf = esalts_buf;
12145 data.hash_info = hash_info;
12146
12147 /**
12148 * Automatic Optimizers
12149 */
12150
12151 if (salts_cnt == 1)
12152 opti_type |= OPTI_TYPE_SINGLE_SALT;
12153
12154 if (digests_cnt == 1)
12155 opti_type |= OPTI_TYPE_SINGLE_HASH;
12156
12157 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12158 opti_type |= OPTI_TYPE_NOT_ITERATED;
12159
12160 if (attack_mode == ATTACK_MODE_BF)
12161 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12162
12163 data.opti_type = opti_type;
12164
12165 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12166 {
12167 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12168 {
12169 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12170 {
12171 if (opts_type & OPTS_TYPE_ST_ADD80)
12172 {
12173 opts_type &= ~OPTS_TYPE_ST_ADD80;
12174 opts_type |= OPTS_TYPE_PT_ADD80;
12175 }
12176
12177 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12178 {
12179 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12180 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12181 }
12182
12183 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12184 {
12185 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12186 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12187 }
12188 }
12189 }
12190 }
12191
12192 /**
12193 * Some algorithm, like descrypt, can benefit from JIT compilation
12194 */
12195
12196 int force_jit_compilation = -1;
12197
12198 if (hash_mode == 8900)
12199 {
12200 force_jit_compilation = 8900;
12201 }
12202 else if (hash_mode == 9300)
12203 {
12204 force_jit_compilation = 8900;
12205 }
12206 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12207 {
12208 force_jit_compilation = 1500;
12209 }
12210
12211 /**
12212 * generate bitmap tables
12213 */
12214
12215 const uint bitmap_shift1 = 5;
12216 const uint bitmap_shift2 = 13;
12217
12218 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12219
12220 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12221 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12222 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12223 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12224 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12225 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12226 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12227 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12228
12229 uint bitmap_bits;
12230 uint bitmap_nums;
12231 uint bitmap_mask;
12232 uint bitmap_size;
12233
12234 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12235 {
12236 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12237
12238 bitmap_nums = 1 << bitmap_bits;
12239
12240 bitmap_mask = bitmap_nums - 1;
12241
12242 bitmap_size = bitmap_nums * sizeof (uint);
12243
12244 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12245
12246 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;
12247 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;
12248
12249 break;
12250 }
12251
12252 bitmap_nums = 1 << bitmap_bits;
12253
12254 bitmap_mask = bitmap_nums - 1;
12255
12256 bitmap_size = bitmap_nums * sizeof (uint);
12257
12258 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);
12259 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);
12260
12261 /**
12262 * prepare quick rule
12263 */
12264
12265 data.rule_buf_l = rule_buf_l;
12266 data.rule_buf_r = rule_buf_r;
12267
12268 int rule_len_l = (int) strlen (rule_buf_l);
12269 int rule_len_r = (int) strlen (rule_buf_r);
12270
12271 data.rule_len_l = rule_len_l;
12272 data.rule_len_r = rule_len_r;
12273
12274 /**
12275 * load rules
12276 */
12277
12278 uint *all_kernel_rules_cnt = NULL;
12279
12280 kernel_rule_t **all_kernel_rules_buf = NULL;
12281
12282 if (rp_files_cnt)
12283 {
12284 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12285
12286 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12287 }
12288
12289 char rule_buf[BUFSIZ] = { 0 };
12290
12291 int rule_len = 0;
12292
12293 for (uint i = 0; i < rp_files_cnt; i++)
12294 {
12295 uint kernel_rules_avail = 0;
12296
12297 uint kernel_rules_cnt = 0;
12298
12299 kernel_rule_t *kernel_rules_buf = NULL;
12300
12301 char *rp_file = rp_files[i];
12302
12303 char in[BLOCK_SIZE] = { 0 };
12304 char out[BLOCK_SIZE] = { 0 };
12305
12306 FILE *fp = NULL;
12307
12308 uint rule_line = 0;
12309
12310 if ((fp = fopen (rp_file, "rb")) == NULL)
12311 {
12312 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12313
12314 return (-1);
12315 }
12316
12317 while (!feof (fp))
12318 {
12319 memset (rule_buf, 0, BUFSIZ);
12320
12321 rule_len = fgetl (fp, rule_buf);
12322
12323 rule_line++;
12324
12325 if (rule_len == 0) continue;
12326
12327 if (rule_buf[0] == '#') continue;
12328
12329 if (kernel_rules_avail == kernel_rules_cnt)
12330 {
12331 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12332
12333 kernel_rules_avail += INCR_RULES;
12334 }
12335
12336 memset (in, 0, BLOCK_SIZE);
12337 memset (out, 0, BLOCK_SIZE);
12338
12339 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12340
12341 if (result == -1)
12342 {
12343 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12344
12345 continue;
12346 }
12347
12348 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12349 {
12350 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12351
12352 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12353
12354 continue;
12355 }
12356
12357 /* its so slow
12358 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12359 {
12360 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12361
12362 continue;
12363 }
12364 */
12365
12366 kernel_rules_cnt++;
12367 }
12368
12369 fclose (fp);
12370
12371 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12372
12373 all_kernel_rules_buf[i] = kernel_rules_buf;
12374 }
12375
12376 /**
12377 * merge rules or automatic rule generator
12378 */
12379
12380 uint kernel_rules_cnt = 0;
12381
12382 kernel_rule_t *kernel_rules_buf = NULL;
12383
12384 if (attack_mode == ATTACK_MODE_STRAIGHT)
12385 {
12386 if (rp_files_cnt)
12387 {
12388 kernel_rules_cnt = 1;
12389
12390 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12391
12392 repeats[0] = kernel_rules_cnt;
12393
12394 for (uint i = 0; i < rp_files_cnt; i++)
12395 {
12396 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12397
12398 repeats[i + 1] = kernel_rules_cnt;
12399 }
12400
12401 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12402
12403 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12404
12405 for (uint i = 0; i < kernel_rules_cnt; i++)
12406 {
12407 uint out_pos = 0;
12408
12409 kernel_rule_t *out = &kernel_rules_buf[i];
12410
12411 for (uint j = 0; j < rp_files_cnt; j++)
12412 {
12413 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12414 uint in_pos;
12415
12416 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12417
12418 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12419 {
12420 if (out_pos == RULES_MAX - 1)
12421 {
12422 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12423
12424 break;
12425 }
12426
12427 out->cmds[out_pos] = in->cmds[in_pos];
12428 }
12429 }
12430 }
12431
12432 local_free (repeats);
12433 }
12434 else if (rp_gen)
12435 {
12436 uint kernel_rules_avail = 0;
12437
12438 while (kernel_rules_cnt < rp_gen)
12439 {
12440 if (kernel_rules_avail == kernel_rules_cnt)
12441 {
12442 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12443
12444 kernel_rules_avail += INCR_RULES;
12445 }
12446
12447 memset (rule_buf, 0, BLOCK_SIZE);
12448
12449 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12450
12451 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12452
12453 kernel_rules_cnt++;
12454 }
12455 }
12456 }
12457
12458 /**
12459 * generate NOP rules
12460 */
12461
12462 if (kernel_rules_cnt == 0)
12463 {
12464 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12465
12466 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12467
12468 kernel_rules_cnt++;
12469 }
12470
12471 data.kernel_rules_cnt = kernel_rules_cnt;
12472 data.kernel_rules_buf = kernel_rules_buf;
12473
12474 /**
12475 * OpenCL platforms: detect
12476 */
12477
12478 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12479 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12480
12481 cl_uint platforms_cnt = 0;
12482 cl_uint platform_devices_cnt = 0;
12483
12484 if (keyspace == 0)
12485 {
12486 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12487
12488 if (platforms_cnt == 0)
12489 {
12490 log_error ("ERROR: No OpenCL compatible platform found");
12491
12492 return (-1);
12493 }
12494 }
12495
12496 /**
12497 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12498 */
12499
12500 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12501 {
12502 cl_platform_id platform = platforms[platform_id];
12503
12504 char platform_vendor[INFOSZ] = { 0 };
12505
12506 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12507
12508 #ifdef HAVE_HWMON
12509 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12510 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12511 {
12512 // make sure that we do not directly control the fan for NVidia
12513
12514 gpu_temp_retain = 0;
12515
12516 data.gpu_temp_retain = gpu_temp_retain;
12517 }
12518 #endif // HAVE_NVML || HAVE_NVAPI
12519 #endif
12520 }
12521
12522 /**
12523 * OpenCL devices: simply push all devices from all platforms into the same device array
12524 */
12525
12526 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12527
12528 data.devices_param = devices_param;
12529
12530 uint devices_cnt = 0;
12531
12532 uint devices_active = 0;
12533
12534 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12535 {
12536 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12537
12538 cl_platform_id platform = platforms[platform_id];
12539
12540 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12541
12542 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12543 {
12544 size_t param_value_size = 0;
12545
12546 const uint device_id = devices_cnt;
12547
12548 hc_device_param_t *device_param = &data.devices_param[device_id];
12549
12550 device_param->device = platform_devices[platform_devices_id];
12551
12552 device_param->device_id = device_id;
12553
12554 device_param->platform_devices_id = platform_devices_id;
12555
12556 // device_type
12557
12558 cl_device_type device_type;
12559
12560 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12561
12562 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12563
12564 device_param->device_type = device_type;
12565
12566 // vendor_id
12567
12568 cl_uint vendor_id = 0;
12569
12570 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12571
12572 device_param->vendor_id = vendor_id;
12573
12574 // device_name
12575
12576 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12577
12578 char *device_name = (char *) mymalloc (param_value_size);
12579
12580 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12581
12582 device_param->device_name = device_name;
12583
12584 // tuning db
12585
12586 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12587
12588 // device_version
12589
12590 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12591
12592 char *device_version = (char *) mymalloc (param_value_size);
12593
12594 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12595
12596 device_param->device_version = device_version;
12597
12598 // device_opencl_version
12599
12600 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12601
12602 char *device_opencl_version = (char *) mymalloc (param_value_size);
12603
12604 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12605
12606 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12607
12608 myfree (device_opencl_version);
12609
12610 if (strstr (device_version, "pocl"))
12611 {
12612 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12613 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12614
12615 cl_uint vendor_id = VENDOR_ID_GENERIC;
12616
12617 device_param->vendor_id = vendor_id;
12618 }
12619
12620 // vector_width
12621
12622 cl_uint vector_width;
12623
12624 if (opencl_vector_width_chgd == 0)
12625 {
12626 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12627 {
12628 if (opti_type & OPTI_TYPE_USES_BITS_64)
12629 {
12630 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12631 }
12632 else
12633 {
12634 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12635 }
12636 }
12637 else
12638 {
12639 vector_width = (cl_uint) tuningdb_entry->vector_width;
12640 }
12641 }
12642 else
12643 {
12644 vector_width = opencl_vector_width;
12645 }
12646
12647 if (vector_width > 16) vector_width = 16;
12648
12649 device_param->vector_width = vector_width;
12650
12651 // max_compute_units
12652
12653 cl_uint device_processors;
12654
12655 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12656
12657 device_param->device_processors = device_processors;
12658
12659 // max_mem_alloc_size
12660
12661 cl_ulong device_maxmem_alloc;
12662
12663 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12664
12665 device_param->device_maxmem_alloc = device_maxmem_alloc;
12666
12667 // max_mem_alloc_size
12668
12669 cl_ulong device_global_mem;
12670
12671 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12672
12673 device_param->device_global_mem = device_global_mem;
12674
12675 // max_clock_frequency
12676
12677 cl_uint device_maxclock_frequency;
12678
12679 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12680
12681 device_param->device_maxclock_frequency = device_maxclock_frequency;
12682
12683 // skipped
12684
12685 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12686 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12687
12688 device_param->skipped = (skipped1 || skipped2);
12689
12690 // driver_version
12691 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12692
12693 char *driver_version = (char *) mymalloc (param_value_size);
12694
12695 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12696
12697 device_param->driver_version = driver_version;
12698
12699 // device_name_chksum
12700
12701 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12702
12703 #if __x86_64__
12704 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);
12705 #else
12706 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);
12707 #endif
12708
12709 uint device_name_digest[4] = { 0 };
12710
12711 md5_64 ((uint *) device_name_chksum, device_name_digest);
12712
12713 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12714
12715 device_param->device_name_chksum = device_name_chksum;
12716
12717 // device_processor_cores
12718
12719 if (device_type & CL_DEVICE_TYPE_CPU)
12720 {
12721 cl_uint device_processor_cores = 1;
12722
12723 device_param->device_processor_cores = device_processor_cores;
12724 }
12725
12726 if (device_type & CL_DEVICE_TYPE_GPU)
12727 {
12728 if (vendor_id == VENDOR_ID_AMD)
12729 {
12730 cl_uint device_processor_cores = 0;
12731
12732 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12733
12734 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12735
12736 device_param->device_processor_cores = device_processor_cores;
12737 }
12738 else if (vendor_id == VENDOR_ID_NV)
12739 {
12740 cl_uint kernel_exec_timeout = 0;
12741
12742 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12743
12744 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12745
12746 device_param->kernel_exec_timeout = kernel_exec_timeout;
12747
12748 cl_uint device_processor_cores = 0;
12749
12750 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12751
12752 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12753
12754 device_param->device_processor_cores = device_processor_cores;
12755
12756 cl_uint sm_minor = 0;
12757 cl_uint sm_major = 0;
12758
12759 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12760 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12761
12762 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12763 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12764
12765 device_param->sm_minor = sm_minor;
12766 device_param->sm_major = sm_major;
12767 }
12768 else
12769 {
12770 cl_uint device_processor_cores = 1;
12771
12772 device_param->device_processor_cores = device_processor_cores;
12773 }
12774 }
12775
12776 // display results
12777
12778 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12779 {
12780 if (device_param->skipped == 0)
12781 {
12782 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12783 device_id + 1,
12784 device_name,
12785 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12786 (unsigned int) (device_global_mem / 1024 / 1024),
12787 (unsigned int) (device_maxclock_frequency),
12788 (unsigned int) device_processors);
12789 }
12790 else
12791 {
12792 log_info ("Device #%u: %s, skipped",
12793 device_id + 1,
12794 device_name);
12795 }
12796 }
12797
12798 // common driver check
12799
12800 if (device_param->skipped == 0)
12801 {
12802 if (strstr (device_version, "pocl"))
12803 {
12804 if (force == 0)
12805 {
12806 log_info ("");
12807 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12808 log_info ("You are STRONGLY encouraged not to use it");
12809 log_info ("You can use --force to override this but do not post error reports if you do so");
12810 log_info ("");
12811
12812 return (-1);
12813 }
12814 }
12815
12816 if (device_type & CL_DEVICE_TYPE_GPU)
12817 {
12818 if (vendor_id == VENDOR_ID_NV)
12819 {
12820 if (device_param->kernel_exec_timeout != 0)
12821 {
12822 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);
12823 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12824 }
12825 }
12826 else if (vendor_id == VENDOR_ID_AMD)
12827 {
12828 int catalyst_check = (force == 1) ? 0 : 1;
12829
12830 int catalyst_warn = 0;
12831
12832 int catalyst_broken = 0;
12833
12834 if (catalyst_check == 1)
12835 {
12836 catalyst_warn = 1;
12837
12838 // v14.9 and higher
12839 if (atoi (device_param->driver_version) >= 1573)
12840 {
12841 catalyst_warn = 0;
12842 }
12843
12844 catalyst_check = 0;
12845 }
12846
12847 if (catalyst_broken == 1)
12848 {
12849 log_info ("");
12850 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12851 log_info ("It will pass over cracked hashes and does not report them as cracked");
12852 log_info ("You are STRONGLY encouraged not to use it");
12853 log_info ("You can use --force to override this but do not post error reports if you do so");
12854 log_info ("");
12855
12856 return (-1);
12857 }
12858
12859 if (catalyst_warn == 1)
12860 {
12861 log_info ("");
12862 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12863 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12864 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12865 #ifdef _WIN
12866 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12867 #endif
12868 log_info ("You can use --force to override this but do not post error reports if you do so");
12869 log_info ("");
12870
12871 return (-1);
12872 }
12873 }
12874 }
12875
12876 /**
12877 * kernel accel and loops tuning db adjustment
12878 */
12879
12880 device_param->kernel_accel_min = 1;
12881 device_param->kernel_accel_max = 1024;
12882
12883 device_param->kernel_loops_min = 1;
12884 device_param->kernel_loops_max = 1024;
12885
12886 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12887
12888 if (tuningdb_entry)
12889 {
12890 u32 _kernel_accel = tuningdb_entry->kernel_accel;
12891 u32 _kernel_loops = tuningdb_entry->kernel_loops;
12892
12893 if (_kernel_accel)
12894 {
12895 device_param->kernel_accel_min = _kernel_accel;
12896 device_param->kernel_accel_max = _kernel_accel;
12897 }
12898
12899 if (_kernel_loops)
12900 {
12901 if (workload_profile == 1)
12902 {
12903 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
12904 }
12905 else if (workload_profile == 2)
12906 {
12907 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
12908 }
12909
12910 device_param->kernel_loops_min = _kernel_loops;
12911 device_param->kernel_loops_max = _kernel_loops;
12912 }
12913 }
12914
12915 // commandline parameters overwrite tuningdb entries
12916
12917 if (kernel_accel)
12918 {
12919 device_param->kernel_accel_min = kernel_accel;
12920 device_param->kernel_accel_max = kernel_accel;
12921 }
12922
12923 if (kernel_loops)
12924 {
12925 device_param->kernel_loops_min = kernel_loops;
12926 device_param->kernel_loops_max = kernel_loops;
12927 }
12928
12929 /**
12930 * activate device
12931 */
12932
12933 devices_active++;
12934 }
12935
12936 // next please
12937
12938 devices_cnt++;
12939 }
12940 }
12941
12942 if (keyspace == 0 && devices_active == 0)
12943 {
12944 log_error ("ERROR: No devices found/left");
12945
12946 return (-1);
12947 }
12948
12949 data.devices_cnt = devices_cnt;
12950
12951 data.devices_active = devices_active;
12952
12953 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12954 {
12955 log_info ("");
12956 }
12957
12958 /**
12959 * HM devices: init
12960 */
12961
12962 #ifdef HAVE_HWMON
12963 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12964 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12965 #endif
12966
12967 #ifdef HAVE_ADL
12968 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12969 #endif
12970
12971 if (gpu_temp_disable == 0)
12972 {
12973 #if defined(WIN) && defined(HAVE_NVAPI)
12974 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
12975
12976 if (nvapi_init (nvapi) == 0)
12977 data.hm_nv = nvapi;
12978
12979 if (data.hm_nv)
12980 {
12981 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
12982 {
12983 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
12984
12985 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12986
12987 int tmp_out = 0;
12988
12989 for (int i = 0; i < tmp_in; i++)
12990 {
12991 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12992 }
12993
12994 for (int i = 0; i < tmp_out; i++)
12995 {
12996 NV_GPU_COOLER_SETTINGS pCoolerSettings;
12997
12998 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
12999
13000 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;
13001 }
13002 }
13003 }
13004 #endif // WIN && HAVE_NVAPI
13005
13006 #if defined(LINUX) && defined(HAVE_NVML)
13007 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13008
13009 if (nvml_init (nvml) == 0)
13010 data.hm_nv = nvml;
13011
13012 if (data.hm_nv)
13013 {
13014 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13015 {
13016 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13017
13018 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13019
13020 int tmp_out = 0;
13021
13022 for (int i = 0; i < tmp_in; i++)
13023 {
13024 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13025 }
13026
13027 for (int i = 0; i < tmp_out; i++)
13028 {
13029 unsigned int speed;
13030
13031 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;
13032 }
13033 }
13034 }
13035 #endif // LINUX && HAVE_NVML
13036
13037 data.hm_amd = NULL;
13038
13039 #ifdef HAVE_ADL
13040 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13041
13042 if (adl_init (adl) == 0)
13043 data.hm_amd = adl;
13044
13045 if (data.hm_amd)
13046 {
13047 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13048 {
13049 // total number of adapters
13050
13051 int hm_adapters_num;
13052
13053 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13054
13055 // adapter info
13056
13057 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13058
13059 if (lpAdapterInfo == NULL) return (-1);
13060
13061 // get a list (of ids of) valid/usable adapters
13062
13063 int num_adl_adapters = 0;
13064
13065 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13066
13067 if (num_adl_adapters > 0)
13068 {
13069 hc_thread_mutex_lock (mux_adl);
13070
13071 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13072
13073 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13074
13075 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13076 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13077
13078 hc_thread_mutex_unlock (mux_adl);
13079 }
13080
13081 myfree (valid_adl_device_list);
13082 myfree (lpAdapterInfo);
13083 }
13084 }
13085 #endif // HAVE_ADL
13086
13087 if (data.hm_amd == NULL && data.hm_nv == NULL)
13088 {
13089 gpu_temp_disable = 1;
13090 }
13091 }
13092
13093 /**
13094 * OpenCL devices: allocate buffer for device specific information
13095 */
13096
13097 #ifdef HAVE_HWMON
13098 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13099
13100 #ifdef HAVE_ADL
13101 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13102
13103 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13104 #endif // ADL
13105 #endif
13106
13107 /**
13108 * enable custom signal handler(s)
13109 */
13110
13111 if (benchmark == 0)
13112 {
13113 hc_signal (sigHandler_default);
13114 }
13115 else
13116 {
13117 hc_signal (sigHandler_benchmark);
13118 }
13119
13120 /**
13121 * User-defined GPU temp handling
13122 */
13123
13124 #ifdef HAVE_HWMON
13125 if (gpu_temp_disable == 1)
13126 {
13127 gpu_temp_abort = 0;
13128 gpu_temp_retain = 0;
13129 }
13130
13131 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13132 {
13133 if (gpu_temp_abort < gpu_temp_retain)
13134 {
13135 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13136
13137 return (-1);
13138 }
13139 }
13140
13141 data.gpu_temp_disable = gpu_temp_disable;
13142 data.gpu_temp_abort = gpu_temp_abort;
13143 data.gpu_temp_retain = gpu_temp_retain;
13144 #endif
13145
13146 /**
13147 * inform the user
13148 */
13149
13150 if (data.quiet == 0)
13151 {
13152 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13153
13154 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);
13155
13156 if (attack_mode == ATTACK_MODE_STRAIGHT)
13157 {
13158 log_info ("Rules: %u", kernel_rules_cnt);
13159 }
13160
13161 if (opti_type)
13162 {
13163 log_info ("Applicable Optimizers:");
13164
13165 for (uint i = 0; i < 32; i++)
13166 {
13167 const uint opti_bit = 1u << i;
13168
13169 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13170 }
13171 }
13172
13173 /**
13174 * Watchdog and Temperature balance
13175 */
13176
13177 #ifdef HAVE_HWMON
13178 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13179 {
13180 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13181 }
13182
13183 if (gpu_temp_abort == 0)
13184 {
13185 log_info ("Watchdog: Temperature abort trigger disabled");
13186 }
13187 else
13188 {
13189 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13190 }
13191
13192 if (gpu_temp_retain == 0)
13193 {
13194 log_info ("Watchdog: Temperature retain trigger disabled");
13195 }
13196 else
13197 {
13198 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13199 }
13200 #endif
13201 }
13202
13203 if (data.quiet == 0) log_info ("");
13204
13205 /**
13206 * HM devices: copy
13207 */
13208
13209 if (gpu_temp_disable == 0)
13210 {
13211 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13212 {
13213 hc_device_param_t *device_param = &data.devices_param[device_id];
13214
13215 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13216
13217 if (device_param->skipped) continue;
13218
13219 const uint platform_devices_id = device_param->platform_devices_id;
13220
13221 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13222 if (device_param->vendor_id == VENDOR_ID_NV)
13223 {
13224 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13225 }
13226 #endif
13227
13228 #ifdef HAVE_ADL
13229 if (device_param->vendor_id == VENDOR_ID_AMD)
13230 {
13231 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13232 }
13233 #endif
13234 }
13235 }
13236
13237 /*
13238 * Temporary fix:
13239 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13240 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13241 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13242 * Driver / ADL bug?
13243 */
13244
13245 #ifdef HAVE_ADL
13246 if (powertune_enable == 1)
13247 {
13248 hc_thread_mutex_lock (mux_adl);
13249
13250 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13251 {
13252 hc_device_param_t *device_param = &data.devices_param[device_id];
13253
13254 if (device_param->skipped) continue;
13255
13256 if (data.hm_device[device_id].od_version == 6)
13257 {
13258 // set powertune value only
13259
13260 int powertune_supported = 0;
13261
13262 int ADL_rc = 0;
13263
13264 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13265 {
13266 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13267
13268 return (-1);
13269 }
13270
13271 if (powertune_supported != 0)
13272 {
13273 // powertune set
13274 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13275
13276 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13277 {
13278 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13279
13280 return (-1);
13281 }
13282
13283 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13284 {
13285 log_error ("ERROR: Failed to set new ADL PowerControl values");
13286
13287 return (-1);
13288 }
13289 }
13290 }
13291 }
13292
13293 hc_thread_mutex_unlock (mux_adl);
13294 }
13295 #endif // HAVE_ADK
13296 #endif // HAVE_HWMON
13297
13298 #ifdef DEBUG
13299 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13300 #endif
13301
13302 uint kernel_power_all = 0;
13303
13304 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13305 {
13306 /**
13307 * host buffer
13308 */
13309
13310 hc_device_param_t *device_param = &data.devices_param[device_id];
13311
13312 if (device_param->skipped) continue;
13313
13314 /**
13315 * device properties
13316 */
13317
13318 const char *device_name_chksum = device_param->device_name_chksum;
13319 const u32 device_processors = device_param->device_processors;
13320 const u32 device_processor_cores = device_param->device_processor_cores;
13321
13322 /**
13323 * create context for each device
13324 */
13325
13326 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13327
13328 /**
13329 * create command-queue
13330 */
13331
13332 // not supported with NV
13333 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13334
13335 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13336
13337 /**
13338 * create input buffers on device : calculate size of fixed memory buffers
13339 */
13340
13341 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13342 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13343
13344 device_param->size_root_css = size_root_css;
13345 device_param->size_markov_css = size_markov_css;
13346
13347 uint size_results = KERNEL_THREADS * sizeof (uint);
13348
13349 device_param->size_results = size_results;
13350
13351 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13352 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13353
13354 uint size_plains = digests_cnt * sizeof (plain_t);
13355 uint size_salts = salts_cnt * sizeof (salt_t);
13356 uint size_esalts = salts_cnt * esalt_size;
13357
13358 device_param->size_plains = size_plains;
13359 device_param->size_digests = size_digests;
13360 device_param->size_shown = size_shown;
13361 device_param->size_salts = size_salts;
13362
13363 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13364 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13365 uint size_tm = 32 * sizeof (bs_word_t);
13366
13367 // scryptV stuff
13368
13369 u64 size_scryptV = 1;
13370
13371 if ((hash_mode == 8900) || (hash_mode == 9300))
13372 {
13373 uint tmto_start = 0;
13374 uint tmto_stop = 10;
13375
13376 if (scrypt_tmto)
13377 {
13378 tmto_start = scrypt_tmto;
13379 }
13380 else
13381 {
13382 // in case the user did not specify the tmto manually
13383 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13384 // but set the lower end only in case the user has a device with too less memory
13385
13386 if (hash_mode == 8900)
13387 {
13388 if (device_param->vendor_id == VENDOR_ID_AMD)
13389 {
13390 tmto_start = 1;
13391 }
13392 else if (device_param->vendor_id == VENDOR_ID_NV)
13393 {
13394 tmto_start = 3;
13395 }
13396 }
13397 else if (hash_mode == 9300)
13398 {
13399 if (device_param->vendor_id == VENDOR_ID_AMD)
13400 {
13401 tmto_start = 3;
13402 }
13403 else if (device_param->vendor_id == VENDOR_ID_NV)
13404 {
13405 tmto_start = 5;
13406 }
13407 }
13408 }
13409
13410 if (quiet == 0) log_info ("");
13411
13412 uint shader_per_mp = 1;
13413
13414 if (device_param->vendor_id == VENDOR_ID_AMD)
13415 {
13416 shader_per_mp = 8;
13417 }
13418 else if (device_param->vendor_id == VENDOR_ID_NV)
13419 {
13420 shader_per_mp = 32;
13421 }
13422
13423 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13424 {
13425 // TODO: in theory the following calculation needs to be done per salt, not global
13426 // we assume all hashes have the same scrypt settings
13427
13428 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13429
13430 size_scryptV /= 1 << tmto;
13431
13432 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13433
13434 if (size_scryptV > device_param->device_maxmem_alloc)
13435 {
13436 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13437
13438 continue;
13439 }
13440
13441 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13442 {
13443 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13444 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13445 }
13446
13447 break;
13448 }
13449
13450 if (data.salts_buf[0].scrypt_phy == 0)
13451 {
13452 log_error ("ERROR: can't allocate enough device memory");
13453
13454 return -1;
13455 }
13456
13457 if (quiet == 0) log_info ("");
13458 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13459 }
13460
13461 /**
13462 * create input buffers on device : calculate size of dynamic size memory buffers
13463 */
13464
13465 uint kernel_threads = KERNEL_THREADS;
13466
13467 // some algorithms need a fixed kernel-threads count (mostly because of shared memory usage)
13468
13469 if (hash_mode == 3200) kernel_threads = 8;
13470 if (hash_mode == 9000) kernel_threads = 8;
13471
13472 /**
13473 * some algorithms need a fixed kernel-loops count
13474 */
13475
13476 if (hash_mode == 1500)
13477 {
13478 const u32 kernel_loops_fixed = 1024;
13479
13480 device_param->kernel_loops_min = kernel_loops_fixed;
13481 device_param->kernel_loops_max = kernel_loops_fixed;
13482 }
13483
13484 if (hash_mode == 3000)
13485 {
13486 const u32 kernel_loops_fixed = 1024;
13487
13488 device_param->kernel_loops_min = kernel_loops_fixed;
13489 device_param->kernel_loops_max = kernel_loops_fixed;
13490 }
13491
13492 if (hash_mode == 8900)
13493 {
13494 const u32 kernel_loops_fixed = 1;
13495
13496 device_param->kernel_loops_min = kernel_loops_fixed;
13497 device_param->kernel_loops_max = kernel_loops_fixed;
13498 }
13499
13500 if (hash_mode == 9300)
13501 {
13502 const u32 kernel_loops_fixed = 1;
13503
13504 device_param->kernel_loops_min = kernel_loops_fixed;
13505 device_param->kernel_loops_max = kernel_loops_fixed;
13506 }
13507
13508 if (hash_mode == 12500)
13509 {
13510 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13511
13512 device_param->kernel_loops_min = kernel_loops_fixed;
13513 device_param->kernel_loops_max = kernel_loops_fixed;
13514 }
13515
13516 /**
13517 * some algorithms have a maximum kernel-loops count
13518 */
13519
13520 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13521 {
13522 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13523 {
13524 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13525 }
13526 }
13527
13528 /**
13529 * some algorithms need a special kernel-accel
13530 */
13531
13532 if (hash_mode == 8900)
13533 {
13534 device_param->kernel_accel_min = 1;
13535 device_param->kernel_accel_max = 64;
13536 }
13537
13538 if (hash_mode == 9300)
13539 {
13540 device_param->kernel_accel_min = 1;
13541 device_param->kernel_accel_max = 64;
13542 }
13543
13544 u32 kernel_accel_min = device_param->kernel_accel_min;
13545 u32 kernel_accel_max = device_param->kernel_accel_max;
13546
13547 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13548
13549 uint size_pws = 4;
13550 uint size_tmps = 4;
13551 uint size_hooks = 4;
13552
13553 while (kernel_accel_max >= kernel_accel_min)
13554 {
13555 uint kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13556
13557 // size_pws
13558
13559 size_pws = kernel_power_max * sizeof (pw_t);
13560
13561 // size_tmps
13562
13563 switch (hash_mode)
13564 {
13565 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13566 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13567 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13568 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13569 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13570 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13571 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13572 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13573 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13574 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13575 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13576 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13577 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13578 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13579 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13580 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13581 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13582 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13583 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13584 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13585 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13586 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13587 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13588 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13589 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13590 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13591 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13592 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13593 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13594 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13595 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13596 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13597 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13598 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13599 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13600 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13601 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13602 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13603 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13604 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13605 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13606 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13607 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13608 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13609 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13610 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13611 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13612 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13613 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13614 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13615 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13616 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13617 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13618 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13619 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13620 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13621 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13622 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13623 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13624 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13625 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13626 };
13627
13628 // size_hooks
13629
13630 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13631 {
13632 // none yet
13633 }
13634
13635 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13636 // if not, decrease amplifier and try again
13637
13638 int skip = 0;
13639
13640 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13641 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13642 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13643
13644 if (( bitmap_size
13645 + bitmap_size
13646 + bitmap_size
13647 + bitmap_size
13648 + bitmap_size
13649 + bitmap_size
13650 + bitmap_size
13651 + bitmap_size
13652 + size_bfs
13653 + size_combs
13654 + size_digests
13655 + size_esalts
13656 + size_hooks
13657 + size_markov_css
13658 + size_plains
13659 + size_pws
13660 + size_results
13661 + size_root_css
13662 + size_rules
13663 + size_rules_c
13664 + size_salts
13665 + size_scryptV
13666 + size_shown
13667 + size_tm
13668 + size_tmps) > device_param->device_global_mem) skip = 1;
13669
13670 if (skip == 1)
13671 {
13672 kernel_accel_max--;
13673
13674 continue;
13675 }
13676
13677 break;
13678 }
13679
13680 /*
13681 if (kernel_accel_max == 0)
13682 {
13683 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13684
13685 return -1;
13686 }
13687 */
13688
13689 device_param->kernel_accel_min = kernel_accel_min;
13690 device_param->kernel_accel_max = kernel_accel_max;
13691
13692 /*
13693 if (kernel_accel_max < kernel_accel)
13694 {
13695 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13696
13697 device_param->kernel_accel = kernel_accel_max;
13698 }
13699 */
13700
13701 device_param->size_bfs = size_bfs;
13702 device_param->size_combs = size_combs;
13703 device_param->size_rules = size_rules;
13704 device_param->size_rules_c = size_rules_c;
13705 device_param->size_pws = size_pws;
13706 device_param->size_tmps = size_tmps;
13707 device_param->size_hooks = size_hooks;
13708
13709 // do not confuse kernel_accel_max with kernel_accel here
13710
13711 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13712
13713 device_param->kernel_threads = kernel_threads;
13714 device_param->kernel_power_user = kernel_power;
13715
13716 kernel_power_all += kernel_power;
13717
13718 /**
13719 * default building options
13720 */
13721
13722 char build_opts[1024] = { 0 };
13723
13724 // we don't have sm_* on vendors not NV but it doesn't matter
13725
13726 snprintf (build_opts, sizeof (build_opts) - 1, "-I%s/ -DVENDOR_ID=%u -DCUDA_ARCH=%d -DVECT_SIZE=%u -DDEVICE_TYPE=%u", shared_dir, device_param->vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type);
13727
13728 /**
13729 * main kernel
13730 */
13731
13732 {
13733 /**
13734 * kernel source filename
13735 */
13736
13737 char source_file[256] = { 0 };
13738
13739 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13740
13741 struct stat sst;
13742
13743 if (stat (source_file, &sst) == -1)
13744 {
13745 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13746
13747 return -1;
13748 }
13749
13750 /**
13751 * kernel cached filename
13752 */
13753
13754 char cached_file[256] = { 0 };
13755
13756 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13757
13758 int cached = 1;
13759
13760 struct stat cst;
13761
13762 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13763 {
13764 cached = 0;
13765 }
13766
13767 /**
13768 * kernel compile or load
13769 */
13770
13771 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13772
13773 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13774
13775 if (force_jit_compilation == -1)
13776 {
13777 if (cached == 0)
13778 {
13779 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13780
13781 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13782
13783 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13784
13785 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13786
13787 if (rc != 0)
13788 {
13789 device_param->skipped = true;
13790 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13791 continue;
13792 }
13793
13794 size_t binary_size;
13795
13796 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13797
13798 u8 *binary = (u8 *) mymalloc (binary_size);
13799
13800 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13801
13802 writeProgramBin (cached_file, binary, binary_size);
13803
13804 local_free (binary);
13805 }
13806 else
13807 {
13808 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13809
13810 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13811
13812 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13813
13814 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
13815 }
13816 }
13817 else
13818 {
13819 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13820
13821 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13822
13823 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13824
13825 char build_opts_update[1024] = { 0 };
13826
13827 if (force_jit_compilation == 1500)
13828 {
13829 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13830 }
13831 else if (force_jit_compilation == 8900)
13832 {
13833 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);
13834 }
13835 else
13836 {
13837 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
13838 }
13839
13840 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
13841
13842 if (rc != 0)
13843 {
13844 device_param->skipped = true;
13845
13846 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13847 }
13848 }
13849
13850 local_free (kernel_lengths);
13851 local_free (kernel_sources[0]);
13852 local_free (kernel_sources);
13853 }
13854
13855 /**
13856 * word generator kernel
13857 */
13858
13859 if (attack_mode != ATTACK_MODE_STRAIGHT)
13860 {
13861 /**
13862 * kernel mp source filename
13863 */
13864
13865 char source_file[256] = { 0 };
13866
13867 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13868
13869 struct stat sst;
13870
13871 if (stat (source_file, &sst) == -1)
13872 {
13873 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13874
13875 return -1;
13876 }
13877
13878 /**
13879 * kernel mp cached filename
13880 */
13881
13882 char cached_file[256] = { 0 };
13883
13884 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13885
13886 int cached = 1;
13887
13888 struct stat cst;
13889
13890 if (stat (cached_file, &cst) == -1)
13891 {
13892 cached = 0;
13893 }
13894
13895 /**
13896 * kernel compile or load
13897 */
13898
13899 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13900
13901 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13902
13903 if (cached == 0)
13904 {
13905 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13906
13907 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13908
13909 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13910
13911 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
13912
13913 if (rc != 0)
13914 {
13915 device_param->skipped = true;
13916 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13917 continue;
13918 }
13919
13920 size_t binary_size;
13921
13922 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13923
13924 u8 *binary = (u8 *) mymalloc (binary_size);
13925
13926 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13927
13928 writeProgramBin (cached_file, binary, binary_size);
13929
13930 local_free (binary);
13931 }
13932 else
13933 {
13934 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13935
13936 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13937
13938 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13939
13940 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
13941 }
13942
13943 local_free (kernel_lengths);
13944 local_free (kernel_sources[0]);
13945 local_free (kernel_sources);
13946 }
13947
13948 /**
13949 * amplifier kernel
13950 */
13951
13952 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13953 {
13954
13955 }
13956 else
13957 {
13958 /**
13959 * kernel amp source filename
13960 */
13961
13962 char source_file[256] = { 0 };
13963
13964 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13965
13966 struct stat sst;
13967
13968 if (stat (source_file, &sst) == -1)
13969 {
13970 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13971
13972 return -1;
13973 }
13974
13975 /**
13976 * kernel amp cached filename
13977 */
13978
13979 char cached_file[256] = { 0 };
13980
13981 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
13982
13983 int cached = 1;
13984
13985 struct stat cst;
13986
13987 if (stat (cached_file, &cst) == -1)
13988 {
13989 cached = 0;
13990 }
13991
13992 /**
13993 * kernel compile or load
13994 */
13995
13996 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13997
13998 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13999
14000 if (cached == 0)
14001 {
14002 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14003
14004 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14005
14006 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14007
14008 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14009
14010 if (rc != 0)
14011 {
14012 device_param->skipped = true;
14013 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14014 continue;
14015 }
14016
14017 size_t binary_size;
14018
14019 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14020
14021 u8 *binary = (u8 *) mymalloc (binary_size);
14022
14023 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14024
14025 writeProgramBin (cached_file, binary, binary_size);
14026
14027 local_free (binary);
14028 }
14029 else
14030 {
14031 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14032
14033 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14034
14035 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14036
14037 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14038 }
14039
14040 local_free (kernel_lengths);
14041 local_free (kernel_sources[0]);
14042 local_free (kernel_sources);
14043 }
14044
14045 // some algorithm collide too fast, make that impossible
14046
14047 if (benchmark == 1)
14048 {
14049 ((uint *) digests_buf)[0] = -1;
14050 ((uint *) digests_buf)[1] = -1;
14051 ((uint *) digests_buf)[2] = -1;
14052 ((uint *) digests_buf)[3] = -1;
14053 }
14054
14055 /**
14056 * global buffers
14057 */
14058
14059 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14060 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14061 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14062 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14063 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14064 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14065 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14066 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14067 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14068 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14069 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14070 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14071 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14072 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14073 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14074 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14075 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14076 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14077
14078 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);
14079 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);
14080 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);
14081 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);
14082 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);
14083 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);
14084 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);
14085 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);
14086 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14087 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14088 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14089
14090 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14091 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14092 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14093 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14094 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14095 run_kernel_bzero (device_param, device_param->d_result, size_results);
14096
14097 /**
14098 * special buffers
14099 */
14100
14101 if (attack_kern == ATTACK_KERN_STRAIGHT)
14102 {
14103 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14104 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14105
14106 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14107
14108 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14109 }
14110 else if (attack_kern == ATTACK_KERN_COMBI)
14111 {
14112 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14113 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14114 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14115 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14116
14117 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14118 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14119 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14120 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14121 }
14122 else if (attack_kern == ATTACK_KERN_BF)
14123 {
14124 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14125 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14126 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14127 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14128 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14129
14130 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14131 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14132 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14133 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14134 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14135 }
14136
14137 if (size_esalts)
14138 {
14139 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14140
14141 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14142 }
14143
14144 /**
14145 * main host data
14146 */
14147
14148 uint *result = (uint *) mymalloc (size_results);
14149
14150 device_param->result = result;
14151
14152 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14153
14154 device_param->pws_buf = pws_buf;
14155
14156 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14157
14158 device_param->combs_buf = combs_buf;
14159
14160 void *hooks_buf = mymalloc (size_hooks);
14161
14162 device_param->hooks_buf = hooks_buf;
14163
14164 /**
14165 * kernel args
14166 */
14167
14168 device_param->kernel_params_buf32[21] = bitmap_mask;
14169 device_param->kernel_params_buf32[22] = bitmap_shift1;
14170 device_param->kernel_params_buf32[23] = bitmap_shift2;
14171 device_param->kernel_params_buf32[24] = 0; // salt_pos
14172 device_param->kernel_params_buf32[25] = 0; // loop_pos
14173 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14174 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14175 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14176 device_param->kernel_params_buf32[29] = 0; // digests_offset
14177 device_param->kernel_params_buf32[30] = 0; // combs_mode
14178 device_param->kernel_params_buf32[31] = 0; // gid_max
14179
14180 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14181 ? &device_param->d_pws_buf
14182 : &device_param->d_pws_amp_buf;
14183 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14184 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14185 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14186 device_param->kernel_params[ 4] = &device_param->d_tmps;
14187 device_param->kernel_params[ 5] = &device_param->d_hooks;
14188 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14189 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14190 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14191 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14192 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14193 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14194 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14195 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14196 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14197 device_param->kernel_params[15] = &device_param->d_digests_buf;
14198 device_param->kernel_params[16] = &device_param->d_digests_shown;
14199 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14200 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14201 device_param->kernel_params[19] = &device_param->d_result;
14202 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14203 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14204 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14205 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14206 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14207 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14208 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14209 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14210 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14211 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14212 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14213 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14214
14215 device_param->kernel_params_mp_buf64[3] = 0;
14216 device_param->kernel_params_mp_buf32[4] = 0;
14217 device_param->kernel_params_mp_buf32[5] = 0;
14218 device_param->kernel_params_mp_buf32[6] = 0;
14219 device_param->kernel_params_mp_buf32[7] = 0;
14220 device_param->kernel_params_mp_buf32[8] = 0;
14221
14222 device_param->kernel_params_mp[0] = NULL;
14223 device_param->kernel_params_mp[1] = NULL;
14224 device_param->kernel_params_mp[2] = NULL;
14225 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14226 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14227 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14228 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14229 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14230 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14231
14232 device_param->kernel_params_mp_l_buf64[3] = 0;
14233 device_param->kernel_params_mp_l_buf32[4] = 0;
14234 device_param->kernel_params_mp_l_buf32[5] = 0;
14235 device_param->kernel_params_mp_l_buf32[6] = 0;
14236 device_param->kernel_params_mp_l_buf32[7] = 0;
14237 device_param->kernel_params_mp_l_buf32[8] = 0;
14238 device_param->kernel_params_mp_l_buf32[9] = 0;
14239
14240 device_param->kernel_params_mp_l[0] = NULL;
14241 device_param->kernel_params_mp_l[1] = NULL;
14242 device_param->kernel_params_mp_l[2] = NULL;
14243 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14244 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14245 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14246 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14247 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14248 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14249 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14250
14251 device_param->kernel_params_mp_r_buf64[3] = 0;
14252 device_param->kernel_params_mp_r_buf32[4] = 0;
14253 device_param->kernel_params_mp_r_buf32[5] = 0;
14254 device_param->kernel_params_mp_r_buf32[6] = 0;
14255 device_param->kernel_params_mp_r_buf32[7] = 0;
14256 device_param->kernel_params_mp_r_buf32[8] = 0;
14257
14258 device_param->kernel_params_mp_r[0] = NULL;
14259 device_param->kernel_params_mp_r[1] = NULL;
14260 device_param->kernel_params_mp_r[2] = NULL;
14261 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14262 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14263 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14264 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14265 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14266 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14267
14268 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14269 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14270
14271 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14272 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14273 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14274 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14275 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14276 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14277 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14278
14279 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14280
14281 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14282 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14283
14284 /**
14285 * kernel name
14286 */
14287
14288 char kernel_name[64] = { 0 };
14289
14290 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14291 {
14292 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14293 {
14294 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14295
14296 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14297
14298 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14299
14300 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14301
14302 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14303
14304 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14305 }
14306 else
14307 {
14308 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14309
14310 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14311
14312 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14313
14314 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14315
14316 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14317
14318 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14319 }
14320
14321 if (data.attack_mode == ATTACK_MODE_BF)
14322 {
14323 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14324 {
14325 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14326
14327 device_param->kernel_tb = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14328
14329 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14330
14331 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14332 }
14333 }
14334 }
14335 else
14336 {
14337 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14338
14339 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14340
14341 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14342
14343 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14344
14345 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14346
14347 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14348
14349 if (opts_type & OPTS_TYPE_HOOK12)
14350 {
14351 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14352
14353 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14354 }
14355
14356 if (opts_type & OPTS_TYPE_HOOK23)
14357 {
14358 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14359
14360 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14361 }
14362 }
14363
14364 for (uint i = 0; i <= 20; i++)
14365 {
14366 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14367 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14368 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14369
14370 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14371 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14372 }
14373
14374 for (uint i = 21; i <= 31; i++)
14375 {
14376 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14377 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14378 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14379
14380 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14381 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14382 }
14383
14384 if (attack_mode == ATTACK_MODE_BF)
14385 {
14386 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14387 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14388
14389 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14390 {
14391 hc_clSetKernelArg (data.ocl, device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14392
14393 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14394 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14395 }
14396 }
14397 else if (attack_mode == ATTACK_MODE_HYBRID1)
14398 {
14399 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14400 }
14401 else if (attack_mode == ATTACK_MODE_HYBRID2)
14402 {
14403 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14404 }
14405
14406 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14407 {
14408 // nothing to do
14409 }
14410 else
14411 {
14412 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14413 }
14414
14415 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14416 {
14417 // nothing to do
14418 }
14419 else
14420 {
14421 for (uint i = 0; i < 5; i++)
14422 {
14423 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14424 }
14425
14426 for (uint i = 5; i < 7; i++)
14427 {
14428 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14429 }
14430 }
14431
14432 /**
14433 * Store initial fanspeed if gpu_temp_retain is enabled
14434 */
14435
14436 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14437 int gpu_temp_retain_set = 0;
14438
14439 if (gpu_temp_disable == 0)
14440 {
14441 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14442 {
14443 hc_thread_mutex_lock (mux_adl);
14444
14445 if (data.hm_device[device_id].fan_supported == 1)
14446 {
14447 if (gpu_temp_retain_chgd == 0)
14448 {
14449 uint cur_temp = 0;
14450 uint default_temp = 0;
14451
14452 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);
14453
14454 if (ADL_rc == ADL_OK)
14455 {
14456 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14457
14458 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14459
14460 // special case with multi gpu setups: always use minimum retain
14461
14462 if (gpu_temp_retain_set == 0)
14463 {
14464 gpu_temp_retain = gpu_temp_retain_target;
14465 gpu_temp_retain_set = 1;
14466 }
14467 else
14468 {
14469 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14470 }
14471
14472 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14473 }
14474 }
14475
14476 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14477
14478 temp_retain_fanspeed_value[device_id] = fan_speed;
14479
14480 if (fan_speed == -1)
14481 {
14482 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14483
14484 temp_retain_fanspeed_value[device_id] = 0;
14485 }
14486 }
14487
14488 hc_thread_mutex_unlock (mux_adl);
14489 }
14490 }
14491
14492 /**
14493 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14494 */
14495
14496 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14497 {
14498 hc_thread_mutex_lock (mux_adl);
14499
14500 if (data.hm_device[device_id].od_version == 6)
14501 {
14502 int ADL_rc;
14503
14504 // check powertune capabilities first, if not available then skip device
14505
14506 int powertune_supported = 0;
14507
14508 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14509 {
14510 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14511
14512 return (-1);
14513 }
14514
14515 if (powertune_supported != 0)
14516 {
14517 // powercontrol settings
14518
14519 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14520
14521 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14522 {
14523 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14524 }
14525
14526 if (ADL_rc != ADL_OK)
14527 {
14528 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14529
14530 return (-1);
14531 }
14532
14533 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14534 {
14535 log_error ("ERROR: Failed to set new ADL PowerControl values");
14536
14537 return (-1);
14538 }
14539
14540 // clocks
14541
14542 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14543
14544 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14545
14546 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)
14547 {
14548 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14549
14550 return (-1);
14551 }
14552
14553 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14554
14555 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14556
14557 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14558 {
14559 log_error ("ERROR: Failed to get ADL device capabilities");
14560
14561 return (-1);
14562 }
14563
14564 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14565 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14566
14567 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14568 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14569
14570 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14571 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14572
14573 // warning if profile has too low max values
14574
14575 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14576 {
14577 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14578 }
14579
14580 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14581 {
14582 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14583 }
14584
14585 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14586
14587 performance_state->iNumberOfPerformanceLevels = 2;
14588
14589 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14590 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14591 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14592 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14593
14594 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)
14595 {
14596 log_info ("ERROR: Failed to set ADL performance state");
14597
14598 return (-1);
14599 }
14600
14601 local_free (performance_state);
14602 }
14603 }
14604
14605 hc_thread_mutex_unlock (mux_adl);
14606 }
14607 #endif // HAVE_HWMON && HAVE_ADL
14608 }
14609
14610 data.kernel_power_all = kernel_power_all;
14611
14612 if (data.quiet == 0) log_info ("");
14613
14614 /**
14615 * Inform user which algorithm is checked and at which workload setting
14616 */
14617
14618 if (benchmark == 1)
14619 {
14620 quiet = 0;
14621
14622 data.quiet = quiet;
14623
14624 char *hash_type = strhashtype (data.hash_mode); // not a bug
14625
14626 log_info ("Hashtype: %s", hash_type);
14627 log_info ("");
14628 }
14629
14630 /**
14631 * keep track of the progress
14632 */
14633
14634 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14635 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14636 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14637
14638 /**
14639 * open filehandles
14640 */
14641
14642 #if _WIN
14643 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14644 {
14645 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14646
14647 return (-1);
14648 }
14649
14650 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14651 {
14652 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14653
14654 return (-1);
14655 }
14656
14657 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14658 {
14659 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14660
14661 return (-1);
14662 }
14663 #endif
14664
14665 /**
14666 * dictionary pad
14667 */
14668
14669 segment_size *= (1024 * 1024);
14670
14671 data.segment_size = segment_size;
14672
14673 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14674
14675 wl_data->buf = (char *) mymalloc (segment_size);
14676 wl_data->avail = segment_size;
14677 wl_data->incr = segment_size;
14678 wl_data->cnt = 0;
14679 wl_data->pos = 0;
14680
14681 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14682
14683 data.wordlist_mode = wordlist_mode;
14684
14685 cs_t *css_buf = NULL;
14686 uint css_cnt = 0;
14687 uint dictcnt = 0;
14688 uint maskcnt = 1;
14689 char **masks = NULL;
14690 char **dictfiles = NULL;
14691
14692 uint mask_from_file = 0;
14693
14694 if (attack_mode == ATTACK_MODE_STRAIGHT)
14695 {
14696 if (wordlist_mode == WL_MODE_FILE)
14697 {
14698 int wls_left = myargc - (optind + 1);
14699
14700 for (int i = 0; i < wls_left; i++)
14701 {
14702 char *l0_filename = myargv[optind + 1 + i];
14703
14704 struct stat l0_stat;
14705
14706 if (stat (l0_filename, &l0_stat) == -1)
14707 {
14708 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14709
14710 return (-1);
14711 }
14712
14713 uint is_dir = S_ISDIR (l0_stat.st_mode);
14714
14715 if (is_dir == 0)
14716 {
14717 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14718
14719 dictcnt++;
14720
14721 dictfiles[dictcnt - 1] = l0_filename;
14722 }
14723 else
14724 {
14725 // do not allow --keyspace w/ a directory
14726
14727 if (keyspace == 1)
14728 {
14729 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14730
14731 return (-1);
14732 }
14733
14734 char **dictionary_files = NULL;
14735
14736 dictionary_files = scan_directory (l0_filename);
14737
14738 if (dictionary_files != NULL)
14739 {
14740 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14741
14742 for (int d = 0; dictionary_files[d] != NULL; d++)
14743 {
14744 char *l1_filename = dictionary_files[d];
14745
14746 struct stat l1_stat;
14747
14748 if (stat (l1_filename, &l1_stat) == -1)
14749 {
14750 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14751
14752 return (-1);
14753 }
14754
14755 if (S_ISREG (l1_stat.st_mode))
14756 {
14757 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14758
14759 dictcnt++;
14760
14761 dictfiles[dictcnt - 1] = strdup (l1_filename);
14762 }
14763 }
14764 }
14765
14766 local_free (dictionary_files);
14767 }
14768 }
14769
14770 if (dictcnt < 1)
14771 {
14772 log_error ("ERROR: No usable dictionary file found.");
14773
14774 return (-1);
14775 }
14776 }
14777 else if (wordlist_mode == WL_MODE_STDIN)
14778 {
14779 dictcnt = 1;
14780 }
14781 }
14782 else if (attack_mode == ATTACK_MODE_COMBI)
14783 {
14784 // display
14785
14786 char *dictfile1 = myargv[optind + 1 + 0];
14787 char *dictfile2 = myargv[optind + 1 + 1];
14788
14789 // find the bigger dictionary and use as base
14790
14791 FILE *fp1 = NULL;
14792 FILE *fp2 = NULL;
14793
14794 struct stat tmp_stat;
14795
14796 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14797 {
14798 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14799
14800 return (-1);
14801 }
14802
14803 if (stat (dictfile1, &tmp_stat) == -1)
14804 {
14805 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14806
14807 fclose (fp1);
14808
14809 return (-1);
14810 }
14811
14812 if (S_ISDIR (tmp_stat.st_mode))
14813 {
14814 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14815
14816 fclose (fp1);
14817
14818 return (-1);
14819 }
14820
14821 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14822 {
14823 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14824
14825 fclose (fp1);
14826
14827 return (-1);
14828 }
14829
14830 if (stat (dictfile2, &tmp_stat) == -1)
14831 {
14832 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14833
14834 fclose (fp1);
14835 fclose (fp2);
14836
14837 return (-1);
14838 }
14839
14840 if (S_ISDIR (tmp_stat.st_mode))
14841 {
14842 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14843
14844 fclose (fp1);
14845 fclose (fp2);
14846
14847 return (-1);
14848 }
14849
14850 data.combs_cnt = 1;
14851
14852 data.quiet = 1;
14853
14854 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14855
14856 data.quiet = quiet;
14857
14858 if (words1_cnt == 0)
14859 {
14860 log_error ("ERROR: %s: empty file", dictfile1);
14861
14862 fclose (fp1);
14863 fclose (fp2);
14864
14865 return (-1);
14866 }
14867
14868 data.combs_cnt = 1;
14869
14870 data.quiet = 1;
14871
14872 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14873
14874 data.quiet = quiet;
14875
14876 if (words2_cnt == 0)
14877 {
14878 log_error ("ERROR: %s: empty file", dictfile2);
14879
14880 fclose (fp1);
14881 fclose (fp2);
14882
14883 return (-1);
14884 }
14885
14886 fclose (fp1);
14887 fclose (fp2);
14888
14889 data.dictfile = dictfile1;
14890 data.dictfile2 = dictfile2;
14891
14892 if (words1_cnt >= words2_cnt)
14893 {
14894 data.combs_cnt = words2_cnt;
14895 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14896
14897 dictfiles = &data.dictfile;
14898
14899 dictcnt = 1;
14900 }
14901 else
14902 {
14903 data.combs_cnt = words1_cnt;
14904 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14905
14906 dictfiles = &data.dictfile2;
14907
14908 dictcnt = 1;
14909
14910 // we also have to switch wordlist related rules!
14911
14912 char *tmpc = data.rule_buf_l;
14913
14914 data.rule_buf_l = data.rule_buf_r;
14915 data.rule_buf_r = tmpc;
14916
14917 int tmpi = data.rule_len_l;
14918
14919 data.rule_len_l = data.rule_len_r;
14920 data.rule_len_r = tmpi;
14921 }
14922 }
14923 else if (attack_mode == ATTACK_MODE_BF)
14924 {
14925 char *mask = NULL;
14926
14927 maskcnt = 0;
14928
14929 if (benchmark == 0)
14930 {
14931 mask = myargv[optind + 1];
14932
14933 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14934
14935 if ((optind + 2) <= myargc)
14936 {
14937 struct stat file_stat;
14938
14939 if (stat (mask, &file_stat) == -1)
14940 {
14941 maskcnt = 1;
14942
14943 masks[maskcnt - 1] = mystrdup (mask);
14944 }
14945 else
14946 {
14947 int wls_left = myargc - (optind + 1);
14948
14949 uint masks_avail = INCR_MASKS;
14950
14951 for (int i = 0; i < wls_left; i++)
14952 {
14953 if (i != 0)
14954 {
14955 mask = myargv[optind + 1 + i];
14956
14957 if (stat (mask, &file_stat) == -1)
14958 {
14959 log_error ("ERROR: %s: %s", mask, strerror (errno));
14960
14961 return (-1);
14962 }
14963 }
14964
14965 uint is_file = S_ISREG (file_stat.st_mode);
14966
14967 if (is_file == 1)
14968 {
14969 FILE *mask_fp;
14970
14971 if ((mask_fp = fopen (mask, "r")) == NULL)
14972 {
14973 log_error ("ERROR: %s: %s", mask, strerror (errno));
14974
14975 return (-1);
14976 }
14977
14978 char line_buf[BUFSIZ] = { 0 };
14979
14980 while (!feof (mask_fp))
14981 {
14982 memset (line_buf, 0, BUFSIZ);
14983
14984 int line_len = fgetl (mask_fp, line_buf);
14985
14986 if (line_len == 0) continue;
14987
14988 if (line_buf[0] == '#') continue;
14989
14990 if (masks_avail == maskcnt)
14991 {
14992 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14993
14994 masks_avail += INCR_MASKS;
14995 }
14996
14997 masks[maskcnt] = mystrdup (line_buf);
14998
14999 maskcnt++;
15000 }
15001
15002 fclose (mask_fp);
15003 }
15004 else
15005 {
15006 log_error ("ERROR: %s: unsupported file-type", mask);
15007
15008 return (-1);
15009 }
15010 }
15011
15012 mask_from_file = 1;
15013 }
15014 }
15015 else
15016 {
15017 custom_charset_1 = (char *) "?l?d?u";
15018 custom_charset_2 = (char *) "?l?d";
15019 custom_charset_3 = (char *) "?l?d*!$@_";
15020
15021 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15022 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15023 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15024
15025 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15026
15027 wordlist_mode = WL_MODE_MASK;
15028
15029 data.wordlist_mode = wordlist_mode;
15030
15031 increment = 1;
15032
15033 maskcnt = 1;
15034 }
15035 }
15036 else
15037 {
15038 /**
15039 * generate full masks and charsets
15040 */
15041
15042 masks = (char **) mymalloc (sizeof (char *));
15043
15044 switch (hash_mode)
15045 {
15046 case 1731: pw_min = 5;
15047 pw_max = 5;
15048 mask = mystrdup ("?b?b?b?b?b");
15049 break;
15050 case 12500: pw_min = 5;
15051 pw_max = 5;
15052 mask = mystrdup ("?b?b?b?b?b");
15053 break;
15054 default: pw_min = 7;
15055 pw_max = 7;
15056 mask = mystrdup ("?b?b?b?b?b?b?b");
15057 break;
15058 }
15059
15060 maskcnt = 1;
15061
15062 masks[maskcnt - 1] = mystrdup (mask);
15063
15064 wordlist_mode = WL_MODE_MASK;
15065
15066 data.wordlist_mode = wordlist_mode;
15067
15068 increment = 1;
15069 }
15070
15071 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15072
15073 if (increment)
15074 {
15075 if (increment_min > pw_min) pw_min = increment_min;
15076
15077 if (increment_max < pw_max) pw_max = increment_max;
15078 }
15079 }
15080 else if (attack_mode == ATTACK_MODE_HYBRID1)
15081 {
15082 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15083
15084 // display
15085
15086 char *mask = myargv[myargc - 1];
15087
15088 maskcnt = 0;
15089
15090 masks = (char **) mymalloc (1 * sizeof (char *));
15091
15092 // mod
15093
15094 struct stat file_stat;
15095
15096 if (stat (mask, &file_stat) == -1)
15097 {
15098 maskcnt = 1;
15099
15100 masks[maskcnt - 1] = mystrdup (mask);
15101 }
15102 else
15103 {
15104 uint is_file = S_ISREG (file_stat.st_mode);
15105
15106 if (is_file == 1)
15107 {
15108 FILE *mask_fp;
15109
15110 if ((mask_fp = fopen (mask, "r")) == NULL)
15111 {
15112 log_error ("ERROR: %s: %s", mask, strerror (errno));
15113
15114 return (-1);
15115 }
15116
15117 char line_buf[BUFSIZ] = { 0 };
15118
15119 uint masks_avail = 1;
15120
15121 while (!feof (mask_fp))
15122 {
15123 memset (line_buf, 0, BUFSIZ);
15124
15125 int line_len = fgetl (mask_fp, line_buf);
15126
15127 if (line_len == 0) continue;
15128
15129 if (line_buf[0] == '#') continue;
15130
15131 if (masks_avail == maskcnt)
15132 {
15133 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15134
15135 masks_avail += INCR_MASKS;
15136 }
15137
15138 masks[maskcnt] = mystrdup (line_buf);
15139
15140 maskcnt++;
15141 }
15142
15143 fclose (mask_fp);
15144
15145 mask_from_file = 1;
15146 }
15147 else
15148 {
15149 maskcnt = 1;
15150
15151 masks[maskcnt - 1] = mystrdup (mask);
15152 }
15153 }
15154
15155 // base
15156
15157 int wls_left = myargc - (optind + 2);
15158
15159 for (int i = 0; i < wls_left; i++)
15160 {
15161 char *filename = myargv[optind + 1 + i];
15162
15163 struct stat file_stat;
15164
15165 if (stat (filename, &file_stat) == -1)
15166 {
15167 log_error ("ERROR: %s: %s", filename, strerror (errno));
15168
15169 return (-1);
15170 }
15171
15172 uint is_dir = S_ISDIR (file_stat.st_mode);
15173
15174 if (is_dir == 0)
15175 {
15176 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15177
15178 dictcnt++;
15179
15180 dictfiles[dictcnt - 1] = filename;
15181 }
15182 else
15183 {
15184 // do not allow --keyspace w/ a directory
15185
15186 if (keyspace == 1)
15187 {
15188 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15189
15190 return (-1);
15191 }
15192
15193 char **dictionary_files = NULL;
15194
15195 dictionary_files = scan_directory (filename);
15196
15197 if (dictionary_files != NULL)
15198 {
15199 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15200
15201 for (int d = 0; dictionary_files[d] != NULL; d++)
15202 {
15203 char *l1_filename = dictionary_files[d];
15204
15205 struct stat l1_stat;
15206
15207 if (stat (l1_filename, &l1_stat) == -1)
15208 {
15209 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15210
15211 return (-1);
15212 }
15213
15214 if (S_ISREG (l1_stat.st_mode))
15215 {
15216 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15217
15218 dictcnt++;
15219
15220 dictfiles[dictcnt - 1] = strdup (l1_filename);
15221 }
15222 }
15223 }
15224
15225 local_free (dictionary_files);
15226 }
15227 }
15228
15229 if (dictcnt < 1)
15230 {
15231 log_error ("ERROR: No usable dictionary file found.");
15232
15233 return (-1);
15234 }
15235
15236 if (increment)
15237 {
15238 maskcnt = 0;
15239
15240 uint mask_min = increment_min; // we can't reject smaller masks here
15241 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15242
15243 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15244 {
15245 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15246
15247 if (cur_mask == NULL) break;
15248
15249 masks[maskcnt] = cur_mask;
15250
15251 maskcnt++;
15252
15253 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15254 }
15255 }
15256 }
15257 else if (attack_mode == ATTACK_MODE_HYBRID2)
15258 {
15259 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15260
15261 // display
15262
15263 char *mask = myargv[optind + 1 + 0];
15264
15265 maskcnt = 0;
15266
15267 masks = (char **) mymalloc (1 * sizeof (char *));
15268
15269 // mod
15270
15271 struct stat file_stat;
15272
15273 if (stat (mask, &file_stat) == -1)
15274 {
15275 maskcnt = 1;
15276
15277 masks[maskcnt - 1] = mystrdup (mask);
15278 }
15279 else
15280 {
15281 uint is_file = S_ISREG (file_stat.st_mode);
15282
15283 if (is_file == 1)
15284 {
15285 FILE *mask_fp;
15286
15287 if ((mask_fp = fopen (mask, "r")) == NULL)
15288 {
15289 log_error ("ERROR: %s: %s", mask, strerror (errno));
15290
15291 return (-1);
15292 }
15293
15294 char line_buf[BUFSIZ] = { 0 };
15295
15296 uint masks_avail = 1;
15297
15298 while (!feof (mask_fp))
15299 {
15300 memset (line_buf, 0, BUFSIZ);
15301
15302 int line_len = fgetl (mask_fp, line_buf);
15303
15304 if (line_len == 0) continue;
15305
15306 if (line_buf[0] == '#') continue;
15307
15308 if (masks_avail == maskcnt)
15309 {
15310 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15311
15312 masks_avail += INCR_MASKS;
15313 }
15314
15315 masks[maskcnt] = mystrdup (line_buf);
15316
15317 maskcnt++;
15318 }
15319
15320 fclose (mask_fp);
15321
15322 mask_from_file = 1;
15323 }
15324 else
15325 {
15326 maskcnt = 1;
15327
15328 masks[maskcnt - 1] = mystrdup (mask);
15329 }
15330 }
15331
15332 // base
15333
15334 int wls_left = myargc - (optind + 2);
15335
15336 for (int i = 0; i < wls_left; i++)
15337 {
15338 char *filename = myargv[optind + 2 + i];
15339
15340 struct stat file_stat;
15341
15342 if (stat (filename, &file_stat) == -1)
15343 {
15344 log_error ("ERROR: %s: %s", filename, strerror (errno));
15345
15346 return (-1);
15347 }
15348
15349 uint is_dir = S_ISDIR (file_stat.st_mode);
15350
15351 if (is_dir == 0)
15352 {
15353 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15354
15355 dictcnt++;
15356
15357 dictfiles[dictcnt - 1] = filename;
15358 }
15359 else
15360 {
15361 // do not allow --keyspace w/ a directory
15362
15363 if (keyspace == 1)
15364 {
15365 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15366
15367 return (-1);
15368 }
15369
15370 char **dictionary_files = NULL;
15371
15372 dictionary_files = scan_directory (filename);
15373
15374 if (dictionary_files != NULL)
15375 {
15376 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15377
15378 for (int d = 0; dictionary_files[d] != NULL; d++)
15379 {
15380 char *l1_filename = dictionary_files[d];
15381
15382 struct stat l1_stat;
15383
15384 if (stat (l1_filename, &l1_stat) == -1)
15385 {
15386 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15387
15388 return (-1);
15389 }
15390
15391 if (S_ISREG (l1_stat.st_mode))
15392 {
15393 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15394
15395 dictcnt++;
15396
15397 dictfiles[dictcnt - 1] = strdup (l1_filename);
15398 }
15399 }
15400 }
15401
15402 local_free (dictionary_files);
15403 }
15404 }
15405
15406 if (dictcnt < 1)
15407 {
15408 log_error ("ERROR: No usable dictionary file found.");
15409
15410 return (-1);
15411 }
15412
15413 if (increment)
15414 {
15415 maskcnt = 0;
15416
15417 uint mask_min = increment_min; // we can't reject smaller masks here
15418 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15419
15420 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15421 {
15422 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15423
15424 if (cur_mask == NULL) break;
15425
15426 masks[maskcnt] = cur_mask;
15427
15428 maskcnt++;
15429
15430 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15431 }
15432 }
15433 }
15434
15435 data.pw_min = pw_min;
15436 data.pw_max = pw_max;
15437
15438 /**
15439 * weak hash check
15440 */
15441
15442 if (weak_hash_threshold >= salts_cnt)
15443 {
15444 hc_device_param_t *device_param = NULL;
15445
15446 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15447 {
15448 device_param = &data.devices_param[device_id];
15449
15450 if (device_param->skipped) continue;
15451
15452 break;
15453 }
15454
15455 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15456
15457 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15458 {
15459 weak_hash_check (device_param, salt_pos);
15460 }
15461 }
15462
15463 // Display hack, guarantee that there is at least one \r before real start
15464
15465 if (data.quiet == 0) log_info_nn ("");
15466
15467 /**
15468 * status and monitor threads
15469 */
15470
15471 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15472
15473 hc_thread_t i_thread = 0;
15474
15475 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15476 {
15477 hc_thread_create (i_thread, thread_keypress, &benchmark);
15478 }
15479
15480 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15481
15482 uint ni_threads_cnt = 0;
15483
15484 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15485
15486 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15487
15488 ni_threads_cnt++;
15489
15490 /**
15491 * Outfile remove
15492 */
15493
15494 if (keyspace == 0)
15495 {
15496 if (outfile_check_timer != 0)
15497 {
15498 if (data.outfile_check_directory != NULL)
15499 {
15500 if ((hash_mode != 5200) &&
15501 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15502 (hash_mode != 9000))
15503 {
15504 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15505
15506 ni_threads_cnt++;
15507 }
15508 else
15509 {
15510 outfile_check_timer = 0;
15511 }
15512 }
15513 else
15514 {
15515 outfile_check_timer = 0;
15516 }
15517 }
15518 }
15519
15520 /**
15521 * Inform the user if we got some hashes remove because of the pot file remove feature
15522 */
15523
15524 if (data.quiet == 0)
15525 {
15526 if (potfile_remove_cracks > 0)
15527 {
15528 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15529 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15530 }
15531 }
15532
15533 data.outfile_check_timer = outfile_check_timer;
15534
15535 /**
15536 * main loop
15537 */
15538
15539 char **induction_dictionaries = NULL;
15540
15541 int induction_dictionaries_cnt = 0;
15542
15543 hcstat_table_t *root_table_buf = NULL;
15544 hcstat_table_t *markov_table_buf = NULL;
15545
15546 uint initial_restore_done = 0;
15547
15548 data.maskcnt = maskcnt;
15549
15550 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15551 {
15552 if (data.devices_status == STATUS_CRACKED) break;
15553
15554 data.devices_status = STATUS_INIT;
15555
15556 if (maskpos > rd->maskpos)
15557 {
15558 rd->dictpos = 0;
15559 }
15560
15561 rd->maskpos = maskpos;
15562 data.maskpos = maskpos;
15563
15564 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15565 {
15566 char *mask = masks[maskpos];
15567
15568 if (mask_from_file == 1)
15569 {
15570 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15571
15572 char *str_ptr;
15573 uint str_pos;
15574
15575 uint mask_offset = 0;
15576
15577 uint separator_cnt;
15578
15579 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15580 {
15581 str_ptr = strstr (mask + mask_offset, ",");
15582
15583 if (str_ptr == NULL) break;
15584
15585 str_pos = str_ptr - mask;
15586
15587 // escaped separator, i.e. "\,"
15588
15589 if (str_pos > 0)
15590 {
15591 if (mask[str_pos - 1] == '\\')
15592 {
15593 separator_cnt --;
15594
15595 mask_offset = str_pos + 1;
15596
15597 continue;
15598 }
15599 }
15600
15601 // reset the offset
15602
15603 mask_offset = 0;
15604
15605 mask[str_pos] = '\0';
15606
15607 switch (separator_cnt)
15608 {
15609 case 0:
15610 mp_reset_usr (mp_usr, 0);
15611
15612 custom_charset_1 = mask;
15613 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15614 break;
15615
15616 case 1:
15617 mp_reset_usr (mp_usr, 1);
15618
15619 custom_charset_2 = mask;
15620 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15621 break;
15622
15623 case 2:
15624 mp_reset_usr (mp_usr, 2);
15625
15626 custom_charset_3 = mask;
15627 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15628 break;
15629
15630 case 3:
15631 mp_reset_usr (mp_usr, 3);
15632
15633 custom_charset_4 = mask;
15634 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15635 break;
15636 }
15637
15638 mask = mask + str_pos + 1;
15639 }
15640 }
15641
15642 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15643 {
15644 if (maskpos > 0)
15645 {
15646 local_free (css_buf);
15647 local_free (data.root_css_buf);
15648 local_free (data.markov_css_buf);
15649
15650 local_free (masks[maskpos - 1]);
15651 }
15652
15653 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15654
15655 data.mask = mask;
15656 data.css_cnt = css_cnt;
15657 data.css_buf = css_buf;
15658
15659 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15660
15661 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15662
15663 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15664 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15665
15666 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15667
15668 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15669
15670 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15671 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15672
15673 data.root_css_buf = root_css_buf;
15674 data.markov_css_buf = markov_css_buf;
15675
15676 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15677
15678 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15679
15680 local_free (root_table_buf);
15681 local_free (markov_table_buf);
15682
15683 // args
15684
15685 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15686 {
15687 hc_device_param_t *device_param = &data.devices_param[device_id];
15688
15689 if (device_param->skipped) continue;
15690
15691 device_param->kernel_params_mp[0] = &device_param->d_combs;
15692 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15693 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15694
15695 device_param->kernel_params_mp_buf64[3] = 0;
15696 device_param->kernel_params_mp_buf32[4] = css_cnt;
15697 device_param->kernel_params_mp_buf32[5] = 0;
15698 device_param->kernel_params_mp_buf32[6] = 0;
15699 device_param->kernel_params_mp_buf32[7] = 0;
15700
15701 if (attack_mode == ATTACK_MODE_HYBRID1)
15702 {
15703 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15704 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15705 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15706 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15707 }
15708 else if (attack_mode == ATTACK_MODE_HYBRID2)
15709 {
15710 device_param->kernel_params_mp_buf32[5] = 0;
15711 device_param->kernel_params_mp_buf32[6] = 0;
15712 device_param->kernel_params_mp_buf32[7] = 0;
15713 }
15714
15715 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]);
15716 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]);
15717 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]);
15718
15719 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);
15720 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);
15721 }
15722 }
15723 else if (attack_mode == ATTACK_MODE_BF)
15724 {
15725 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15726
15727 if (increment)
15728 {
15729 for (uint i = 0; i < dictcnt; i++)
15730 {
15731 local_free (dictfiles[i]);
15732 }
15733
15734 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15735 {
15736 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15737
15738 if (l1_filename == NULL) break;
15739
15740 dictcnt++;
15741
15742 dictfiles[dictcnt - 1] = l1_filename;
15743 }
15744 }
15745 else
15746 {
15747 dictcnt++;
15748
15749 dictfiles[dictcnt - 1] = mask;
15750 }
15751
15752 if (dictcnt == 0)
15753 {
15754 log_error ("ERROR: Mask is too small");
15755
15756 return (-1);
15757 }
15758 }
15759 }
15760
15761 free (induction_dictionaries);
15762
15763 // induction_dictionaries_cnt = 0; // implied
15764
15765 if (attack_mode != ATTACK_MODE_BF)
15766 {
15767 if (keyspace == 0)
15768 {
15769 induction_dictionaries = scan_directory (induction_directory);
15770
15771 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15772 }
15773 }
15774
15775 if (induction_dictionaries_cnt)
15776 {
15777 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15778 }
15779
15780 /**
15781 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15782 */
15783 if (keyspace == 1)
15784 {
15785 if ((maskcnt > 1) || (dictcnt > 1))
15786 {
15787 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15788
15789 return (-1);
15790 }
15791 }
15792
15793 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15794 {
15795 char *subid = logfile_generate_subid ();
15796
15797 data.subid = subid;
15798
15799 logfile_sub_msg ("START");
15800
15801 data.devices_status = STATUS_INIT;
15802
15803 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15804 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15805 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15806
15807 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15808
15809 data.cpt_pos = 0;
15810
15811 data.cpt_start = time (NULL);
15812
15813 data.cpt_total = 0;
15814
15815 if (data.restore == 0)
15816 {
15817 rd->words_cur = skip;
15818
15819 skip = 0;
15820
15821 data.skip = 0;
15822 }
15823
15824 data.ms_paused = 0;
15825
15826 data.words_cur = rd->words_cur;
15827
15828 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15829 {
15830 hc_device_param_t *device_param = &data.devices_param[device_id];
15831
15832 if (device_param->skipped) continue;
15833
15834 device_param->speed_pos = 0;
15835
15836 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15837 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15838 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15839
15840 device_param->exec_pos = 0;
15841
15842 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
15843
15844 device_param->kernel_power = device_param->kernel_power_user;
15845
15846 device_param->outerloop_pos = 0;
15847 device_param->outerloop_left = 0;
15848 device_param->innerloop_pos = 0;
15849 device_param->innerloop_left = 0;
15850
15851 // some more resets:
15852
15853 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
15854
15855 device_param->pws_cnt = 0;
15856
15857 device_param->words_off = 0;
15858 device_param->words_done = 0;
15859 }
15860
15861 data.kernel_power_div = 0;
15862
15863 // figure out some workload
15864
15865 if (attack_mode == ATTACK_MODE_STRAIGHT)
15866 {
15867 if (data.wordlist_mode == WL_MODE_FILE)
15868 {
15869 char *dictfile = NULL;
15870
15871 if (induction_dictionaries_cnt)
15872 {
15873 dictfile = induction_dictionaries[0];
15874 }
15875 else
15876 {
15877 dictfile = dictfiles[dictpos];
15878 }
15879
15880 data.dictfile = dictfile;
15881
15882 logfile_sub_string (dictfile);
15883
15884 for (uint i = 0; i < rp_files_cnt; i++)
15885 {
15886 logfile_sub_var_string ("rulefile", rp_files[i]);
15887 }
15888
15889 FILE *fd2 = fopen (dictfile, "rb");
15890
15891 if (fd2 == NULL)
15892 {
15893 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15894
15895 return (-1);
15896 }
15897
15898 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15899
15900 fclose (fd2);
15901
15902 if (data.words_cnt == 0)
15903 {
15904 if (data.devices_status == STATUS_CRACKED) break;
15905 if (data.devices_status == STATUS_ABORTED) break;
15906
15907 dictpos++;
15908
15909 continue;
15910 }
15911 }
15912 }
15913 else if (attack_mode == ATTACK_MODE_COMBI)
15914 {
15915 char *dictfile = data.dictfile;
15916 char *dictfile2 = data.dictfile2;
15917
15918 logfile_sub_string (dictfile);
15919 logfile_sub_string (dictfile2);
15920
15921 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15922 {
15923 FILE *fd2 = fopen (dictfile, "rb");
15924
15925 if (fd2 == NULL)
15926 {
15927 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15928
15929 return (-1);
15930 }
15931
15932 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15933
15934 fclose (fd2);
15935 }
15936 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15937 {
15938 FILE *fd2 = fopen (dictfile2, "rb");
15939
15940 if (fd2 == NULL)
15941 {
15942 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15943
15944 return (-1);
15945 }
15946
15947 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15948
15949 fclose (fd2);
15950 }
15951
15952 if (data.words_cnt == 0)
15953 {
15954 if (data.devices_status == STATUS_CRACKED) break;
15955 if (data.devices_status == STATUS_ABORTED) break;
15956
15957 dictpos++;
15958
15959 continue;
15960 }
15961 }
15962 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15963 {
15964 char *dictfile = NULL;
15965
15966 if (induction_dictionaries_cnt)
15967 {
15968 dictfile = induction_dictionaries[0];
15969 }
15970 else
15971 {
15972 dictfile = dictfiles[dictpos];
15973 }
15974
15975 data.dictfile = dictfile;
15976
15977 char *mask = data.mask;
15978
15979 logfile_sub_string (dictfile);
15980 logfile_sub_string (mask);
15981
15982 FILE *fd2 = fopen (dictfile, "rb");
15983
15984 if (fd2 == NULL)
15985 {
15986 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15987
15988 return (-1);
15989 }
15990
15991 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15992
15993 fclose (fd2);
15994
15995 if (data.words_cnt == 0)
15996 {
15997 if (data.devices_status == STATUS_CRACKED) break;
15998 if (data.devices_status == STATUS_ABORTED) break;
15999
16000 dictpos++;
16001
16002 continue;
16003 }
16004 }
16005 else if (attack_mode == ATTACK_MODE_BF)
16006 {
16007 local_free (css_buf);
16008 local_free (data.root_css_buf);
16009 local_free (data.markov_css_buf);
16010
16011 char *mask = dictfiles[dictpos];
16012
16013 logfile_sub_string (mask);
16014
16015 // base
16016
16017 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16018
16019 if (opts_type & OPTS_TYPE_PT_UNICODE)
16020 {
16021 uint css_cnt_unicode = css_cnt * 2;
16022
16023 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16024
16025 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16026 {
16027 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16028
16029 css_buf_unicode[j + 1].cs_buf[0] = 0;
16030 css_buf_unicode[j + 1].cs_len = 1;
16031 }
16032
16033 free (css_buf);
16034
16035 css_buf = css_buf_unicode;
16036 css_cnt = css_cnt_unicode;
16037 }
16038
16039 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16040
16041 uint mask_min = pw_min;
16042 uint mask_max = pw_max;
16043
16044 if (opts_type & OPTS_TYPE_PT_UNICODE)
16045 {
16046 mask_min *= 2;
16047 mask_max *= 2;
16048 }
16049
16050 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16051 {
16052 if (css_cnt < mask_min)
16053 {
16054 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16055 }
16056
16057 if (css_cnt > mask_max)
16058 {
16059 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16060 }
16061
16062 // skip to next mask
16063
16064 dictpos++;
16065
16066 rd->dictpos = dictpos;
16067
16068 logfile_sub_msg ("STOP");
16069
16070 continue;
16071 }
16072
16073 uint save_css_cnt = css_cnt;
16074
16075 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16076 {
16077 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16078 {
16079 uint salt_len = (uint) data.salts_buf[0].salt_len;
16080 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16081
16082 uint css_cnt_salt = css_cnt + salt_len;
16083
16084 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16085
16086 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16087
16088 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16089 {
16090 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16091 css_buf_salt[j].cs_len = 1;
16092 }
16093
16094 free (css_buf);
16095
16096 css_buf = css_buf_salt;
16097 css_cnt = css_cnt_salt;
16098 }
16099 }
16100
16101 data.mask = mask;
16102 data.css_cnt = css_cnt;
16103 data.css_buf = css_buf;
16104
16105 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16106
16107 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16108
16109 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16110
16111 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16112 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16113
16114 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16115
16116 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16117
16118 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16119 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16120
16121 data.root_css_buf = root_css_buf;
16122 data.markov_css_buf = markov_css_buf;
16123
16124 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16125
16126 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16127
16128 local_free (root_table_buf);
16129 local_free (markov_table_buf);
16130
16131 // copy + args
16132
16133 uint css_cnt_l = css_cnt;
16134 uint css_cnt_r;
16135
16136 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16137 {
16138 if (save_css_cnt < 6)
16139 {
16140 css_cnt_r = 1;
16141 }
16142 else if (save_css_cnt == 6)
16143 {
16144 css_cnt_r = 2;
16145 }
16146 else
16147 {
16148 if (opts_type & OPTS_TYPE_PT_UNICODE)
16149 {
16150 if (save_css_cnt == 8 || save_css_cnt == 10)
16151 {
16152 css_cnt_r = 2;
16153 }
16154 else
16155 {
16156 css_cnt_r = 4;
16157 }
16158 }
16159 else
16160 {
16161 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16162 {
16163 css_cnt_r = 3;
16164 }
16165 else
16166 {
16167 css_cnt_r = 4;
16168 }
16169 }
16170 }
16171 }
16172 else
16173 {
16174 css_cnt_r = 1;
16175
16176 /* unfinished code?
16177 int sum = css_buf[css_cnt_r - 1].cs_len;
16178
16179 for (uint i = 1; i < 4 && i < css_cnt; i++)
16180 {
16181 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16182
16183 css_cnt_r++;
16184
16185 sum *= css_buf[css_cnt_r - 1].cs_len;
16186 }
16187 */
16188 }
16189
16190 css_cnt_l -= css_cnt_r;
16191
16192 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16193
16194 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16195 {
16196 hc_device_param_t *device_param = &data.devices_param[device_id];
16197
16198 if (device_param->skipped) continue;
16199
16200 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16201 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16202 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16203
16204 device_param->kernel_params_mp_l_buf64[3] = 0;
16205 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16206 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16207 device_param->kernel_params_mp_l_buf32[6] = 0;
16208 device_param->kernel_params_mp_l_buf32[7] = 0;
16209 device_param->kernel_params_mp_l_buf32[8] = 0;
16210
16211 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16212 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16213 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16214 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16215
16216 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16217 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16218 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16219
16220 device_param->kernel_params_mp_r_buf64[3] = 0;
16221 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16222 device_param->kernel_params_mp_r_buf32[5] = 0;
16223 device_param->kernel_params_mp_r_buf32[6] = 0;
16224 device_param->kernel_params_mp_r_buf32[7] = 0;
16225
16226 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]);
16227 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]);
16228 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]);
16229
16230 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]);
16231 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]);
16232 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]);
16233
16234 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);
16235 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);
16236 }
16237 }
16238
16239 u64 words_base = data.words_cnt;
16240
16241 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16242 {
16243 if (data.kernel_rules_cnt)
16244 {
16245 words_base /= data.kernel_rules_cnt;
16246 }
16247 }
16248 else if (data.attack_kern == ATTACK_KERN_COMBI)
16249 {
16250 if (data.combs_cnt)
16251 {
16252 words_base /= data.combs_cnt;
16253 }
16254 }
16255 else if (data.attack_kern == ATTACK_KERN_BF)
16256 {
16257 if (data.bfs_cnt)
16258 {
16259 words_base /= data.bfs_cnt;
16260 }
16261 }
16262
16263 data.words_base = words_base;
16264
16265 if (keyspace == 1)
16266 {
16267 log_info ("%llu", (unsigned long long int) words_base);
16268
16269 return (0);
16270 }
16271
16272 if (data.words_cur > data.words_base)
16273 {
16274 log_error ("ERROR: restore value greater keyspace");
16275
16276 return (-1);
16277 }
16278
16279 if (data.words_cur)
16280 {
16281 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16282 {
16283 for (uint i = 0; i < data.salts_cnt; i++)
16284 {
16285 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16286 }
16287 }
16288 else if (data.attack_kern == ATTACK_KERN_COMBI)
16289 {
16290 for (uint i = 0; i < data.salts_cnt; i++)
16291 {
16292 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16293 }
16294 }
16295 else if (data.attack_kern == ATTACK_KERN_BF)
16296 {
16297 for (uint i = 0; i < data.salts_cnt; i++)
16298 {
16299 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16300 }
16301 }
16302 }
16303
16304 /*
16305 * Inform user about possible slow speeds
16306 */
16307
16308 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16309 {
16310 if (data.words_base < kernel_power_all)
16311 {
16312 if (quiet == 0)
16313 {
16314 log_info ("");
16315 log_info ("ATTENTION!");
16316 log_info (" The wordlist or mask you are using is too small.");
16317 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16318 log_info (" The cracking speed will drop.");
16319 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16320 log_info ("");
16321 }
16322 }
16323 }
16324
16325 /*
16326 * Update loopback file
16327 */
16328
16329 if (loopback == 1)
16330 {
16331 time_t now;
16332
16333 time (&now);
16334
16335 uint random_num = get_random_num (0, 9999);
16336
16337 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16338
16339 data.loopback_file = loopback_file;
16340 }
16341
16342 /*
16343 * Update dictionary statistic
16344 */
16345
16346 if (keyspace == 0)
16347 {
16348 dictstat_fp = fopen (dictstat, "wb");
16349
16350 if (dictstat_fp)
16351 {
16352 lock_file (dictstat_fp);
16353
16354 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16355
16356 fclose (dictstat_fp);
16357 }
16358 }
16359
16360 data.devices_status = STATUS_RUNNING;
16361
16362 if (initial_restore_done == 0)
16363 {
16364 if (data.restore_disable == 0) cycle_restore ();
16365
16366 initial_restore_done = 1;
16367 }
16368
16369 hc_timer_set (&data.timer_running);
16370
16371 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16372 {
16373 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16374 {
16375 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16376 if (quiet == 0) fflush (stdout);
16377 }
16378 }
16379 else if (wordlist_mode == WL_MODE_STDIN)
16380 {
16381 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16382 if (data.quiet == 0) log_info ("");
16383 }
16384
16385 time_t runtime_start;
16386
16387 time (&runtime_start);
16388
16389 data.runtime_start = runtime_start;
16390
16391 /**
16392 * create cracker threads
16393 */
16394
16395 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16396
16397 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16398 {
16399 hc_device_param_t *device_param = &devices_param[device_id];
16400
16401 if (wordlist_mode == WL_MODE_STDIN)
16402 {
16403 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16404 }
16405 else
16406 {
16407 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16408 }
16409 }
16410
16411 // wait for crack threads to exit
16412
16413 hc_thread_wait (data.devices_cnt, c_threads);
16414
16415 local_free (c_threads);
16416
16417 data.restore = 0;
16418
16419 // finalize task
16420
16421 logfile_sub_var_uint ("status-after-work", data.devices_status);
16422
16423 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16424
16425 if (data.devices_status == STATUS_CRACKED) break;
16426 if (data.devices_status == STATUS_ABORTED) break;
16427
16428 if (data.devices_status == STATUS_BYPASS)
16429 {
16430 data.devices_status = STATUS_RUNNING;
16431 }
16432
16433 if (induction_dictionaries_cnt)
16434 {
16435 unlink (induction_dictionaries[0]);
16436 }
16437
16438 free (induction_dictionaries);
16439
16440 if (attack_mode != ATTACK_MODE_BF)
16441 {
16442 induction_dictionaries = scan_directory (induction_directory);
16443
16444 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16445 }
16446
16447 if (benchmark == 0)
16448 {
16449 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16450 {
16451 if (quiet == 0) clear_prompt ();
16452
16453 if (quiet == 0) log_info ("");
16454
16455 if (status == 1)
16456 {
16457 status_display ();
16458 }
16459 else
16460 {
16461 if (quiet == 0) status_display ();
16462 }
16463
16464 if (quiet == 0) log_info ("");
16465 }
16466 }
16467
16468 if (attack_mode == ATTACK_MODE_BF)
16469 {
16470 dictpos++;
16471
16472 rd->dictpos = dictpos;
16473 }
16474 else
16475 {
16476 if (induction_dictionaries_cnt)
16477 {
16478 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16479 }
16480 else
16481 {
16482 dictpos++;
16483
16484 rd->dictpos = dictpos;
16485 }
16486 }
16487
16488 time_t runtime_stop;
16489
16490 time (&runtime_stop);
16491
16492 data.runtime_stop = runtime_stop;
16493
16494 logfile_sub_uint (runtime_start);
16495 logfile_sub_uint (runtime_stop);
16496
16497 logfile_sub_msg ("STOP");
16498
16499 global_free (subid);
16500 }
16501
16502 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16503
16504 if (data.devices_status == STATUS_CRACKED) break;
16505 if (data.devices_status == STATUS_ABORTED) break;
16506 if (data.devices_status == STATUS_QUIT) break;
16507
16508 if (data.devices_status == STATUS_BYPASS)
16509 {
16510 data.devices_status = STATUS_RUNNING;
16511 }
16512 }
16513
16514 // 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
16515
16516 if (attack_mode == ATTACK_MODE_STRAIGHT)
16517 {
16518 if (data.wordlist_mode == WL_MODE_FILE)
16519 {
16520 if (data.dictfile == NULL)
16521 {
16522 if (dictfiles != NULL)
16523 {
16524 data.dictfile = dictfiles[0];
16525
16526 hc_timer_set (&data.timer_running);
16527 }
16528 }
16529 }
16530 }
16531 // NOTE: combi is okay because it is already set beforehand
16532 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16533 {
16534 if (data.dictfile == NULL)
16535 {
16536 if (dictfiles != NULL)
16537 {
16538 hc_timer_set (&data.timer_running);
16539
16540 data.dictfile = dictfiles[0];
16541 }
16542 }
16543 }
16544 else if (attack_mode == ATTACK_MODE_BF)
16545 {
16546 if (data.mask == NULL)
16547 {
16548 hc_timer_set (&data.timer_running);
16549
16550 data.mask = masks[0];
16551 }
16552 }
16553
16554 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16555 {
16556 data.devices_status = STATUS_EXHAUSTED;
16557 }
16558
16559 // if cracked / aborted remove last induction dictionary
16560
16561 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16562 {
16563 struct stat induct_stat;
16564
16565 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16566 {
16567 unlink (induction_dictionaries[file_pos]);
16568 }
16569 }
16570
16571 // wait for non-interactive threads
16572
16573 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16574 {
16575 hc_thread_wait (1, &ni_threads[thread_idx]);
16576 }
16577
16578 local_free (ni_threads);
16579
16580 // wait for interactive threads
16581
16582 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16583 {
16584 hc_thread_wait (1, &i_thread);
16585 }
16586
16587 // we dont need restore file anymore
16588 if (data.restore_disable == 0)
16589 {
16590 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16591 {
16592 unlink (eff_restore_file);
16593 unlink (new_restore_file);
16594 }
16595 else
16596 {
16597 cycle_restore ();
16598 }
16599 }
16600
16601 // finally save left hashes
16602
16603 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16604 {
16605 save_hash ();
16606 }
16607
16608 /**
16609 * Clean up
16610 */
16611
16612 if (benchmark == 1)
16613 {
16614 status_benchmark ();
16615
16616 log_info ("");
16617 }
16618 else
16619 {
16620 if (quiet == 0) clear_prompt ();
16621
16622 if (quiet == 0) log_info ("");
16623
16624 if (status == 1)
16625 {
16626 status_display ();
16627 }
16628 else
16629 {
16630 if (quiet == 0) status_display ();
16631 }
16632
16633 if (quiet == 0) log_info ("");
16634 }
16635
16636 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16637 {
16638 hc_device_param_t *device_param = &data.devices_param[device_id];
16639
16640 if (device_param->skipped) continue;
16641
16642 local_free (device_param->result);
16643
16644 local_free (device_param->combs_buf);
16645
16646 local_free (device_param->hooks_buf);
16647
16648 local_free (device_param->device_name);
16649
16650 local_free (device_param->device_name_chksum);
16651
16652 local_free (device_param->device_version);
16653
16654 local_free (device_param->driver_version);
16655
16656 if (device_param->pws_buf) myfree (device_param->pws_buf);
16657 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16658 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16659 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16660 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16661 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16662 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16663 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16664 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16665 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16666 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16667 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16668 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16669 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16670 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16671 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16672 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16673 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16674 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16675 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16676 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16677 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16678 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16679 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16680 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16681 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16682 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16683 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16684 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16685
16686 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16687 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16688 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16689 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16690 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16691 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16692 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16693 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16694 if (device_param->kernel_tb) hc_clReleaseKernel (data.ocl, device_param->kernel_tb);
16695 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16696 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16697
16698 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16699 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16700 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16701
16702 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16703 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16704 }
16705
16706 // reset default fan speed
16707
16708 #ifdef HAVE_HWMON
16709 if (gpu_temp_disable == 0)
16710 {
16711 #ifdef HAVE_ADL
16712 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16713 {
16714 hc_thread_mutex_lock (mux_adl);
16715
16716 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16717 {
16718 hc_device_param_t *device_param = &data.devices_param[device_id];
16719
16720 if (device_param->skipped) continue;
16721
16722 if (data.hm_device[device_id].fan_supported == 1)
16723 {
16724 int fanspeed = temp_retain_fanspeed_value[device_id];
16725
16726 if (fanspeed == -1) continue;
16727
16728 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16729
16730 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16731 }
16732 }
16733
16734 hc_thread_mutex_unlock (mux_adl);
16735 }
16736 #endif // HAVE_ADL
16737 }
16738
16739 #ifdef HAVE_ADL
16740 // reset power tuning
16741
16742 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16743 {
16744 hc_thread_mutex_lock (mux_adl);
16745
16746 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16747 {
16748 hc_device_param_t *device_param = &data.devices_param[device_id];
16749
16750 if (device_param->skipped) continue;
16751
16752 if (data.hm_device[device_id].od_version == 6)
16753 {
16754 // check powertune capabilities first, if not available then skip device
16755
16756 int powertune_supported = 0;
16757
16758 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16759 {
16760 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16761
16762 return (-1);
16763 }
16764
16765 if (powertune_supported != 0)
16766 {
16767 // powercontrol settings
16768
16769 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)
16770 {
16771 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16772
16773 return (-1);
16774 }
16775
16776 // clocks
16777
16778 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16779
16780 performance_state->iNumberOfPerformanceLevels = 2;
16781
16782 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16783 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16784 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16785 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16786
16787 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)
16788 {
16789 log_info ("ERROR: Failed to restore ADL performance state");
16790
16791 return (-1);
16792 }
16793
16794 local_free (performance_state);
16795 }
16796 }
16797 }
16798
16799 hc_thread_mutex_unlock (mux_adl);
16800 }
16801 #endif // HAVE_ADL
16802
16803 if (gpu_temp_disable == 0)
16804 {
16805 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
16806 if (data.hm_nv)
16807 {
16808 #if defined(LINUX) && defined(HAVE_NVML)
16809
16810 hm_NVML_nvmlShutdown (data.hm_nv);
16811
16812 nvml_close (data.hm_nv);
16813
16814 #elif defined(WIN) && (HAVE_NVAPI)
16815
16816 hm_NvAPI_Unload (data.hm_nv);
16817
16818 nvapi_close (data.hm_nv);
16819
16820 #endif
16821
16822 data.hm_nv = NULL;
16823 }
16824 #endif
16825
16826 #ifdef HAVE_ADL
16827 if (data.hm_amd)
16828 {
16829 hm_ADL_Main_Control_Destroy (data.hm_amd);
16830
16831 adl_close (data.hm_amd);
16832 data.hm_amd = NULL;
16833 }
16834 #endif
16835 }
16836 #endif // HAVE_HWMON
16837
16838 // free memory
16839
16840 local_free (masks);
16841
16842 local_free (dictstat_base);
16843
16844 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16845 {
16846 pot_t *pot_ptr = &pot[pot_pos];
16847
16848 hash_t *hash = &pot_ptr->hash;
16849
16850 local_free (hash->digest);
16851
16852 if (isSalted)
16853 {
16854 local_free (hash->salt);
16855 }
16856 }
16857
16858 local_free (pot);
16859
16860 local_free (all_kernel_rules_cnt);
16861 local_free (all_kernel_rules_buf);
16862
16863 local_free (wl_data->buf);
16864 local_free (wl_data);
16865
16866 local_free (bitmap_s1_a);
16867 local_free (bitmap_s1_b);
16868 local_free (bitmap_s1_c);
16869 local_free (bitmap_s1_d);
16870 local_free (bitmap_s2_a);
16871 local_free (bitmap_s2_b);
16872 local_free (bitmap_s2_c);
16873 local_free (bitmap_s2_d);
16874
16875 #ifdef HAVE_HWMON
16876 local_free (temp_retain_fanspeed_value);
16877 #ifdef HAVE_ADL
16878 local_free (od_clock_mem_status);
16879 local_free (od_power_control_status);
16880 #endif // ADL
16881 #endif
16882
16883 global_free (devices_param);
16884
16885 global_free (kernel_rules_buf);
16886
16887 global_free (root_css_buf);
16888 global_free (markov_css_buf);
16889
16890 global_free (digests_buf);
16891 global_free (digests_shown);
16892 global_free (digests_shown_tmp);
16893
16894 global_free (salts_buf);
16895 global_free (salts_shown);
16896
16897 global_free (esalts_buf);
16898
16899 global_free (words_progress_done);
16900 global_free (words_progress_rejected);
16901 global_free (words_progress_restored);
16902
16903 if (pot_fp) fclose (pot_fp);
16904
16905 if (data.devices_status == STATUS_QUIT) break;
16906 }
16907
16908 // destroy others mutex
16909
16910 hc_thread_mutex_delete (mux_dispatcher);
16911 hc_thread_mutex_delete (mux_counter);
16912 hc_thread_mutex_delete (mux_display);
16913 hc_thread_mutex_delete (mux_adl);
16914
16915 // free memory
16916
16917 local_free (eff_restore_file);
16918 local_free (new_restore_file);
16919
16920 local_free (rd);
16921
16922 // tuning db
16923
16924 tuning_db_destroy (tuning_db);
16925
16926 // loopback
16927
16928 local_free (loopback_file);
16929
16930 if (loopback == 1) unlink (loopback_file);
16931
16932 // induction directory
16933
16934 if (induction_dir == NULL)
16935 {
16936 if (attack_mode != ATTACK_MODE_BF)
16937 {
16938 if (rmdir (induction_directory) == -1)
16939 {
16940 if (errno == ENOENT)
16941 {
16942 // good, we can ignore
16943 }
16944 else if (errno == ENOTEMPTY)
16945 {
16946 // good, we can ignore
16947 }
16948 else
16949 {
16950 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16951
16952 return (-1);
16953 }
16954 }
16955
16956 local_free (induction_directory);
16957 }
16958 }
16959
16960 // outfile-check directory
16961
16962 if (outfile_check_dir == NULL)
16963 {
16964 if (rmdir (outfile_check_directory) == -1)
16965 {
16966 if (errno == ENOENT)
16967 {
16968 // good, we can ignore
16969 }
16970 else if (errno == ENOTEMPTY)
16971 {
16972 // good, we can ignore
16973 }
16974 else
16975 {
16976 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16977
16978 return (-1);
16979 }
16980 }
16981
16982 local_free (outfile_check_directory);
16983 }
16984
16985 time_t proc_stop;
16986
16987 time (&proc_stop);
16988
16989 logfile_top_uint (proc_start);
16990 logfile_top_uint (proc_stop);
16991
16992 logfile_top_msg ("STOP");
16993
16994 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16995 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16996
16997 if (data.ocl) ocl_close (data.ocl);
16998
16999 if (data.devices_status == STATUS_ABORTED) return 2;
17000 if (data.devices_status == STATUS_QUIT) return 2;
17001 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17002 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17003 if (data.devices_status == STATUS_CRACKED) return 0;
17004
17005 return -1;
17006 }
Hashcat additions to support pwdhash