projects / hashcat.git / blob
? search:


cb3eb3fb143e3b5d30ac286150e427ca383660f1
[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 133
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 13200,
264 13300,
265 6211,
266 6221,
267 6231,
268 6241,
269 8800,
270 12900,
271 12200,
272 9700,
273 9710,
274 9800,
275 9810,
276 9400,
277 9500,
278 9600,
279 10400,
280 10410,
281 10500,
282 10600,
283 10700,
284 9000,
285 5200,
286 6800,
287 6600,
288 8200,
289 11300,
290 12700
291 };
292
293 /**
294 * types
295 */
296
297 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
298
299 /**
300 * globals
301 */
302
303 static unsigned int full01 = 0x01010101;
304 static unsigned int full80 = 0x80808080;
305
306 int SUPPRESS_OUTPUT = 0;
307
308 hc_thread_mutex_t mux_adl;
309 hc_thread_mutex_t mux_counter;
310 hc_thread_mutex_t mux_dispatcher;
311 hc_thread_mutex_t mux_display;
312
313 hc_global_data_t data;
314
315 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
316
317 const char *USAGE_MINI[] =
318 {
319 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
320 "",
321 "Try --help for more help.",
322 NULL
323 };
324
325 const char *USAGE_BIG[] =
326 {
327 "%s, advanced password recovery",
328 "",
329 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
330 "",
331 "=======",
332 "Options",
333 "=======",
334 "",
335 "* General:",
336 "",
337 " -m, --hash-type=NUM Hash-type, see references below",
338 " -a, --attack-mode=NUM Attack-mode, see references below",
339 " -V, --version Print version",
340 " -h, --help Print help",
341 " --quiet Suppress output",
342 "",
343 "* Misc:",
344 "",
345 " --hex-charset Assume charset is given in hex",
346 " --hex-salt Assume salt is given in hex",
347 " --hex-wordlist Assume words in wordlist is given in hex",
348 " --force Ignore warnings",
349 " --status Enable automatic update of the status-screen",
350 " --status-timer=NUM Seconds between status-screen update",
351 " --status-automat Display the status view in a machine readable format",
352 " --loopback Add new plains to induct directory",
353 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
354 "",
355 "* Markov:",
356 "",
357 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
358 " --markov-disable Disables markov-chains, emulates classic brute-force",
359 " --markov-classic Enables classic markov-chains, no per-position enhancement",
360 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
361 "",
362 "* Session:",
363 "",
364 " --runtime=NUM Abort session after NUM seconds of runtime",
365 " --session=STR Define specific session name",
366 " --restore Restore session from --session",
367 " --restore-disable Do not write restore file",
368 "",
369 "* Files:",
370 "",
371 " -o, --outfile=FILE Define outfile for recovered hash",
372 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
373 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
374 " --outfile-check-timer=NUM Seconds between outfile checks",
375 " -p, --separator=CHAR Separator char for hashlists and outfile",
376 " --show Show cracked passwords only",
377 " --left Show un-cracked passwords only",
378 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
379 " --remove Enable remove of hash once it is cracked",
380 " --remove-timer=NUM Update input hash file each NUM seconds",
381 " --potfile-disable Do not write potfile",
382 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
383 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
384 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
385 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
386 " --logfile-disable Disable the logfile",
387 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
388 "",
389 "* Resources:",
390 "",
391 " -b, --benchmark Run benchmark",
392 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
393 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
394 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
395 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
396 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
397 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
398 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
399 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
400 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
401 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
402 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
403 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
404 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
405 #ifdef HAVE_HWMON
406 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
407 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
408 #ifdef HAVE_ADL
409 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
410 #endif
411 #endif
412 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
413 "",
414 "* Distributed:",
415 "",
416 " -s, --skip=NUM Skip number of words",
417 " -l, --limit=NUM Limit number of words",
418 " --keyspace Show keyspace base:mod values and quit",
419 "",
420 "* Rules:",
421 "",
422 " -j, --rule-left=RULE Single rule applied to each word from left dict",
423 " -k, --rule-right=RULE Single rule applied to each word from right dict",
424 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
425 " -g, --generate-rules=NUM Generate NUM random rules",
426 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
427 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
428 " --generate-rules-seed=NUM Force RNG seed to NUM",
429 "",
430 "* Custom charsets:",
431 "",
432 " -1, --custom-charset1=CS User-defined charsets",
433 " -2, --custom-charset2=CS Example:",
434 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
435 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
436 "",
437 "* Increment:",
438 "",
439 " -i, --increment Enable increment mode",
440 " --increment-min=NUM Start incrementing at NUM",
441 " --increment-max=NUM Stop incrementing at NUM",
442 "",
443 "==========",
444 "References",
445 "==========",
446 "",
447 "* Workload Profile:",
448 "",
449 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
450 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
451 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
452 "",
453 "* OpenCL device-types:",
454 "",
455 " 1 = CPU devices",
456 " 2 = GPU devices",
457 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
458 "",
459 "* Outfile Formats:",
460 "",
461 " 1 = hash[:salt]",
462 " 2 = plain",
463 " 3 = hash[:salt]:plain",
464 " 4 = hex_plain",
465 " 5 = hash[:salt]:hex_plain",
466 " 6 = plain:hex_plain",
467 " 7 = hash[:salt]:plain:hex_plain",
468 " 8 = crackpos",
469 " 9 = hash[:salt]:crackpos",
470 " 10 = plain:crackpos",
471 " 11 = hash[:salt]:plain:crackpos",
472 " 12 = hex_plain:crackpos",
473 " 13 = hash[:salt]:hex_plain:crackpos",
474 " 14 = plain:hex_plain:crackpos",
475 " 15 = hash[:salt]:plain:hex_plain:crackpos",
476 "",
477 "* Debug mode output formats (for hybrid mode only, by using rules):",
478 "",
479 " 1 = save finding rule",
480 " 2 = save original word",
481 " 3 = save original word and finding rule",
482 " 4 = save original word, finding rule and modified plain",
483 "",
484 "* Built-in charsets:",
485 "",
486 " ?l = abcdefghijklmnopqrstuvwxyz",
487 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
488 " ?d = 0123456789",
489 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
490 " ?a = ?l?u?d?s",
491 " ?b = 0x00 - 0xff",
492 "",
493 "* Attack modes:",
494 "",
495 " 0 = Straight",
496 " 1 = Combination",
497 " 3 = Brute-force",
498 " 6 = Hybrid dict + mask",
499 " 7 = Hybrid mask + dict",
500 "",
501 "* Hash types:",
502 "",
503 "[[ Roll-your-own: Raw Hashes ]]",
504 "",
505 " 900 = MD4",
506 " 0 = MD5",
507 " 5100 = Half MD5",
508 " 100 = SHA1",
509 " 10800 = SHA-384",
510 " 1400 = SHA-256",
511 " 1700 = SHA-512",
512 " 5000 = SHA-3(Keccak)",
513 " 10100 = SipHash",
514 " 6000 = RipeMD160",
515 " 6100 = Whirlpool",
516 " 6900 = GOST R 34.11-94",
517 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
518 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
519 "",
520 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
521 "",
522 " 10 = md5($pass.$salt)",
523 " 20 = md5($salt.$pass)",
524 " 30 = md5(unicode($pass).$salt)",
525 " 40 = md5($salt.unicode($pass))",
526 " 3800 = md5($salt.$pass.$salt)",
527 " 3710 = md5($salt.md5($pass))",
528 " 2600 = md5(md5($pass)",
529 " 4300 = md5(strtoupper(md5($pass)))",
530 " 4400 = md5(sha1($pass))",
531 " 110 = sha1($pass.$salt)",
532 " 120 = sha1($salt.$pass)",
533 " 130 = sha1(unicode($pass).$salt)",
534 " 140 = sha1($salt.unicode($pass))",
535 " 4500 = sha1(sha1($pass)",
536 " 4700 = sha1(md5($pass))",
537 " 4900 = sha1($salt.$pass.$salt)",
538 " 1410 = sha256($pass.$salt)",
539 " 1420 = sha256($salt.$pass)",
540 " 1430 = sha256(unicode($pass).$salt)",
541 " 1440 = sha256($salt.unicode($pass))",
542 " 1710 = sha512($pass.$salt)",
543 " 1720 = sha512($salt.$pass)",
544 " 1730 = sha512(unicode($pass).$salt)",
545 " 1740 = sha512($salt.unicode($pass))",
546 "",
547 "[[ Roll-your-own: Authenticated Hashes ]]",
548 "",
549 " 50 = HMAC-MD5 (key = $pass)",
550 " 60 = HMAC-MD5 (key = $salt)",
551 " 150 = HMAC-SHA1 (key = $pass)",
552 " 160 = HMAC-SHA1 (key = $salt)",
553 " 1450 = HMAC-SHA256 (key = $pass)",
554 " 1460 = HMAC-SHA256 (key = $salt)",
555 " 1750 = HMAC-SHA512 (key = $pass)",
556 " 1760 = HMAC-SHA512 (key = $salt)",
557 "",
558 "[[ Generic KDF ]]",
559 "",
560 " 400 = phpass",
561 " 8900 = scrypt",
562 " 11900 = PBKDF2-HMAC-MD5",
563 " 12000 = PBKDF2-HMAC-SHA1",
564 " 10900 = PBKDF2-HMAC-SHA256",
565 " 12100 = PBKDF2-HMAC-SHA512",
566 "",
567 "[[ Network protocols, Challenge-Response ]]",
568 "",
569 " 23 = Skype",
570 " 2500 = WPA/WPA2",
571 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
572 " 5300 = IKE-PSK MD5",
573 " 5400 = IKE-PSK SHA1",
574 " 5500 = NetNTLMv1",
575 " 5500 = NetNTLMv1 + ESS",
576 " 5600 = NetNTLMv2",
577 " 7300 = IPMI2 RAKP HMAC-SHA1",
578 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
579 " 8300 = DNSSEC (NSEC3)",
580 " 10200 = Cram MD5",
581 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
582 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
583 " 11400 = SIP digest authentication (MD5)",
584 " 13100 = Kerberos 5 TGS-REP etype 23",
585 "",
586 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
587 "",
588 " 121 = SMF (Simple Machines Forum)",
589 " 400 = phpBB3",
590 " 2611 = vBulletin < v3.8.5",
591 " 2711 = vBulletin > v3.8.5",
592 " 2811 = MyBB",
593 " 2811 = IPB (Invison Power Board)",
594 " 8400 = WBB3 (Woltlab Burning Board)",
595 " 11 = Joomla < 2.5.18",
596 " 400 = Joomla > 2.5.18",
597 " 400 = Wordpress",
598 " 2612 = PHPS",
599 " 7900 = Drupal7",
600 " 21 = osCommerce",
601 " 21 = xt:Commerce",
602 " 11000 = PrestaShop",
603 " 124 = Django (SHA-1)",
604 " 10000 = Django (PBKDF2-SHA256)",
605 " 3711 = Mediawiki B type",
606 " 7600 = Redmine",
607 "",
608 "[[ Database Server ]]",
609 "",
610 " 12 = PostgreSQL",
611 " 131 = MSSQL(2000)",
612 " 132 = MSSQL(2005)",
613 " 1731 = MSSQL(2012)",
614 " 1731 = MSSQL(2014)",
615 " 200 = MySQL323",
616 " 300 = MySQL4.1/MySQL5",
617 " 3100 = Oracle H: Type (Oracle 7+)",
618 " 112 = Oracle S: Type (Oracle 11+)",
619 " 12300 = Oracle T: Type (Oracle 12+)",
620 " 8000 = Sybase ASE",
621 "",
622 "[[ HTTP, SMTP, LDAP Server ]]",
623 "",
624 " 141 = EPiServer 6.x < v4",
625 " 1441 = EPiServer 6.x > v4",
626 " 1600 = Apache $apr1$",
627 " 12600 = ColdFusion 10+",
628 " 1421 = hMailServer",
629 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
630 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
631 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
632 "",
633 "[[ Checksums ]]",
634 "",
635 " 11500 = CRC32",
636 "",
637 "[[ Operating-Systems ]]",
638 "",
639 " 3000 = LM",
640 " 1000 = NTLM",
641 " 1100 = Domain Cached Credentials (DCC), MS Cache",
642 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
643 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
644 " 1500 = descrypt, DES(Unix), Traditional DES",
645 " 12400 = BSDiCrypt, Extended DES",
646 " 500 = md5crypt $1$, MD5(Unix)",
647 " 3200 = bcrypt $2*$, Blowfish(Unix)",
648 " 7400 = sha256crypt $5$, SHA256(Unix)",
649 " 1800 = sha512crypt $6$, SHA512(Unix)",
650 " 122 = OSX v10.4",
651 " 122 = OSX v10.5",
652 " 122 = OSX v10.6",
653 " 1722 = OSX v10.7",
654 " 7100 = OSX v10.8",
655 " 7100 = OSX v10.9",
656 " 7100 = OSX v10.10",
657 " 6300 = AIX {smd5}",
658 " 6700 = AIX {ssha1}",
659 " 6400 = AIX {ssha256}",
660 " 6500 = AIX {ssha512}",
661 " 2400 = Cisco-PIX",
662 " 2410 = Cisco-ASA",
663 " 500 = Cisco-IOS $1$",
664 " 5700 = Cisco-IOS $4$",
665 " 9200 = Cisco-IOS $8$",
666 " 9300 = Cisco-IOS $9$",
667 " 22 = Juniper Netscreen/SSG (ScreenOS)",
668 " 501 = Juniper IVE",
669 " 5800 = Android PIN",
670 " 8100 = Citrix Netscaler",
671 " 8500 = RACF",
672 " 7200 = GRUB 2",
673 " 9900 = Radmin2",
674 "",
675 "[[ Enterprise Application Software (EAS) ]]",
676 "",
677 " 7700 = SAP CODVN B (BCODE)",
678 " 7800 = SAP CODVN F/G (PASSCODE)",
679 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
680 " 8600 = Lotus Notes/Domino 5",
681 " 8700 = Lotus Notes/Domino 6",
682 " 9100 = Lotus Notes/Domino 8",
683 " 133 = PeopleSoft",
684 "",
685 "[[ Archives ]]",
686 "",
687 " 11600 = 7-Zip",
688 " 12500 = RAR3-hp",
689 " 13000 = RAR5",
690 " 13200 = AxCrypt",
691 " 13300 = AxCrypt in memory SHA1",
692 "",
693 "[[ Full-Disk encryptions (FDE) ]]",
694 "",
695 " 62XY = TrueCrypt 5.0+",
696 " X = 1 = PBKDF2-HMAC-RipeMD160",
697 " X = 2 = PBKDF2-HMAC-SHA512",
698 " X = 3 = PBKDF2-HMAC-Whirlpool",
699 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
700 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
701 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
702 " Y = 3 = XTS 1536 bit (Ciphers: All)",
703 " 8800 = Android FDE < v4.3",
704 " 12900 = Android FDE (Samsung DEK)",
705 " 12200 = eCryptfs",
706 "",
707 "[[ Documents ]]",
708 "",
709 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
710 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
711 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
712 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
713 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
714 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
715 " 9400 = MS Office 2007",
716 " 9500 = MS Office 2010",
717 " 9600 = MS Office 2013",
718 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
719 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
720 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
721 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
722 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
723 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
724 "",
725 "[[ Password Managers ]]",
726 "",
727 " 9000 = Password Safe v2",
728 " 5200 = Password Safe v3",
729 " 6800 = Lastpass",
730 " 6600 = 1Password, agilekeychain",
731 " 8200 = 1Password, cloudkeychain",
732 " 11300 = Bitcoin/Litecoin wallet.dat",
733 " 12700 = Blockchain, My Wallet",
734 "",
735 NULL
736 };
737
738 /**
739 * oclHashcat specific functions
740 */
741
742 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
743 {
744 int exec_pos = (int) device_param->exec_pos - last_num_entries;
745
746 if (exec_pos < 0) exec_pos += EXEC_CACHE;
747
748 double exec_ms_sum = 0;
749
750 int exec_ms_cnt = 0;
751
752 for (int i = 0; i < last_num_entries; i++)
753 {
754 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
755
756 if (exec_ms)
757 {
758 exec_ms_sum += exec_ms;
759
760 exec_ms_cnt++;
761 }
762 }
763
764 if (exec_ms_cnt == 0) return 0;
765
766 return exec_ms_sum / exec_ms_cnt;
767 }
768
769 void status_display_automat ()
770 {
771 FILE *out = stdout;
772
773 fprintf (out, "STATUS\t%u\t", data.devices_status);
774
775 /**
776 * speed new
777 */
778
779 fprintf (out, "SPEED\t");
780
781 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
782 {
783 hc_device_param_t *device_param = &data.devices_param[device_id];
784
785 if (device_param->skipped) continue;
786
787 u64 speed_cnt = 0;
788 float speed_ms = 0;
789
790 for (int i = 0; i < SPEED_CACHE; i++)
791 {
792 float rec_ms;
793
794 hc_timer_get (device_param->speed_rec[i], rec_ms);
795
796 if (rec_ms > SPEED_MAXAGE) continue;
797
798 speed_cnt += device_param->speed_cnt[i];
799 speed_ms += device_param->speed_ms[i];
800 }
801
802 speed_cnt /= SPEED_CACHE;
803 speed_ms /= SPEED_CACHE;
804
805 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
806 }
807
808 /**
809 * exec time
810 */
811
812 fprintf (out, "EXEC_RUNTIME\t");
813
814 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
815 {
816 hc_device_param_t *device_param = &data.devices_param[device_id];
817
818 if (device_param->skipped) continue;
819
820 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
821
822 fprintf (out, "%f\t", exec_ms_avg);
823 }
824
825 /**
826 * words_cur
827 */
828
829 u64 words_cur = get_lowest_words_done ();
830
831 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
832
833 /**
834 * counter
835 */
836
837 u64 progress_total = data.words_cnt * data.salts_cnt;
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 all_done += data.words_progress_done[salt_pos];
846 all_rejected += data.words_progress_rejected[salt_pos];
847 all_restored += data.words_progress_restored[salt_pos];
848 }
849
850 u64 progress_cur = all_restored + all_done + all_rejected;
851 u64 progress_end = progress_total;
852
853 u64 progress_skip = 0;
854
855 if (data.skip)
856 {
857 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
858
859 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
860 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
861 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
862 }
863
864 if (data.limit)
865 {
866 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
867
868 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
869 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
870 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
871 }
872
873 u64 progress_cur_relative_skip = progress_cur - progress_skip;
874 u64 progress_end_relative_skip = progress_end - progress_skip;
875
876 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
877
878 /**
879 * cracks
880 */
881
882 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
883 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
884
885 /**
886 * temperature
887 */
888
889 #ifdef HAVE_HWMON
890 if (data.gpu_temp_disable == 0)
891 {
892 fprintf (out, "TEMP\t");
893
894 hc_thread_mutex_lock (mux_adl);
895
896 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
897 {
898 hc_device_param_t *device_param = &data.devices_param[device_id];
899
900 if (device_param->skipped) continue;
901
902 int temp = hm_get_temperature_with_device_id (device_id);
903
904 fprintf (out, "%d\t", temp);
905 }
906
907 hc_thread_mutex_unlock (mux_adl);
908 }
909 #endif // HAVE_HWMON
910
911 /**
912 * flush
913 */
914
915 #ifdef _WIN
916 fputc ('\r', out);
917 fputc ('\n', out);
918 #endif
919
920 #ifdef _POSIX
921 fputc ('\n', out);
922 #endif
923
924 fflush (out);
925 }
926
927 void status_display ()
928 {
929 if (data.devices_status == STATUS_INIT) return;
930 if (data.devices_status == STATUS_STARTING) return;
931 if (data.devices_status == STATUS_BYPASS) return;
932
933 if (data.status_automat == 1)
934 {
935 status_display_automat ();
936
937 return;
938 }
939
940 char tmp_buf[1000] = { 0 };
941
942 uint tmp_len = 0;
943
944 log_info ("Session.Name...: %s", data.session);
945
946 char *status_type = strstatus (data.devices_status);
947
948 uint hash_mode = data.hash_mode;
949
950 char *hash_type = strhashtype (hash_mode); // not a bug
951
952 log_info ("Status.........: %s", status_type);
953
954 /**
955 * show rules
956 */
957
958 if (data.rp_files_cnt)
959 {
960 uint i;
961
962 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
963 {
964 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
965 }
966
967 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
968
969 log_info ("Rules.Type.....: %s", tmp_buf);
970
971 tmp_len = 0;
972 }
973
974 if (data.rp_gen)
975 {
976 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
977
978 if (data.rp_gen_seed)
979 {
980 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
981 }
982 }
983
984 /**
985 * show input
986 */
987
988 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
989 {
990 if (data.wordlist_mode == WL_MODE_FILE)
991 {
992 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
993 }
994 else if (data.wordlist_mode == WL_MODE_STDIN)
995 {
996 log_info ("Input.Mode.....: Pipe");
997 }
998 }
999 else if (data.attack_mode == ATTACK_MODE_COMBI)
1000 {
1001 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1002 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1003 }
1004 else if (data.attack_mode == ATTACK_MODE_BF)
1005 {
1006 char *mask = data.mask;
1007
1008 if (mask != NULL)
1009 {
1010 uint mask_len = data.css_cnt;
1011
1012 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1013
1014 if (mask_len > 0)
1015 {
1016 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1017 {
1018 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1019 {
1020 mask_len -= data.salts_buf[0].salt_len;
1021 }
1022 }
1023
1024 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1025
1026 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1027 }
1028
1029 if (data.maskcnt > 1)
1030 {
1031 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1032
1033 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1034 }
1035
1036 log_info ("Input.Mode.....: %s", tmp_buf);
1037 }
1038
1039 tmp_len = 0;
1040 }
1041 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1042 {
1043 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1044 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1045 }
1046 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1047 {
1048 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1049 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1050 }
1051
1052 if (data.digests_cnt == 1)
1053 {
1054 if (data.hash_mode == 2500)
1055 {
1056 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1057
1058 uint pke[25] = { 0 };
1059
1060 char *pke_ptr = (char *) pke;
1061
1062 for (uint i = 0; i < 25; i++)
1063 {
1064 pke[i] = byte_swap_32 (wpa->pke[i]);
1065 }
1066
1067 char mac1[6] = { 0 };
1068 char mac2[6] = { 0 };
1069
1070 memcpy (mac1, pke_ptr + 23, 6);
1071 memcpy (mac2, pke_ptr + 29, 6);
1072
1073 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1074 (char *) data.salts_buf[0].salt_buf,
1075 mac1[0] & 0xff,
1076 mac1[1] & 0xff,
1077 mac1[2] & 0xff,
1078 mac1[3] & 0xff,
1079 mac1[4] & 0xff,
1080 mac1[5] & 0xff,
1081 mac2[0] & 0xff,
1082 mac2[1] & 0xff,
1083 mac2[2] & 0xff,
1084 mac2[3] & 0xff,
1085 mac2[4] & 0xff,
1086 mac2[5] & 0xff);
1087 }
1088 else if (data.hash_mode == 5200)
1089 {
1090 log_info ("Hash.Target....: File (%s)", data.hashfile);
1091 }
1092 else if (data.hash_mode == 9000)
1093 {
1094 log_info ("Hash.Target....: File (%s)", data.hashfile);
1095 }
1096 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1097 {
1098 log_info ("Hash.Target....: File (%s)", data.hashfile);
1099 }
1100 else
1101 {
1102 char out_buf[4096] = { 0 };
1103
1104 ascii_digest (out_buf, 0, 0);
1105
1106 // limit length
1107 if (strlen (out_buf) > 40)
1108 {
1109 out_buf[41] = '.';
1110 out_buf[42] = '.';
1111 out_buf[43] = '.';
1112 out_buf[44] = 0;
1113 }
1114
1115 log_info ("Hash.Target....: %s", out_buf);
1116 }
1117 }
1118 else
1119 {
1120 if (data.hash_mode == 3000)
1121 {
1122 char out_buf1[4096] = { 0 };
1123 char out_buf2[4096] = { 0 };
1124
1125 ascii_digest (out_buf1, 0, 0);
1126 ascii_digest (out_buf2, 0, 1);
1127
1128 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1129 }
1130 else
1131 {
1132 log_info ("Hash.Target....: File (%s)", data.hashfile);
1133 }
1134 }
1135
1136 log_info ("Hash.Type......: %s", hash_type);
1137
1138 /**
1139 * speed new
1140 */
1141
1142 u64 speed_cnt[DEVICES_MAX] = { 0 };
1143 float speed_ms[DEVICES_MAX] = { 0 };
1144
1145 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1146 {
1147 hc_device_param_t *device_param = &data.devices_param[device_id];
1148
1149 if (device_param->skipped) continue;
1150
1151 // we need to clear values (set to 0) because in case the device does
1152 // not get new candidates it idles around but speed display would
1153 // show it as working.
1154 // if we instantly set it to 0 after reading it happens that the
1155 // speed can be shown as zero if the users refreshes too fast.
1156 // therefore, we add a timestamp when a stat was recorded and if its
1157 // too old we will not use it
1158
1159 speed_cnt[device_id] = 0;
1160 speed_ms[device_id] = 0;
1161
1162 for (int i = 0; i < SPEED_CACHE; i++)
1163 {
1164 float rec_ms;
1165
1166 hc_timer_get (device_param->speed_rec[i], rec_ms);
1167
1168 if (rec_ms > SPEED_MAXAGE) continue;
1169
1170 speed_cnt[device_id] += device_param->speed_cnt[i];
1171 speed_ms[device_id] += device_param->speed_ms[i];
1172 }
1173
1174 speed_cnt[device_id] /= SPEED_CACHE;
1175 speed_ms[device_id] /= SPEED_CACHE;
1176 }
1177
1178 float hashes_all_ms = 0;
1179
1180 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1181
1182 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1183 {
1184 hc_device_param_t *device_param = &data.devices_param[device_id];
1185
1186 if (device_param->skipped) continue;
1187
1188 hashes_dev_ms[device_id] = 0;
1189
1190 if (speed_ms[device_id])
1191 {
1192 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1193
1194 hashes_all_ms += hashes_dev_ms[device_id];
1195 }
1196 }
1197
1198 /**
1199 * exec time
1200 */
1201
1202 double exec_all_ms[DEVICES_MAX] = { 0 };
1203
1204 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1205 {
1206 hc_device_param_t *device_param = &data.devices_param[device_id];
1207
1208 if (device_param->skipped) continue;
1209
1210 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1211
1212 exec_all_ms[device_id] = exec_ms_avg;
1213 }
1214
1215 /**
1216 * timers
1217 */
1218
1219 float ms_running = 0;
1220
1221 hc_timer_get (data.timer_running, ms_running);
1222
1223 float ms_paused = data.ms_paused;
1224
1225 if (data.devices_status == STATUS_PAUSED)
1226 {
1227 float ms_paused_tmp = 0;
1228
1229 hc_timer_get (data.timer_paused, ms_paused_tmp);
1230
1231 ms_paused += ms_paused_tmp;
1232 }
1233
1234 #ifdef WIN
1235
1236 __time64_t sec_run = ms_running / 1000;
1237
1238 #else
1239
1240 time_t sec_run = ms_running / 1000;
1241
1242 #endif
1243
1244 if (sec_run)
1245 {
1246 char display_run[32] = { 0 };
1247
1248 struct tm tm_run;
1249
1250 struct tm *tmp = NULL;
1251
1252 #ifdef WIN
1253
1254 tmp = _gmtime64 (&sec_run);
1255
1256 #else
1257
1258 tmp = gmtime (&sec_run);
1259
1260 #endif
1261
1262 if (tmp != NULL)
1263 {
1264 memset (&tm_run, 0, sizeof (tm_run));
1265
1266 memcpy (&tm_run, tmp, sizeof (tm_run));
1267
1268 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1269
1270 char *start = ctime (&data.proc_start);
1271
1272 size_t start_len = strlen (start);
1273
1274 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1275 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1276
1277 log_info ("Time.Started...: %s (%s)", start, display_run);
1278 }
1279 }
1280 else
1281 {
1282 log_info ("Time.Started...: 0 secs");
1283 }
1284
1285 /**
1286 * counters
1287 */
1288
1289 u64 progress_total = data.words_cnt * data.salts_cnt;
1290
1291 u64 all_done = 0;
1292 u64 all_rejected = 0;
1293 u64 all_restored = 0;
1294
1295 u64 progress_noneed = 0;
1296
1297 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1298 {
1299 all_done += data.words_progress_done[salt_pos];
1300 all_rejected += data.words_progress_rejected[salt_pos];
1301 all_restored += data.words_progress_restored[salt_pos];
1302
1303 // Important for ETA only
1304
1305 if (data.salts_shown[salt_pos] == 1)
1306 {
1307 const u64 all = data.words_progress_done[salt_pos]
1308 + data.words_progress_rejected[salt_pos]
1309 + data.words_progress_restored[salt_pos];
1310
1311 const u64 left = data.words_cnt - all;
1312
1313 progress_noneed += left;
1314 }
1315 }
1316
1317 u64 progress_cur = all_restored + all_done + all_rejected;
1318 u64 progress_end = progress_total;
1319
1320 u64 progress_skip = 0;
1321
1322 if (data.skip)
1323 {
1324 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1325
1326 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1327 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1328 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1329 }
1330
1331 if (data.limit)
1332 {
1333 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1334
1335 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1336 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1337 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1338 }
1339
1340 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1341 u64 progress_end_relative_skip = progress_end - progress_skip;
1342
1343 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1344 {
1345 if (data.devices_status != STATUS_CRACKED)
1346 {
1347 #ifdef WIN
1348 __time64_t sec_etc = 0;
1349 #else
1350 time_t sec_etc = 0;
1351 #endif
1352
1353 if (hashes_all_ms)
1354 {
1355 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1356
1357 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1358
1359 sec_etc = ms_left / 1000;
1360 }
1361
1362 if (sec_etc == 0)
1363 {
1364 //log_info ("Time.Estimated.: 0 secs");
1365 }
1366 else if ((u64) sec_etc > ETC_MAX)
1367 {
1368 log_info ("Time.Estimated.: > 10 Years");
1369 }
1370 else
1371 {
1372 char display_etc[32] = { 0 };
1373
1374 struct tm tm_etc;
1375
1376 struct tm *tmp = NULL;
1377
1378 #ifdef WIN
1379
1380 tmp = _gmtime64 (&sec_etc);
1381
1382 #else
1383
1384 tmp = gmtime (&sec_etc);
1385
1386 #endif
1387
1388 if (tmp != NULL)
1389 {
1390 memset (&tm_etc, 0, sizeof (tm_etc));
1391
1392 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1393
1394 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1395
1396 time_t now;
1397
1398 time (&now);
1399
1400 now += sec_etc;
1401
1402 char *etc = ctime (&now);
1403
1404 size_t etc_len = strlen (etc);
1405
1406 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1407 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1408
1409 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1410 }
1411 }
1412 }
1413 }
1414
1415 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1416 {
1417 hc_device_param_t *device_param = &data.devices_param[device_id];
1418
1419 if (device_param->skipped) continue;
1420
1421 char display_dev_cur[16] = { 0 };
1422
1423 strncpy (display_dev_cur, "0.00", 4);
1424
1425 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1426
1427 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1428 }
1429
1430 char display_all_cur[16] = { 0 };
1431
1432 strncpy (display_all_cur, "0.00", 4);
1433
1434 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1435
1436 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1437
1438 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1439 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1440
1441 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);
1442
1443 // crack-per-time
1444
1445 if (data.digests_cnt > 100)
1446 {
1447 time_t now = time (NULL);
1448
1449 int cpt_cur_min = 0;
1450 int cpt_cur_hour = 0;
1451 int cpt_cur_day = 0;
1452
1453 for (int i = 0; i < CPT_BUF; i++)
1454 {
1455 const uint cracked = data.cpt_buf[i].cracked;
1456 const time_t timestamp = data.cpt_buf[i].timestamp;
1457
1458 if ((timestamp + 60) > now)
1459 {
1460 cpt_cur_min += cracked;
1461 }
1462
1463 if ((timestamp + 3600) > now)
1464 {
1465 cpt_cur_hour += cracked;
1466 }
1467
1468 if ((timestamp + 86400) > now)
1469 {
1470 cpt_cur_day += cracked;
1471 }
1472 }
1473
1474 float ms_real = ms_running - ms_paused;
1475
1476 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1477 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1478 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1479
1480 if ((data.cpt_start + 86400) < now)
1481 {
1482 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1483 cpt_cur_min,
1484 cpt_cur_hour,
1485 cpt_cur_day,
1486 cpt_avg_min,
1487 cpt_avg_hour,
1488 cpt_avg_day);
1489 }
1490 else if ((data.cpt_start + 3600) < now)
1491 {
1492 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1493 cpt_cur_min,
1494 cpt_cur_hour,
1495 cpt_avg_min,
1496 cpt_avg_hour,
1497 cpt_avg_day);
1498 }
1499 else if ((data.cpt_start + 60) < now)
1500 {
1501 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1502 cpt_cur_min,
1503 cpt_avg_min,
1504 cpt_avg_hour,
1505 cpt_avg_day);
1506 }
1507 else
1508 {
1509 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1510 cpt_avg_min,
1511 cpt_avg_hour,
1512 cpt_avg_day);
1513 }
1514 }
1515
1516 // Restore point
1517
1518 u64 restore_point = get_lowest_words_done ();
1519
1520 u64 restore_total = data.words_base;
1521
1522 float percent_restore = 0;
1523
1524 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1525
1526 if (progress_end_relative_skip)
1527 {
1528 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1529 {
1530 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1531 float percent_rejected = 0.0;
1532
1533 if (progress_cur)
1534 {
1535 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1536 }
1537
1538 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);
1539 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1540
1541 if (data.restore_disable == 0)
1542 {
1543 if (percent_finished != 1)
1544 {
1545 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1546 }
1547 }
1548 }
1549 }
1550 else
1551 {
1552 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1553 {
1554 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1555 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1556
1557 if (data.restore_disable == 0)
1558 {
1559 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1560 }
1561 }
1562 else
1563 {
1564 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1565 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1566
1567 // --restore not allowed if stdin is used -- really? why?
1568
1569 //if (data.restore_disable == 0)
1570 //{
1571 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1572 //}
1573 }
1574 }
1575
1576 #ifdef HAVE_HWMON
1577 if (data.gpu_temp_disable == 0)
1578 {
1579 hc_thread_mutex_lock (mux_adl);
1580
1581 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1582 {
1583 hc_device_param_t *device_param = &data.devices_param[device_id];
1584
1585 if (device_param->skipped) continue;
1586
1587 #define HM_STR_BUF_SIZE 255
1588
1589 if (data.hm_device[device_id].fan_supported == 1)
1590 {
1591 char utilization[HM_STR_BUF_SIZE] = { 0 };
1592 char temperature[HM_STR_BUF_SIZE] = { 0 };
1593 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1594
1595 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1596 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1597
1598 if (device_param->vendor_id == VENDOR_ID_AMD)
1599 {
1600 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1601 }
1602 else if (device_param->vendor_id == VENDOR_ID_NV)
1603 {
1604 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1605 }
1606
1607 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1608 }
1609 else
1610 {
1611 char utilization[HM_STR_BUF_SIZE] = { 0 };
1612 char temperature[HM_STR_BUF_SIZE] = { 0 };
1613
1614 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1615 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1616
1617 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1618 }
1619 }
1620
1621 hc_thread_mutex_unlock (mux_adl);
1622 }
1623 #endif // HAVE_HWMON
1624 }
1625
1626 static void status_benchmark ()
1627 {
1628 if (data.devices_status == STATUS_INIT) return;
1629 if (data.devices_status == STATUS_STARTING) return;
1630
1631 if (data.words_cnt == 0) return;
1632
1633 u64 speed_cnt[DEVICES_MAX] = { 0 };
1634 float speed_ms[DEVICES_MAX] = { 0 };
1635
1636 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1637 {
1638 hc_device_param_t *device_param = &data.devices_param[device_id];
1639
1640 if (device_param->skipped) continue;
1641
1642 speed_cnt[device_id] = 0;
1643 speed_ms[device_id] = 0;
1644
1645 for (int i = 0; i < SPEED_CACHE; i++)
1646 {
1647 speed_cnt[device_id] += device_param->speed_cnt[i];
1648 speed_ms[device_id] += device_param->speed_ms[i];
1649 }
1650
1651 speed_cnt[device_id] /= SPEED_CACHE;
1652 speed_ms[device_id] /= SPEED_CACHE;
1653 }
1654
1655 float hashes_all_ms = 0;
1656
1657 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1658
1659 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1660 {
1661 hc_device_param_t *device_param = &data.devices_param[device_id];
1662
1663 if (device_param->skipped) continue;
1664
1665 hashes_dev_ms[device_id] = 0;
1666
1667 if (speed_ms[device_id])
1668 {
1669 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1670
1671 hashes_all_ms += hashes_dev_ms[device_id];
1672 }
1673 }
1674
1675 /**
1676 * exec time
1677 */
1678
1679 double exec_all_ms[DEVICES_MAX] = { 0 };
1680
1681 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1682 {
1683 hc_device_param_t *device_param = &data.devices_param[device_id];
1684
1685 if (device_param->skipped) continue;
1686
1687 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1688
1689 exec_all_ms[device_id] = exec_ms_avg;
1690 }
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 char display_dev_cur[16] = { 0 };
1699
1700 strncpy (display_dev_cur, "0.00", 4);
1701
1702 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1703
1704 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1705 }
1706
1707 char display_all_cur[16] = { 0 };
1708
1709 strncpy (display_all_cur, "0.00", 4);
1710
1711 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1712
1713 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1714 }
1715
1716 /**
1717 * oclHashcat -only- functions
1718 */
1719
1720 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1721 {
1722 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1723 {
1724 if (attack_kern == ATTACK_KERN_STRAIGHT)
1725 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1726 else if (attack_kern == ATTACK_KERN_COMBI)
1727 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1728 else if (attack_kern == ATTACK_KERN_BF)
1729 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1730 }
1731 else
1732 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1733 }
1734
1735 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)
1736 {
1737 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1738 {
1739 if (attack_kern == ATTACK_KERN_STRAIGHT)
1740 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1741 else if (attack_kern == ATTACK_KERN_COMBI)
1742 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1743 else if (attack_kern == ATTACK_KERN_BF)
1744 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1745 }
1746 else
1747 {
1748 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1749 }
1750 }
1751
1752 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1753 {
1754 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1755 {
1756 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1757 }
1758 else
1759 {
1760 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1761 }
1762 }
1763
1764 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)
1765 {
1766 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1767 {
1768 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1769 }
1770 else
1771 {
1772 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1773 }
1774 }
1775
1776 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1777 {
1778 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1779 }
1780
1781 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1782 {
1783 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1784 }
1785
1786 static uint convert_from_hex (char *line_buf, const uint line_len)
1787 {
1788 if (line_len & 1) return (line_len); // not in hex
1789
1790 if (data.hex_wordlist == 1)
1791 {
1792 uint i;
1793 uint j;
1794
1795 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1796 {
1797 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1798 }
1799
1800 memset (line_buf + i, 0, line_len - i);
1801
1802 return (i);
1803 }
1804 else if (line_len >= 6) // $HEX[] = 6
1805 {
1806 if (line_buf[0] != '$') return (line_len);
1807 if (line_buf[1] != 'H') return (line_len);
1808 if (line_buf[2] != 'E') return (line_len);
1809 if (line_buf[3] != 'X') return (line_len);
1810 if (line_buf[4] != '[') return (line_len);
1811 if (line_buf[line_len - 1] != ']') return (line_len);
1812
1813 uint i;
1814 uint j;
1815
1816 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1817 {
1818 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1819 }
1820
1821 memset (line_buf + i, 0, line_len - i);
1822
1823 return (i);
1824 }
1825
1826 return (line_len);
1827 }
1828
1829 static void clear_prompt ()
1830 {
1831 fputc ('\r', stdout);
1832
1833 for (size_t i = 0; i < strlen (PROMPT); i++)
1834 {
1835 fputc (' ', stdout);
1836 }
1837
1838 fputc ('\r', stdout);
1839
1840 fflush (stdout);
1841 }
1842
1843 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1844 {
1845 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);
1846 }
1847
1848 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1849 {
1850 char *outfile = data.outfile;
1851 uint quiet = data.quiet;
1852 FILE *pot_fp = data.pot_fp;
1853 uint loopback = data.loopback;
1854 uint debug_mode = data.debug_mode;
1855 char *debug_file = data.debug_file;
1856
1857 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1858 int debug_rule_len = 0; // -1 error
1859 uint debug_plain_len = 0;
1860
1861 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1862
1863 // hash
1864
1865 char out_buf[4096] = { 0 };
1866
1867 ascii_digest (out_buf, salt_pos, digest_pos);
1868
1869 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1870
1871 // plain
1872
1873 plain_t plain;
1874
1875 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);
1876
1877 uint gidvid = plain.gidvid;
1878 uint il_pos = plain.il_pos;
1879
1880 u64 crackpos = device_param->words_off;
1881
1882 uint plain_buf[16] = { 0 };
1883
1884 u8 *plain_ptr = (u8 *) plain_buf;
1885 unsigned int plain_len = 0;
1886
1887 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1888 {
1889 u64 gidd = gidvid;
1890 u64 gidm = 0;
1891
1892 pw_t pw;
1893
1894 gidd_to_pw_t (device_param, gidd, &pw);
1895
1896 for (int i = 0, j = gidm; i < 16; i++, j++)
1897 {
1898 plain_buf[i] = pw.i[j];
1899 }
1900
1901 plain_len = pw.pw_len;
1902
1903 const uint off = device_param->innerloop_pos + il_pos;
1904
1905 if (debug_mode > 0)
1906 {
1907 debug_rule_len = 0;
1908
1909 // save rule
1910 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1911 {
1912 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1913
1914 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1915 }
1916
1917 // save plain
1918 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1919 {
1920 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1921
1922 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1923
1924 debug_plain_len = plain_len;
1925 }
1926 }
1927
1928 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1929
1930 crackpos += gidvid;
1931 crackpos *= data.kernel_rules_cnt;
1932 crackpos += device_param->innerloop_pos + il_pos;
1933
1934 if (plain_len > data.pw_max) plain_len = data.pw_max;
1935 }
1936 else if (data.attack_mode == ATTACK_MODE_COMBI)
1937 {
1938 u64 gidd = gidvid;
1939 u64 gidm = 0;
1940
1941 pw_t pw;
1942
1943 gidd_to_pw_t (device_param, gidd, &pw);
1944
1945 for (int i = 0, j = gidm; i < 16; i++, j++)
1946 {
1947 plain_buf[i] = pw.i[j];
1948 }
1949
1950 plain_len = pw.pw_len;
1951
1952 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1953 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1954
1955 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1956 {
1957 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1958 }
1959 else
1960 {
1961 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1962
1963 memcpy (plain_ptr, comb_buf, comb_len);
1964 }
1965
1966 plain_len += comb_len;
1967
1968 crackpos += gidvid;
1969 crackpos *= data.combs_cnt;
1970 crackpos += device_param->innerloop_pos + il_pos;
1971
1972 if (data.pw_max != PW_DICTMAX1)
1973 {
1974 if (plain_len > data.pw_max) plain_len = data.pw_max;
1975 }
1976 }
1977 else if (data.attack_mode == ATTACK_MODE_BF)
1978 {
1979 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1980 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1981
1982 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1983 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1984
1985 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1986 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1987
1988 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1989 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1990
1991 plain_len = data.css_cnt;
1992
1993 crackpos += gidvid;
1994 crackpos *= data.bfs_cnt;
1995 crackpos += device_param->innerloop_pos + il_pos;
1996 }
1997 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1998 {
1999 u64 gidd = gidvid;
2000 u64 gidm = 0;
2001
2002 pw_t pw;
2003
2004 gidd_to_pw_t (device_param, gidd, &pw);
2005
2006 for (int i = 0, j = gidm; i < 16; i++, j++)
2007 {
2008 plain_buf[i] = pw.i[j];
2009 }
2010
2011 plain_len = pw.pw_len;
2012
2013 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2014
2015 uint start = 0;
2016 uint stop = device_param->kernel_params_mp_buf32[4];
2017
2018 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2019
2020 plain_len += start + stop;
2021
2022 crackpos += gidvid;
2023 crackpos *= data.combs_cnt;
2024 crackpos += device_param->innerloop_pos + il_pos;
2025
2026 if (data.pw_max != PW_DICTMAX1)
2027 {
2028 if (plain_len > data.pw_max) plain_len = data.pw_max;
2029 }
2030 }
2031 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2032 {
2033 u64 gidd = gidvid;
2034 u64 gidm = 0;
2035
2036 pw_t pw;
2037
2038 gidd_to_pw_t (device_param, gidd, &pw);
2039
2040 for (int i = 0, j = gidm; i < 16; i++, j++)
2041 {
2042 plain_buf[i] = pw.i[j];
2043 }
2044
2045 plain_len = pw.pw_len;
2046
2047 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2048
2049 uint start = 0;
2050 uint stop = device_param->kernel_params_mp_buf32[4];
2051
2052 memmove (plain_ptr + stop, plain_ptr, plain_len);
2053
2054 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2055
2056 plain_len += start + stop;
2057
2058 crackpos += gidvid;
2059 crackpos *= data.combs_cnt;
2060 crackpos += device_param->innerloop_pos + il_pos;
2061
2062 if (data.pw_max != PW_DICTMAX1)
2063 {
2064 if (plain_len > data.pw_max) plain_len = data.pw_max;
2065 }
2066 }
2067
2068 if (data.attack_mode == ATTACK_MODE_BF)
2069 {
2070 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2071 {
2072 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2073 {
2074 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2075 {
2076 plain_len = plain_len - data.salts_buf[0].salt_len;
2077 }
2078 }
2079
2080 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2081 {
2082 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2083 {
2084 plain_ptr[j] = plain_ptr[i];
2085 }
2086
2087 plain_len = plain_len / 2;
2088 }
2089 }
2090 }
2091
2092 // if enabled, update also the potfile
2093
2094 if (pot_fp)
2095 {
2096 lock_file (pot_fp);
2097
2098 fprintf (pot_fp, "%s:", out_buf);
2099
2100 format_plain (pot_fp, plain_ptr, plain_len, 1);
2101
2102 fputc ('\n', pot_fp);
2103
2104 fflush (pot_fp);
2105
2106 unlock_file (pot_fp);
2107 }
2108
2109 // outfile
2110
2111 FILE *out_fp = NULL;
2112
2113 if (outfile != NULL)
2114 {
2115 if ((out_fp = fopen (outfile, "ab")) == NULL)
2116 {
2117 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2118
2119 out_fp = stdout;
2120 }
2121 lock_file (out_fp);
2122 }
2123 else
2124 {
2125 out_fp = stdout;
2126
2127 if (quiet == 0) clear_prompt ();
2128 }
2129
2130 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2131
2132 if (outfile != NULL)
2133 {
2134 if (out_fp != stdout)
2135 {
2136 fclose (out_fp);
2137 }
2138 }
2139 else
2140 {
2141 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2142 {
2143 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2144 {
2145 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2146 if (quiet == 0) fflush (stdout);
2147 }
2148 }
2149 }
2150
2151 // loopback
2152
2153 if (loopback)
2154 {
2155 char *loopback_file = data.loopback_file;
2156
2157 FILE *fb_fp = NULL;
2158
2159 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2160 {
2161 lock_file (fb_fp);
2162
2163 format_plain (fb_fp, plain_ptr, plain_len, 1);
2164
2165 fputc ('\n', fb_fp);
2166
2167 fclose (fb_fp);
2168 }
2169 }
2170
2171 // (rule) debug mode
2172
2173 // the next check implies that:
2174 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2175 // - debug_mode > 0
2176
2177 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2178 {
2179 if (debug_rule_len < 0) debug_rule_len = 0;
2180
2181 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2182
2183 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2184
2185 if ((quiet == 0) && (debug_file == NULL))
2186 {
2187 fprintf (stdout, "%s", PROMPT);
2188 fflush (stdout);
2189 }
2190 }
2191 }
2192
2193 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2194 {
2195 salt_t *salt_buf = &data.salts_buf[salt_pos];
2196
2197 int found = 0;
2198
2199 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);
2200
2201 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2202
2203 if (found == 1)
2204 {
2205 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2206
2207 log_info_nn ("");
2208
2209 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);
2210
2211 uint cpt_cracked = 0;
2212
2213 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2214 {
2215 uint idx = salt_buf->digests_offset + digest_pos;
2216
2217 if (data.digests_shown_tmp[idx] == 0) continue;
2218
2219 if (data.digests_shown[idx] == 1) continue;
2220
2221 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2222 {
2223 data.digests_shown[idx] = 1;
2224
2225 data.digests_done++;
2226
2227 cpt_cracked++;
2228
2229 salt_buf->digests_done++;
2230
2231 if (salt_buf->digests_done == salt_buf->digests_cnt)
2232 {
2233 data.salts_shown[salt_pos] = 1;
2234
2235 data.salts_done++;
2236 }
2237 }
2238
2239 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2240
2241 check_hash (device_param, salt_pos, digest_pos);
2242 }
2243
2244 if (cpt_cracked > 0)
2245 {
2246 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2247 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2248
2249 data.cpt_pos++;
2250
2251 data.cpt_total += cpt_cracked;
2252
2253 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2254 }
2255
2256 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2257 {
2258 // we need to reset cracked state on the device
2259 // otherwise host thinks again and again the hash was cracked
2260 // and returns invalid password each time
2261
2262 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2263
2264 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);
2265 }
2266
2267 memset (device_param->result, 0, device_param->size_results);
2268
2269 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);
2270 }
2271 }
2272
2273 static void save_hash ()
2274 {
2275 char *hashfile = data.hashfile;
2276
2277 char new_hashfile[256] = { 0 };
2278 char old_hashfile[256] = { 0 };
2279
2280 snprintf (new_hashfile, 255, "%s.new", hashfile);
2281 snprintf (old_hashfile, 255, "%s.old", hashfile);
2282
2283 unlink (new_hashfile);
2284
2285 char separator = data.separator;
2286
2287 FILE *fp = fopen (new_hashfile, "wb");
2288
2289 if (fp == NULL)
2290 {
2291 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2292
2293 exit (-1);
2294 }
2295
2296 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2297 {
2298 if (data.salts_shown[salt_pos] == 1) continue;
2299
2300 salt_t *salt_buf = &data.salts_buf[salt_pos];
2301
2302 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2303 {
2304 uint idx = salt_buf->digests_offset + digest_pos;
2305
2306 if (data.digests_shown[idx] == 1) continue;
2307
2308 if (data.hash_mode != 2500)
2309 {
2310 char out_buf[4096] = { 0 };
2311
2312 if (data.username == 1)
2313 {
2314 user_t *user = data.hash_info[idx]->user;
2315
2316 uint i;
2317
2318 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2319
2320 fputc (separator, fp);
2321 }
2322
2323 ascii_digest (out_buf, salt_pos, digest_pos);
2324
2325 fputs (out_buf, fp);
2326
2327 log_out (fp, "");
2328 }
2329 else
2330 {
2331 hccap_t hccap;
2332
2333 to_hccap_t (&hccap, salt_pos, digest_pos);
2334
2335 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2336 }
2337 }
2338 }
2339
2340 fflush (fp);
2341
2342 fclose (fp);
2343
2344 unlink (old_hashfile);
2345
2346 if (rename (hashfile, old_hashfile) != 0)
2347 {
2348 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2349
2350 exit (-1);
2351 }
2352
2353 unlink (hashfile);
2354
2355 if (rename (new_hashfile, hashfile) != 0)
2356 {
2357 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2358
2359 exit (-1);
2360 }
2361
2362 unlink (old_hashfile);
2363 }
2364
2365 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2366 {
2367 // function called only in case kernel_power_all > words_left
2368
2369 float kernel_power_div = (float) (total_left) / kernel_power_all;
2370
2371 kernel_power_div += kernel_power_div / 100;
2372
2373 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2374
2375 while (kernel_power_new < total_left)
2376 {
2377 kernel_power_div += kernel_power_div / 100;
2378
2379 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2380 }
2381
2382 if (data.quiet == 0)
2383 {
2384 clear_prompt ();
2385
2386 log_info ("");
2387
2388 log_info ("INFO: approaching final keyspace, workload adjusted");
2389
2390 log_info ("");
2391
2392 fprintf (stdout, "%s", PROMPT);
2393
2394 fflush (stdout);
2395 }
2396
2397 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2398
2399 return kernel_power_div;
2400 }
2401
2402 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2403 {
2404 uint num_elements = num;
2405
2406 device_param->kernel_params_buf32[30] = data.combs_mode;
2407 device_param->kernel_params_buf32[31] = num;
2408
2409 uint kernel_threads = device_param->kernel_threads;
2410
2411 while (num_elements % kernel_threads) num_elements++;
2412
2413 cl_kernel kernel = NULL;
2414
2415 switch (kern_run)
2416 {
2417 case KERN_RUN_1: kernel = device_param->kernel1; break;
2418 case KERN_RUN_12: kernel = device_param->kernel12; break;
2419 case KERN_RUN_2: kernel = device_param->kernel2; break;
2420 case KERN_RUN_23: kernel = device_param->kernel23; break;
2421 case KERN_RUN_3: kernel = device_param->kernel3; break;
2422 }
2423
2424 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2425 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2426 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2427 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2428 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2429 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2430 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2431 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2432 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2433 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2434 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2435
2436 hc_timer_t timer;
2437
2438 hc_timer_set (&timer);
2439
2440 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2441 {
2442 const size_t global_work_size[3] = { num_elements, 32, 1 };
2443 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2444
2445 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2446 }
2447 else
2448 {
2449 size_t workgroup_size = 0;
2450
2451 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2452
2453 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2454
2455 const size_t global_work_size[3] = { num_elements, 1, 1 };
2456 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2457
2458 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2459 }
2460
2461 hc_clFlush (data.ocl, device_param->command_queue);
2462
2463 hc_clFinish (data.ocl, device_param->command_queue);
2464
2465 if (event_update)
2466 {
2467 float exec_time;
2468
2469 hc_timer_get (timer, exec_time);
2470
2471 uint exec_pos = device_param->exec_pos;
2472
2473 device_param->exec_ms[exec_pos] = exec_time;
2474
2475 exec_pos++;
2476
2477 if (exec_pos == EXEC_CACHE)
2478 {
2479 exec_pos = 0;
2480 }
2481
2482 device_param->exec_pos = exec_pos;
2483 }
2484 }
2485
2486 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2487 {
2488 uint num_elements = num;
2489
2490 switch (kern_run)
2491 {
2492 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2493 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2494 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2495 }
2496
2497 // causes problems with special threads like in bcrypt
2498 // const uint kernel_threads = device_param->kernel_threads;
2499
2500 uint kernel_threads = KERNEL_THREADS;
2501
2502 while (num_elements % kernel_threads) num_elements++;
2503
2504 cl_kernel kernel = NULL;
2505
2506 switch (kern_run)
2507 {
2508 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2509 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2510 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2511 }
2512
2513 switch (kern_run)
2514 {
2515 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2516 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2517 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2518 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2519 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2520 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2521 break;
2522 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2523 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2524 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2525 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2526 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2527 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2528 break;
2529 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2530 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2531 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2532 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2533 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2534 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2535 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2536 break;
2537 }
2538
2539 size_t workgroup_size = 0;
2540 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
2541 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2542
2543 const size_t global_work_size[3] = { num_elements, 1, 1 };
2544 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2545
2546 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2547
2548 hc_clFlush (data.ocl, device_param->command_queue);
2549
2550 hc_clFinish (data.ocl, device_param->command_queue);
2551 }
2552
2553 static void run_kernel_tm (hc_device_param_t *device_param)
2554 {
2555 const uint num_elements = 1024; // fixed
2556
2557 uint kernel_threads = 32;
2558
2559 cl_kernel kernel = device_param->kernel_tm;
2560
2561 size_t workgroup_size = 0;
2562 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2563 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2564
2565 const size_t global_work_size[3] = { num_elements, 1, 1 };
2566 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2567
2568 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2569
2570 hc_clFlush (data.ocl, device_param->command_queue);
2571
2572 hc_clFinish (data.ocl, device_param->command_queue);
2573 }
2574
2575 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2576 {
2577 uint num_elements = num;
2578
2579 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2580 device_param->kernel_params_amp_buf32[6] = num_elements;
2581
2582 // causes problems with special threads like in bcrypt
2583 // const uint kernel_threads = device_param->kernel_threads;
2584
2585 uint kernel_threads = KERNEL_THREADS;
2586
2587 while (num_elements % kernel_threads) num_elements++;
2588
2589 cl_kernel kernel = device_param->kernel_amp;
2590
2591 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2592 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2593
2594 size_t workgroup_size = 0;
2595 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2596 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2597
2598 const size_t global_work_size[3] = { num_elements, 1, 1 };
2599 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2600
2601 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2602
2603 hc_clFlush (data.ocl, device_param->command_queue);
2604
2605 hc_clFinish (data.ocl, device_param->command_queue);
2606 }
2607
2608 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2609 {
2610 int rc = -1;
2611
2612 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2613 {
2614 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2615
2616 const cl_uchar zero = 0;
2617
2618 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2619 }
2620
2621 if (rc != 0)
2622 {
2623 // NOTE: clEnqueueFillBuffer () always fails with -59
2624 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2625 // How's that possible, OpenCL 1.2 support is advertised??
2626 // We need to workaround...
2627
2628 #define FILLSZ 0x100000
2629
2630 char *tmp = (char *) mymalloc (FILLSZ);
2631
2632 for (uint i = 0; i < size; i += FILLSZ)
2633 {
2634 const int left = size - i;
2635
2636 const int fillsz = MIN (FILLSZ, left);
2637
2638 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2639 }
2640
2641 myfree (tmp);
2642 }
2643 }
2644
2645 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)
2646 {
2647 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2648 {
2649 if (attack_mode == ATTACK_MODE_BF)
2650 {
2651 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2652 {
2653 const uint size_tm = 32 * sizeof (bs_word_t);
2654
2655 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2656
2657 run_kernel_tm (device_param);
2658
2659 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);
2660 }
2661 }
2662
2663 if (highest_pw_len < 16)
2664 {
2665 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2666 }
2667 else if (highest_pw_len < 32)
2668 {
2669 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2670 }
2671 else
2672 {
2673 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2674 }
2675 }
2676 else
2677 {
2678 run_kernel_amp (device_param, pws_cnt);
2679
2680 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2681
2682 if (opts_type & OPTS_TYPE_HOOK12)
2683 {
2684 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2685 }
2686
2687 uint iter = salt_buf->salt_iter;
2688
2689 uint loop_step = device_param->kernel_loops;
2690
2691 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2692 {
2693 uint loop_left = iter - loop_pos;
2694
2695 loop_left = MIN (loop_left, loop_step);
2696
2697 device_param->kernel_params_buf32[25] = loop_pos;
2698 device_param->kernel_params_buf32[26] = loop_left;
2699
2700 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2701
2702 if (data.devices_status == STATUS_CRACKED) break;
2703 if (data.devices_status == STATUS_ABORTED) break;
2704 if (data.devices_status == STATUS_QUIT) break;
2705 }
2706
2707 if (opts_type & OPTS_TYPE_HOOK23)
2708 {
2709 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2710
2711 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);
2712
2713 // do something with data
2714
2715 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);
2716 }
2717
2718 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2719 }
2720 }
2721
2722 static int run_rule_engine (const int rule_len, const char *rule_buf)
2723 {
2724 if (rule_len == 0)
2725 {
2726 return 0;
2727 }
2728 else if (rule_len == 1)
2729 {
2730 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2731 }
2732
2733 return 1;
2734 }
2735
2736 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2737 {
2738 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2739 {
2740 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);
2741 }
2742 else if (data.attack_kern == ATTACK_KERN_COMBI)
2743 {
2744 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2745 {
2746 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2747 {
2748 for (u32 i = 0; i < pws_cnt; i++)
2749 {
2750 const u32 pw_len = device_param->pws_buf[i].pw_len;
2751
2752 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2753
2754 ptr[pw_len] = 0x01;
2755 }
2756 }
2757 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2758 {
2759 for (u32 i = 0; i < pws_cnt; i++)
2760 {
2761 const u32 pw_len = device_param->pws_buf[i].pw_len;
2762
2763 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2764
2765 ptr[pw_len] = 0x80;
2766 }
2767 }
2768 }
2769
2770 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);
2771 }
2772 else if (data.attack_kern == ATTACK_KERN_BF)
2773 {
2774 const u64 off = device_param->words_off;
2775
2776 device_param->kernel_params_mp_l_buf64[3] = off;
2777
2778 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2779 }
2780 }
2781
2782 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops, const int repeat)
2783 {
2784 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2785
2786 device_param->kernel_params_buf32[26] = kernel_loops;
2787 device_param->kernel_params_buf32[27] = kernel_loops;
2788
2789 // init some fake words
2790
2791 for (u32 i = 0; i < kernel_power; i++)
2792 {
2793 device_param->pws_buf[i].i[0] = i;
2794 device_param->pws_buf[i].i[1] = 0x01234567;
2795 device_param->pws_buf[i].pw_len = 4 + (i & 3);
2796 }
2797
2798 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);
2799
2800 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2801 {
2802 run_kernel_amp (device_param, kernel_power);
2803 }
2804
2805 // caching run
2806
2807 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2808 {
2809 run_kernel (KERN_RUN_1, device_param, kernel_power, false);
2810 }
2811 else
2812 {
2813 run_kernel (KERN_RUN_2, device_param, kernel_power, false);
2814 }
2815
2816 // now user repeats
2817
2818 for (int i = 0; i < repeat; i++)
2819 {
2820 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2821 {
2822 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2823 }
2824 else
2825 {
2826 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2827 }
2828 }
2829
2830 const double exec_ms_prev = get_avg_exec_time (device_param, repeat);
2831
2832 // reset fake words
2833
2834 memset (device_param->pws_buf, 0, kernel_power * sizeof (pw_t));
2835
2836 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);
2837 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);
2838
2839 return exec_ms_prev;
2840 }
2841
2842 static void autotune (hc_device_param_t *device_param)
2843 {
2844 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2845
2846 const u32 kernel_accel_min = device_param->kernel_accel_min;
2847 const u32 kernel_accel_max = device_param->kernel_accel_max;
2848
2849 const u32 kernel_loops_min = device_param->kernel_loops_min;
2850 const u32 kernel_loops_max = device_param->kernel_loops_max;
2851
2852 u32 kernel_accel = kernel_accel_min;
2853 u32 kernel_loops = kernel_loops_min;
2854
2855 // steps
2856
2857 #define STEPS_CNT 10
2858
2859 #define STEPS_ACCEL_CNT (STEPS_CNT + 2)
2860 #define STEPS_LOOPS_CNT (STEPS_CNT + 2)
2861
2862 u32 steps_accel[STEPS_ACCEL_CNT];
2863 u32 steps_loops[STEPS_LOOPS_CNT];
2864
2865 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2866 {
2867 steps_accel[i] = 1 << i;
2868 }
2869
2870 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2871 {
2872 steps_loops[i] = 1 << i;
2873 }
2874
2875 steps_accel[STEPS_CNT + 0] = kernel_accel_min;
2876 steps_accel[STEPS_CNT + 1] = kernel_accel_max;
2877
2878 steps_loops[STEPS_CNT + 0] = kernel_loops_min;
2879 steps_loops[STEPS_CNT + 1] = kernel_loops_max;
2880
2881 qsort (steps_accel, STEPS_ACCEL_CNT, sizeof (u32), sort_by_u32);
2882 qsort (steps_loops, STEPS_LOOPS_CNT, sizeof (u32), sort_by_u32);
2883
2884 // find out highest kernel-loops that stays below target_ms, we can use it later for multiplication as this is a linear function
2885
2886 u32 kernel_loops_tmp;
2887
2888 for (kernel_loops_tmp = kernel_loops_max; kernel_loops_tmp > kernel_loops_min; kernel_loops_tmp >>= 1)
2889 {
2890 const double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops_tmp, 1);
2891
2892 if (exec_ms < target_ms) break;
2893 }
2894
2895 // kernel-accel
2896
2897 if (kernel_accel_min < kernel_accel_max)
2898 {
2899 double e_best = 0;
2900
2901 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2902 {
2903 const u32 kernel_accel_try = steps_accel[i];
2904
2905 if (kernel_accel_try < kernel_accel_min) continue;
2906 if (kernel_accel_try > kernel_accel_max) break;
2907
2908 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_tmp, 1);
2909
2910 if (exec_ms > target_ms) break;
2911
2912 const double e = kernel_accel_try / exec_ms;
2913
2914 if (e > e_best)
2915 {
2916 kernel_accel = kernel_accel_try;
2917
2918 e_best = e;
2919 }
2920 }
2921 }
2922
2923 // kernel-loops final
2924
2925 if (kernel_loops_min < kernel_loops_max)
2926 {
2927 double e_best = 0;
2928
2929 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2930 {
2931 const u32 kernel_loops_try = steps_loops[i];
2932
2933 if (kernel_loops_try < kernel_loops_min) continue;
2934 if (kernel_loops_try > kernel_loops_max) break;
2935
2936 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops_try, 1);
2937
2938 if (exec_ms > target_ms) break;
2939
2940 const double e = kernel_loops_try / exec_ms;
2941
2942 if (e > e_best)
2943 {
2944 kernel_loops = kernel_loops_try;
2945
2946 e_best = e;
2947 }
2948 }
2949 }
2950
2951 // final balance
2952
2953 u32 kernel_accel_best = kernel_accel;
2954 u32 kernel_loops_best = kernel_loops;
2955
2956 u32 exec_best = -1;
2957
2958 if ((kernel_accel_min < kernel_accel_max) || (kernel_loops_min < kernel_loops_max))
2959 {
2960 const double exec_ms = try_run (device_param, kernel_accel_best, kernel_loops_best, 1);
2961
2962 exec_best = exec_ms;
2963 }
2964
2965 // reset
2966
2967 if (kernel_accel_min < kernel_accel_max)
2968 {
2969 u32 kernel_accel_try = kernel_accel;
2970 u32 kernel_loops_try = kernel_loops;
2971
2972 for (int i = 0; i < 2; i++)
2973 {
2974 kernel_accel_try >>= 1;
2975 kernel_loops_try <<= 1;
2976
2977 if (kernel_accel_try < kernel_accel_min) break;
2978 if (kernel_loops_try > kernel_loops_max) break;
2979
2980 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
2981
2982 if (exec_ms < exec_best)
2983 {
2984 kernel_accel_best = kernel_accel_try;
2985 kernel_loops_best = kernel_loops_try;
2986
2987 exec_best = exec_ms;
2988 }
2989 }
2990 }
2991
2992 // reset
2993
2994 if (kernel_loops_min < kernel_loops_max)
2995 {
2996 u32 kernel_accel_try = kernel_accel;
2997 u32 kernel_loops_try = kernel_loops;
2998
2999 for (int i = 0; i < 2; i++)
3000 {
3001 kernel_accel_try <<= 1;
3002 kernel_loops_try >>= 1;
3003
3004 if (kernel_accel_try > kernel_accel_max) break;
3005 if (kernel_loops_try < kernel_loops_min) break;
3006
3007 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
3008
3009 if (exec_ms < exec_best)
3010 {
3011 kernel_accel_best = kernel_accel_try;
3012 kernel_loops_best = kernel_loops_try;
3013
3014 exec_best = exec_ms;
3015 }
3016 }
3017 }
3018
3019 // reset timer
3020
3021 device_param->exec_pos = 0;
3022
3023 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3024
3025 // store
3026
3027 kernel_accel = kernel_accel_best;
3028 kernel_loops = kernel_loops_best;
3029
3030 device_param->kernel_accel = kernel_accel;
3031 device_param->kernel_loops = kernel_loops;
3032
3033 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3034
3035 device_param->kernel_power = kernel_power;
3036
3037 #ifdef DEBUG
3038
3039 if (data.quiet == 0)
3040 {
3041 clear_prompt ();
3042
3043 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3044 "Device #%u: autotuned kernel-loops to %u\n",
3045 device_param->device_id + 1,
3046 kernel_accel,
3047 device_param->device_id + 1,
3048 kernel_loops);
3049
3050 fprintf (stdout, "%s", PROMPT);
3051 fflush (stdout);
3052 }
3053
3054 #endif
3055 }
3056
3057 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3058 {
3059 // init speed timer
3060
3061 uint speed_pos = device_param->speed_pos;
3062
3063 #ifdef _POSIX
3064 if (device_param->timer_speed.tv_sec == 0)
3065 {
3066 hc_timer_set (&device_param->timer_speed);
3067 }
3068 #endif
3069
3070 #ifdef _WIN
3071 if (device_param->timer_speed.QuadPart == 0)
3072 {
3073 hc_timer_set (&device_param->timer_speed);
3074 }
3075 #endif
3076
3077 // find higest password length, this is for optimization stuff
3078
3079 uint highest_pw_len = 0;
3080
3081 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3082 {
3083 }
3084 else if (data.attack_kern == ATTACK_KERN_COMBI)
3085 {
3086 }
3087 else if (data.attack_kern == ATTACK_KERN_BF)
3088 {
3089 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3090 + device_param->kernel_params_mp_l_buf32[5];
3091 }
3092
3093 // iteration type
3094
3095 uint innerloop_step = 0;
3096 uint innerloop_cnt = 0;
3097
3098 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3099 else innerloop_step = 1;
3100
3101 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3102 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3103 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3104
3105 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3106
3107 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3108 {
3109 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3110
3111 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3112
3113 if (data.devices_status == STATUS_CRACKED) break;
3114 if (data.devices_status == STATUS_ABORTED) break;
3115 if (data.devices_status == STATUS_QUIT) break;
3116 if (data.devices_status == STATUS_BYPASS) break;
3117
3118 salt_t *salt_buf = &data.salts_buf[salt_pos];
3119
3120 device_param->kernel_params_buf32[24] = salt_pos;
3121 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3122 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3123
3124 FILE *combs_fp = device_param->combs_fp;
3125
3126 if (data.attack_mode == ATTACK_MODE_COMBI)
3127 {
3128 rewind (combs_fp);
3129 }
3130
3131 // innerloops
3132
3133 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3134 {
3135 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3136
3137 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3138
3139 if (data.devices_status == STATUS_CRACKED) break;
3140 if (data.devices_status == STATUS_ABORTED) break;
3141 if (data.devices_status == STATUS_QUIT) break;
3142 if (data.devices_status == STATUS_BYPASS) break;
3143
3144 uint innerloop_left = innerloop_cnt - innerloop_pos;
3145
3146 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3147
3148 device_param->innerloop_pos = innerloop_pos;
3149 device_param->innerloop_left = innerloop_left;
3150
3151 device_param->kernel_params_buf32[27] = innerloop_left;
3152
3153 // i think we can get rid of this
3154 if (innerloop_left == 0)
3155 {
3156 puts ("bug, how should this happen????\n");
3157
3158 continue;
3159 }
3160
3161 if (data.salts_shown[salt_pos] == 1)
3162 {
3163 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3164
3165 continue;
3166 }
3167
3168 // initialize amplifiers
3169
3170 if (data.attack_mode == ATTACK_MODE_COMBI)
3171 {
3172 char line_buf[BUFSIZ] = { 0 };
3173
3174 uint i = 0;
3175
3176 while (i < innerloop_left)
3177 {
3178 if (feof (combs_fp)) break;
3179
3180 int line_len = fgetl (combs_fp, line_buf);
3181
3182 if (line_len >= PW_MAX1) continue;
3183
3184 line_len = convert_from_hex (line_buf, line_len);
3185
3186 char *line_buf_new = line_buf;
3187
3188 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3189 {
3190 char rule_buf_out[BLOCK_SIZE] = { 0 };
3191
3192 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3193
3194 if (rule_len_out < 0)
3195 {
3196 data.words_progress_rejected[salt_pos] += pws_cnt;
3197
3198 continue;
3199 }
3200
3201 line_len = rule_len_out;
3202
3203 line_buf_new = rule_buf_out;
3204 }
3205
3206 line_len = MIN (line_len, PW_DICTMAX);
3207
3208 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3209
3210 memcpy (ptr, line_buf_new, line_len);
3211
3212 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3213
3214 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3215 {
3216 uppercase (ptr, line_len);
3217 }
3218
3219 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3220 {
3221 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3222 {
3223 ptr[line_len] = 0x80;
3224 }
3225
3226 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3227 {
3228 ptr[line_len] = 0x01;
3229 }
3230 }
3231
3232 device_param->combs_buf[i].pw_len = line_len;
3233
3234 i++;
3235 }
3236
3237 for (uint j = i; j < innerloop_left; j++)
3238 {
3239 device_param->combs_buf[j].i[0] = 0;
3240 device_param->combs_buf[j].i[1] = 0;
3241 device_param->combs_buf[j].i[2] = 0;
3242 device_param->combs_buf[j].i[3] = 0;
3243 device_param->combs_buf[j].i[4] = 0;
3244 device_param->combs_buf[j].i[5] = 0;
3245 device_param->combs_buf[j].i[6] = 0;
3246 device_param->combs_buf[j].i[7] = 0;
3247
3248 device_param->combs_buf[j].pw_len = 0;
3249 }
3250
3251 innerloop_left = i;
3252 }
3253 else if (data.attack_mode == ATTACK_MODE_BF)
3254 {
3255 u64 off = innerloop_pos;
3256
3257 device_param->kernel_params_mp_r_buf64[3] = off;
3258
3259 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3260 }
3261 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3262 {
3263 u64 off = innerloop_pos;
3264
3265 device_param->kernel_params_mp_buf64[3] = off;
3266
3267 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3268 }
3269 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3270 {
3271 u64 off = innerloop_pos;
3272
3273 device_param->kernel_params_mp_buf64[3] = off;
3274
3275 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3276 }
3277
3278 // copy amplifiers
3279
3280 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3281 {
3282 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);
3283 }
3284 else if (data.attack_mode == ATTACK_MODE_COMBI)
3285 {
3286 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);
3287 }
3288 else if (data.attack_mode == ATTACK_MODE_BF)
3289 {
3290 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);
3291 }
3292 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3293 {
3294 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);
3295 }
3296 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3297 {
3298 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);
3299 }
3300
3301 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3302
3303 if (data.benchmark == 1)
3304 {
3305 for (u32 i = 0; i < data.benchmark_repeats; i++)
3306 {
3307 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3308 }
3309 }
3310
3311 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3312
3313 if (data.devices_status == STATUS_CRACKED) break;
3314 if (data.devices_status == STATUS_ABORTED) break;
3315 if (data.devices_status == STATUS_QUIT) break;
3316
3317 /**
3318 * result
3319 */
3320
3321 hc_thread_mutex_lock (mux_display);
3322
3323 check_cracked (device_param, salt_pos);
3324
3325 hc_thread_mutex_unlock (mux_display);
3326
3327 /**
3328 * progress
3329 */
3330
3331 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3332
3333 if (data.benchmark == 1)
3334 {
3335 perf_sum_all = (perf_sum_all * data.benchmark_repeats) + perf_sum_all;
3336 }
3337
3338 hc_thread_mutex_lock (mux_counter);
3339
3340 data.words_progress_done[salt_pos] += perf_sum_all;
3341
3342 hc_thread_mutex_unlock (mux_counter);
3343
3344 /**
3345 * speed
3346 */
3347
3348 float speed_ms;
3349
3350 hc_timer_get (device_param->timer_speed, speed_ms);
3351
3352 hc_timer_set (&device_param->timer_speed);
3353
3354 hc_thread_mutex_lock (mux_display);
3355
3356 device_param->speed_cnt[speed_pos] = perf_sum_all;
3357
3358 device_param->speed_ms[speed_pos] = speed_ms;
3359
3360 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3361
3362 hc_thread_mutex_unlock (mux_display);
3363
3364 speed_pos++;
3365
3366 if (speed_pos == SPEED_CACHE)
3367 {
3368 speed_pos = 0;
3369 }
3370
3371 /**
3372 * benchmark
3373 */
3374
3375 if (data.benchmark == 1) break;
3376 }
3377 }
3378
3379 device_param->speed_pos = speed_pos;
3380 }
3381
3382 static void load_segment (wl_data_t *wl_data, FILE *fd)
3383 {
3384 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3385
3386 wl_data->pos = 0;
3387
3388 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3389
3390 wl_data->buf[wl_data->cnt] = 0;
3391
3392 if (wl_data->cnt == 0) return;
3393
3394 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3395
3396 while (!feof (fd))
3397 {
3398 if (wl_data->cnt == wl_data->avail)
3399 {
3400 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3401
3402 wl_data->avail += wl_data->incr;
3403 }
3404
3405 const int c = fgetc (fd);
3406
3407 if (c == EOF) break;
3408
3409 wl_data->buf[wl_data->cnt] = (char) c;
3410
3411 wl_data->cnt++;
3412
3413 if (c == '\n') break;
3414 }
3415
3416 // ensure stream ends with a newline
3417
3418 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3419 {
3420 wl_data->cnt++;
3421
3422 wl_data->buf[wl_data->cnt - 1] = '\n';
3423 }
3424
3425 return;
3426 }
3427
3428 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3429 {
3430 char *ptr = buf;
3431
3432 for (u32 i = 0; i < sz; i++, ptr++)
3433 {
3434 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3435
3436 if (i == 7)
3437 {
3438 *off = i;
3439 *len = i;
3440
3441 return;
3442 }
3443
3444 if (*ptr != '\n') continue;
3445
3446 *off = i + 1;
3447
3448 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3449
3450 *len = i;
3451
3452 return;
3453 }
3454
3455 *off = sz;
3456 *len = sz;
3457 }
3458
3459 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3460 {
3461 char *ptr = buf;
3462
3463 for (u32 i = 0; i < sz; i++, ptr++)
3464 {
3465 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3466
3467 if (*ptr != '\n') continue;
3468
3469 *off = i + 1;
3470
3471 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3472
3473 *len = i;
3474
3475 return;
3476 }
3477
3478 *off = sz;
3479 *len = sz;
3480 }
3481
3482 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3483 {
3484 char *ptr = buf;
3485
3486 for (u32 i = 0; i < sz; i++, ptr++)
3487 {
3488 if (*ptr != '\n') continue;
3489
3490 *off = i + 1;
3491
3492 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3493
3494 *len = i;
3495
3496 return;
3497 }
3498
3499 *off = sz;
3500 *len = sz;
3501 }
3502
3503 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3504 {
3505 while (wl_data->pos < wl_data->cnt)
3506 {
3507 uint off;
3508 uint len;
3509
3510 char *ptr = wl_data->buf + wl_data->pos;
3511
3512 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3513
3514 wl_data->pos += off;
3515
3516 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3517 {
3518 char rule_buf_out[BLOCK_SIZE] = { 0 };
3519
3520 int rule_len_out = -1;
3521
3522 if (len < BLOCK_SIZE)
3523 {
3524 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3525 }
3526
3527 if (rule_len_out < 0)
3528 {
3529 continue;
3530 }
3531
3532 if (rule_len_out > PW_MAX)
3533 {
3534 continue;
3535 }
3536 }
3537 else
3538 {
3539 if (len > PW_MAX)
3540 {
3541 continue;
3542 }
3543 }
3544
3545 *out_buf = ptr;
3546 *out_len = len;
3547
3548 return;
3549 }
3550
3551 if (feof (fd))
3552 {
3553 fprintf (stderr, "BUG feof()!!\n");
3554
3555 return;
3556 }
3557
3558 load_segment (wl_data, fd);
3559
3560 get_next_word (wl_data, fd, out_buf, out_len);
3561 }
3562
3563 #ifdef _POSIX
3564 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3565 #endif
3566
3567 #ifdef _WIN
3568 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3569 #endif
3570 {
3571 hc_signal (NULL);
3572
3573 dictstat_t d;
3574
3575 d.cnt = 0;
3576
3577 #ifdef _POSIX
3578 fstat (fileno (fd), &d.stat);
3579 #endif
3580
3581 #ifdef _WIN
3582 _fstat64 (fileno (fd), &d.stat);
3583 #endif
3584
3585 d.stat.st_mode = 0;
3586 d.stat.st_nlink = 0;
3587 d.stat.st_uid = 0;
3588 d.stat.st_gid = 0;
3589 d.stat.st_rdev = 0;
3590 d.stat.st_atime = 0;
3591
3592 #ifdef _POSIX
3593 d.stat.st_blksize = 0;
3594 d.stat.st_blocks = 0;
3595 #endif
3596
3597 if (d.stat.st_size == 0) return 0;
3598
3599 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3600
3601 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3602 {
3603 if (d_cache)
3604 {
3605 u64 cnt = d_cache->cnt;
3606
3607 u64 keyspace = cnt;
3608
3609 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3610 {
3611 keyspace *= data.kernel_rules_cnt;
3612 }
3613 else if (data.attack_kern == ATTACK_KERN_COMBI)
3614 {
3615 keyspace *= data.combs_cnt;
3616 }
3617
3618 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);
3619 if (data.quiet == 0) log_info ("");
3620
3621 hc_signal (sigHandler_default);
3622
3623 return (keyspace);
3624 }
3625 }
3626
3627 time_t now = 0;
3628 time_t prev = 0;
3629
3630 u64 comp = 0;
3631 u64 cnt = 0;
3632 u64 cnt2 = 0;
3633
3634 while (!feof (fd))
3635 {
3636 load_segment (wl_data, fd);
3637
3638 comp += wl_data->cnt;
3639
3640 u32 i = 0;
3641
3642 while (i < wl_data->cnt)
3643 {
3644 u32 len;
3645 u32 off;
3646
3647 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3648
3649 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3650 {
3651 char rule_buf_out[BLOCK_SIZE] = { 0 };
3652
3653 int rule_len_out = -1;
3654
3655 if (len < BLOCK_SIZE)
3656 {
3657 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3658 }
3659
3660 if (rule_len_out < 0)
3661 {
3662 len = PW_MAX1;
3663 }
3664 else
3665 {
3666 len = rule_len_out;
3667 }
3668 }
3669
3670 if (len < PW_MAX1)
3671 {
3672 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3673 {
3674 cnt += data.kernel_rules_cnt;
3675 }
3676 else if (data.attack_kern == ATTACK_KERN_COMBI)
3677 {
3678 cnt += data.combs_cnt;
3679 }
3680
3681 d.cnt++;
3682 }
3683
3684 i += off;
3685
3686 cnt2++;
3687 }
3688
3689 time (&now);
3690
3691 if ((now - prev) == 0) continue;
3692
3693 float percent = (float) comp / (float) d.stat.st_size;
3694
3695 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);
3696
3697 time (&prev);
3698 }
3699
3700 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);
3701 if (data.quiet == 0) log_info ("");
3702
3703 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3704
3705 hc_signal (sigHandler_default);
3706
3707 return (cnt);
3708 }
3709
3710 static void *thread_monitor (void *p)
3711 {
3712 uint runtime_check = 0;
3713 uint remove_check = 0;
3714 uint status_check = 0;
3715 uint restore_check = 0;
3716
3717 uint restore_left = data.restore_timer;
3718 uint remove_left = data.remove_timer;
3719 uint status_left = data.status_timer;
3720
3721 #ifdef HAVE_HWMON
3722 uint hwmon_check = 0;
3723
3724 // these variables are mainly used for fan control (AMD only)
3725
3726 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3727
3728 // temperature controller "loopback" values
3729
3730 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3731 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3732
3733 #ifdef HAVE_ADL
3734 int temp_threshold = 1; // degrees celcius
3735
3736 int fan_speed_min = 15; // in percentage
3737 int fan_speed_max = 100;
3738 #endif // HAVE_ADL
3739
3740 time_t last_temp_check_time;
3741 #endif // HAVE_HWMON
3742
3743 uint sleep_time = 1;
3744
3745 if (data.runtime)
3746 {
3747 runtime_check = 1;
3748 }
3749
3750 if (data.restore_timer)
3751 {
3752 restore_check = 1;
3753 }
3754
3755 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3756 {
3757 remove_check = 1;
3758 }
3759
3760 if (data.status == 1)
3761 {
3762 status_check = 1;
3763 }
3764
3765 #ifdef HAVE_HWMON
3766 if (data.gpu_temp_disable == 0)
3767 {
3768 time (&last_temp_check_time);
3769
3770 hwmon_check = 1;
3771 }
3772 #endif
3773
3774 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3775 {
3776 #ifdef HAVE_HWMON
3777 if (hwmon_check == 0)
3778 #endif
3779 return (p);
3780 }
3781
3782 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3783 {
3784 hc_sleep (sleep_time);
3785
3786 if (data.devices_status != STATUS_RUNNING) continue;
3787
3788 #ifdef HAVE_HWMON
3789 if (hwmon_check == 1)
3790 {
3791 hc_thread_mutex_lock (mux_adl);
3792
3793 time_t temp_check_time;
3794
3795 time (&temp_check_time);
3796
3797 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3798
3799 if (Ta == 0) Ta = 1;
3800
3801 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3802 {
3803 hc_device_param_t *device_param = &data.devices_param[device_id];
3804
3805 if (device_param->skipped) continue;
3806
3807 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3808
3809 const int temperature = hm_get_temperature_with_device_id (device_id);
3810
3811 if (temperature > (int) data.gpu_temp_abort)
3812 {
3813 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3814
3815 if (data.devices_status != STATUS_QUIT) myabort ();
3816
3817 break;
3818 }
3819
3820 #ifdef HAVE_ADL
3821 const int gpu_temp_retain = data.gpu_temp_retain;
3822
3823 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3824 {
3825 if (data.hm_device[device_id].fan_supported == 1)
3826 {
3827 int temp_cur = temperature;
3828
3829 int temp_diff_new = gpu_temp_retain - temp_cur;
3830
3831 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3832
3833 // calculate Ta value (time difference in seconds between the last check and this check)
3834
3835 last_temp_check_time = temp_check_time;
3836
3837 float Kp = 1.8;
3838 float Ki = 0.005;
3839 float Kd = 6;
3840
3841 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3842
3843 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);
3844
3845 if (abs (fan_diff_required) >= temp_threshold)
3846 {
3847 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3848
3849 int fan_speed_level = fan_speed_cur;
3850
3851 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3852
3853 int fan_speed_new = fan_speed_level - fan_diff_required;
3854
3855 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3856 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3857
3858 if (fan_speed_new != fan_speed_cur)
3859 {
3860 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3861 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3862
3863 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3864 {
3865 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3866
3867 fan_speed_chgd[device_id] = 1;
3868 }
3869
3870 temp_diff_old[device_id] = temp_diff_new;
3871 }
3872 }
3873 }
3874 }
3875 #endif // HAVE_ADL
3876 }
3877
3878 hc_thread_mutex_unlock (mux_adl);
3879 }
3880 #endif // HAVE_HWMON
3881
3882 if (restore_check == 1)
3883 {
3884 restore_left--;
3885
3886 if (restore_left == 0)
3887 {
3888 if (data.restore_disable == 0) cycle_restore ();
3889
3890 restore_left = data.restore_timer;
3891 }
3892 }
3893
3894 if ((runtime_check == 1) && (data.runtime_start > 0))
3895 {
3896 time_t runtime_cur;
3897
3898 time (&runtime_cur);
3899
3900 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3901
3902 if (runtime_left <= 0)
3903 {
3904 if (data.benchmark == 0)
3905 {
3906 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3907 }
3908
3909 if (data.devices_status != STATUS_QUIT) myabort ();
3910 }
3911 }
3912
3913 if (remove_check == 1)
3914 {
3915 remove_left--;
3916
3917 if (remove_left == 0)
3918 {
3919 if (data.digests_saved != data.digests_done)
3920 {
3921 data.digests_saved = data.digests_done;
3922
3923 save_hash ();
3924 }
3925
3926 remove_left = data.remove_timer;
3927 }
3928 }
3929
3930 if (status_check == 1)
3931 {
3932 status_left--;
3933
3934 if (status_left == 0)
3935 {
3936 hc_thread_mutex_lock (mux_display);
3937
3938 if (data.quiet == 0) clear_prompt ();
3939
3940 if (data.quiet == 0) log_info ("");
3941
3942 status_display ();
3943
3944 if (data.quiet == 0) log_info ("");
3945
3946 hc_thread_mutex_unlock (mux_display);
3947
3948 status_left = data.status_timer;
3949 }
3950 }
3951 }
3952
3953 #ifdef HAVE_HWMON
3954 myfree (fan_speed_chgd);
3955
3956 myfree (temp_diff_old);
3957 myfree (temp_diff_sum);
3958 #endif
3959
3960 p = NULL;
3961
3962 return (p);
3963 }
3964
3965 static void *thread_outfile_remove (void *p)
3966 {
3967 // some hash-dependent constants
3968 char *outfile_dir = data.outfile_check_directory;
3969 uint dgst_size = data.dgst_size;
3970 uint isSalted = data.isSalted;
3971 uint esalt_size = data.esalt_size;
3972 uint hash_mode = data.hash_mode;
3973
3974 uint outfile_check_timer = data.outfile_check_timer;
3975
3976 char separator = data.separator;
3977
3978 // some hash-dependent functions
3979 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3980 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3981
3982 // buffers
3983 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3984
3985 hash_buf.digest = mymalloc (dgst_size);
3986
3987 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3988
3989 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3990
3991 uint digest_buf[64] = { 0 };
3992
3993 outfile_data_t *out_info = NULL;
3994
3995 char **out_files = NULL;
3996
3997 time_t folder_mtime = 0;
3998
3999 int out_cnt = 0;
4000
4001 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4002
4003 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4004 {
4005 hc_sleep (1);
4006
4007 if (data.devices_status != STATUS_RUNNING) continue;
4008
4009 check_left--;
4010
4011 if (check_left == 0)
4012 {
4013 struct stat outfile_check_stat;
4014
4015 if (stat (outfile_dir, &outfile_check_stat) == 0)
4016 {
4017 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4018
4019 if (is_dir == 1)
4020 {
4021 if (outfile_check_stat.st_mtime > folder_mtime)
4022 {
4023 char **out_files_new = scan_directory (outfile_dir);
4024
4025 int out_cnt_new = count_dictionaries (out_files_new);
4026
4027 outfile_data_t *out_info_new = NULL;
4028
4029 if (out_cnt_new > 0)
4030 {
4031 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4032
4033 for (int i = 0; i < out_cnt_new; i++)
4034 {
4035 out_info_new[i].file_name = out_files_new[i];
4036
4037 // check if there are files that we have seen/checked before (and not changed)
4038
4039 for (int j = 0; j < out_cnt; j++)
4040 {
4041 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4042 {
4043 struct stat outfile_stat;
4044
4045 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4046 {
4047 if (outfile_stat.st_ctime == out_info[j].ctime)
4048 {
4049 out_info_new[i].ctime = out_info[j].ctime;
4050 out_info_new[i].seek = out_info[j].seek;
4051 }
4052 }
4053 }
4054 }
4055 }
4056 }
4057
4058 local_free (out_info);
4059 local_free (out_files);
4060
4061 out_files = out_files_new;
4062 out_cnt = out_cnt_new;
4063 out_info = out_info_new;
4064
4065 folder_mtime = outfile_check_stat.st_mtime;
4066 }
4067
4068 for (int j = 0; j < out_cnt; j++)
4069 {
4070 FILE *fp = fopen (out_info[j].file_name, "rb");
4071
4072 if (fp != NULL)
4073 {
4074 //hc_thread_mutex_lock (mux_display);
4075
4076 #ifdef _POSIX
4077 struct stat outfile_stat;
4078
4079 fstat (fileno (fp), &outfile_stat);
4080 #endif
4081
4082 #ifdef _WIN
4083 struct stat64 outfile_stat;
4084
4085 _fstat64 (fileno (fp), &outfile_stat);
4086 #endif
4087
4088 if (outfile_stat.st_ctime > out_info[j].ctime)
4089 {
4090 out_info[j].ctime = outfile_stat.st_ctime;
4091 out_info[j].seek = 0;
4092 }
4093
4094 fseek (fp, out_info[j].seek, SEEK_SET);
4095
4096 while (!feof (fp))
4097 {
4098 char line_buf[BUFSIZ] = { 0 };
4099
4100 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
4101
4102 if (ptr == NULL) break;
4103
4104 int line_len = strlen (line_buf);
4105
4106 if (line_len <= 0) continue;
4107
4108 int iter = MAX_CUT_TRIES;
4109
4110 for (uint i = line_len - 1; i && iter; i--, line_len--)
4111 {
4112 if (line_buf[i] != separator) continue;
4113
4114 int parser_status = PARSER_OK;
4115
4116 if ((hash_mode != 2500) && (hash_mode != 6800))
4117 {
4118 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4119 }
4120
4121 uint found = 0;
4122
4123 if (parser_status == PARSER_OK)
4124 {
4125 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4126 {
4127 if (data.salts_shown[salt_pos] == 1) continue;
4128
4129 salt_t *salt_buf = &data.salts_buf[salt_pos];
4130
4131 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4132 {
4133 uint idx = salt_buf->digests_offset + digest_pos;
4134
4135 if (data.digests_shown[idx] == 1) continue;
4136
4137 uint cracked = 0;
4138
4139 if (hash_mode == 6800)
4140 {
4141 if (i == salt_buf->salt_len)
4142 {
4143 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4144 }
4145 }
4146 else if (hash_mode == 2500)
4147 {
4148 // BSSID : MAC1 : MAC2 (:plain)
4149 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4150 {
4151 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4152
4153 if (!cracked) continue;
4154
4155 // now compare MAC1 and MAC2 too, since we have this additional info
4156 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4157 char *mac2_pos = mac1_pos + 12 + 1;
4158
4159 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4160 wpa_t *wpa = &wpas[salt_pos];
4161
4162 uint pke[25] = { 0 };
4163
4164 char *pke_ptr = (char *) pke;
4165
4166 for (uint i = 0; i < 25; i++)
4167 {
4168 pke[i] = byte_swap_32 (wpa->pke[i]);
4169 }
4170
4171 u8 mac1[6] = { 0 };
4172 u8 mac2[6] = { 0 };
4173
4174 memcpy (mac1, pke_ptr + 23, 6);
4175 memcpy (mac2, pke_ptr + 29, 6);
4176
4177 // compare hex string(s) vs binary MAC address(es)
4178
4179 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4180 {
4181 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4182 {
4183 cracked = 0;
4184 break;
4185 }
4186 }
4187
4188 // early skip ;)
4189 if (!cracked) continue;
4190
4191 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4192 {
4193 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4194 {
4195 cracked = 0;
4196 break;
4197 }
4198 }
4199 }
4200 }
4201 else
4202 {
4203 char *digests_buf_ptr = (char *) data.digests_buf;
4204
4205 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4206
4207 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4208 }
4209
4210 if (cracked == 1)
4211 {
4212 found = 1;
4213
4214 data.digests_shown[idx] = 1;
4215
4216 data.digests_done++;
4217
4218 salt_buf->digests_done++;
4219
4220 if (salt_buf->digests_done == salt_buf->digests_cnt)
4221 {
4222 data.salts_shown[salt_pos] = 1;
4223
4224 data.salts_done++;
4225
4226 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4227 }
4228 }
4229 }
4230
4231 if (data.devices_status == STATUS_CRACKED) break;
4232 }
4233 }
4234
4235 if (found) break;
4236
4237 if (data.devices_status == STATUS_CRACKED) break;
4238
4239 iter--;
4240 }
4241
4242 if (data.devices_status == STATUS_CRACKED) break;
4243 }
4244
4245 out_info[j].seek = ftell (fp);
4246
4247 //hc_thread_mutex_unlock (mux_display);
4248
4249 fclose (fp);
4250 }
4251 }
4252 }
4253 }
4254
4255 check_left = outfile_check_timer;
4256 }
4257 }
4258
4259 if (esalt_size) local_free (hash_buf.esalt);
4260
4261 if (isSalted) local_free (hash_buf.salt);
4262
4263 local_free (hash_buf.digest);
4264
4265 local_free (out_info);
4266
4267 local_free (out_files);
4268
4269 p = NULL;
4270
4271 return (p);
4272 }
4273
4274 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4275 {
4276 if (device_param->pws_cnt < device_param->kernel_power)
4277 {
4278 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4279
4280 u8 *ptr = (u8 *) pw->i;
4281
4282 memcpy (ptr, pw_buf, pw_len);
4283
4284 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4285
4286 pw->pw_len = pw_len;
4287
4288 device_param->pws_cnt++;
4289 }
4290 else
4291 {
4292 fprintf (stderr, "BUG pw_add()!!\n");
4293
4294 return;
4295 }
4296 }
4297
4298 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4299 {
4300 hc_thread_mutex_lock (mux_dispatcher);
4301
4302 const u64 words_cur = data.words_cur;
4303 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4304
4305 device_param->words_off = words_cur;
4306
4307 const u64 words_left = words_base - words_cur;
4308
4309 if (allow_div)
4310 {
4311 if (data.kernel_power_all > words_left)
4312 {
4313 if (data.kernel_power_div == 0)
4314 {
4315 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4316 }
4317 }
4318
4319 if (data.kernel_power_div)
4320 {
4321 if (device_param->kernel_power == device_param->kernel_power_user)
4322 {
4323 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4324
4325 if (kernel_power_new < device_param->kernel_power)
4326 {
4327 device_param->kernel_power = kernel_power_new;
4328 }
4329 }
4330 }
4331 }
4332
4333 const uint kernel_power = device_param->kernel_power;
4334
4335 uint work = MIN (words_left, kernel_power);
4336
4337 work = MIN (work, max);
4338
4339 data.words_cur += work;
4340
4341 hc_thread_mutex_unlock (mux_dispatcher);
4342
4343 return work;
4344 }
4345
4346 static void *thread_calc_stdin (void *p)
4347 {
4348 hc_device_param_t *device_param = (hc_device_param_t *) p;
4349
4350 if (device_param->skipped) return NULL;
4351
4352 autotune (device_param);
4353
4354 const uint attack_kern = data.attack_kern;
4355
4356 const uint kernel_power = device_param->kernel_power;
4357
4358 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4359 {
4360 hc_thread_mutex_lock (mux_dispatcher);
4361
4362 if (feof (stdin) != 0)
4363 {
4364 hc_thread_mutex_unlock (mux_dispatcher);
4365
4366 break;
4367 }
4368
4369 uint words_cur = 0;
4370
4371 while (words_cur < kernel_power)
4372 {
4373 char buf[BUFSIZ] = { 0 };
4374
4375 char *line_buf = fgets (buf, sizeof (buf), stdin);
4376
4377 if (line_buf == NULL) break;
4378
4379 uint line_len = in_superchop (line_buf);
4380
4381 line_len = convert_from_hex (line_buf, line_len);
4382
4383 // post-process rule engine
4384
4385 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4386 {
4387 char rule_buf_out[BLOCK_SIZE] = { 0 };
4388
4389 int rule_len_out = -1;
4390
4391 if (line_len < BLOCK_SIZE)
4392 {
4393 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4394 }
4395
4396 if (rule_len_out < 0) continue;
4397
4398 line_buf = rule_buf_out;
4399 line_len = rule_len_out;
4400 }
4401
4402 if (line_len > PW_MAX)
4403 {
4404 continue;
4405 }
4406
4407 if (attack_kern == ATTACK_KERN_STRAIGHT)
4408 {
4409 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4410 {
4411 hc_thread_mutex_lock (mux_counter);
4412
4413 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4414 {
4415 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4416 }
4417
4418 hc_thread_mutex_unlock (mux_counter);
4419
4420 continue;
4421 }
4422 }
4423 else if (attack_kern == ATTACK_KERN_COMBI)
4424 {
4425 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4426 // since we still need to combine the plains
4427
4428 if (line_len > data.pw_max)
4429 {
4430 hc_thread_mutex_lock (mux_counter);
4431
4432 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4433 {
4434 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4435 }
4436
4437 hc_thread_mutex_unlock (mux_counter);
4438
4439 continue;
4440 }
4441 }
4442
4443 pw_add (device_param, (u8 *) line_buf, line_len);
4444
4445 words_cur++;
4446
4447 if (data.devices_status == STATUS_CRACKED) break;
4448 if (data.devices_status == STATUS_ABORTED) break;
4449 if (data.devices_status == STATUS_QUIT) break;
4450 if (data.devices_status == STATUS_BYPASS) break;
4451 }
4452
4453 hc_thread_mutex_unlock (mux_dispatcher);
4454
4455 if (data.devices_status == STATUS_CRACKED) break;
4456 if (data.devices_status == STATUS_ABORTED) break;
4457 if (data.devices_status == STATUS_QUIT) break;
4458 if (data.devices_status == STATUS_BYPASS) break;
4459
4460 // flush
4461
4462 const uint pws_cnt = device_param->pws_cnt;
4463
4464 if (pws_cnt)
4465 {
4466 run_copy (device_param, pws_cnt);
4467
4468 run_cracker (device_param, pws_cnt);
4469
4470 device_param->pws_cnt = 0;
4471
4472 if (attack_kern == ATTACK_KERN_STRAIGHT)
4473 {
4474 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4475 }
4476 else if (attack_kern == ATTACK_KERN_COMBI)
4477 {
4478 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4479 }
4480 }
4481 }
4482
4483 device_param->kernel_accel = 0;
4484 device_param->kernel_loops = 0;
4485
4486 return NULL;
4487 }
4488
4489 static void *thread_calc (void *p)
4490 {
4491 hc_device_param_t *device_param = (hc_device_param_t *) p;
4492
4493 if (device_param->skipped) return NULL;
4494
4495 autotune (device_param);
4496
4497 const uint attack_mode = data.attack_mode;
4498 const uint attack_kern = data.attack_kern;
4499
4500 if (attack_mode == ATTACK_MODE_BF)
4501 {
4502 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4503 {
4504 const uint work = get_work (device_param, -1, true);
4505
4506 if (work == 0) break;
4507
4508 const u64 words_off = device_param->words_off;
4509 const u64 words_fin = words_off + work;
4510
4511 const uint pws_cnt = work;
4512
4513 device_param->pws_cnt = pws_cnt;
4514
4515 if (pws_cnt)
4516 {
4517 run_copy (device_param, pws_cnt);
4518
4519 run_cracker (device_param, pws_cnt);
4520
4521 device_param->pws_cnt = 0;
4522
4523 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4524 }
4525
4526 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4527
4528 if (data.devices_status == STATUS_CRACKED) break;
4529 if (data.devices_status == STATUS_ABORTED) break;
4530 if (data.devices_status == STATUS_QUIT) break;
4531 if (data.devices_status == STATUS_BYPASS) break;
4532
4533 if (data.benchmark == 1) break;
4534
4535 device_param->words_done = words_fin;
4536 }
4537 }
4538 else
4539 {
4540 const uint segment_size = data.segment_size;
4541
4542 char *dictfile = data.dictfile;
4543
4544 if (attack_mode == ATTACK_MODE_COMBI)
4545 {
4546 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4547 {
4548 dictfile = data.dictfile2;
4549 }
4550 }
4551
4552 FILE *fd = fopen (dictfile, "rb");
4553
4554 if (fd == NULL)
4555 {
4556 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4557
4558 return NULL;
4559 }
4560
4561 if (attack_mode == ATTACK_MODE_COMBI)
4562 {
4563 const uint combs_mode = data.combs_mode;
4564
4565 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4566 {
4567 const char *dictfilec = data.dictfile2;
4568
4569 FILE *combs_fp = fopen (dictfilec, "rb");
4570
4571 if (combs_fp == NULL)
4572 {
4573 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4574
4575 fclose (fd);
4576
4577 return NULL;
4578 }
4579
4580 device_param->combs_fp = combs_fp;
4581 }
4582 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4583 {
4584 const char *dictfilec = data.dictfile;
4585
4586 FILE *combs_fp = fopen (dictfilec, "rb");
4587
4588 if (combs_fp == NULL)
4589 {
4590 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4591
4592 fclose (fd);
4593
4594 return NULL;
4595 }
4596
4597 device_param->combs_fp = combs_fp;
4598 }
4599 }
4600
4601 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4602
4603 wl_data->buf = (char *) mymalloc (segment_size);
4604 wl_data->avail = segment_size;
4605 wl_data->incr = segment_size;
4606 wl_data->cnt = 0;
4607 wl_data->pos = 0;
4608
4609 u64 words_cur = 0;
4610
4611 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4612 {
4613 u64 words_off = 0;
4614 u64 words_fin = 0;
4615
4616 bool allow_div = true;
4617
4618 u64 max = -1;
4619
4620 while (max)
4621 {
4622 const uint work = get_work (device_param, max, allow_div);
4623
4624 allow_div = false;
4625
4626 if (work == 0) break;
4627
4628 words_off = device_param->words_off;
4629 words_fin = words_off + work;
4630
4631 char *line_buf;
4632 uint line_len;
4633
4634 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4635
4636 max = 0;
4637
4638 for ( ; words_cur < words_fin; words_cur++)
4639 {
4640 get_next_word (wl_data, fd, &line_buf, &line_len);
4641
4642 line_len = convert_from_hex (line_buf, line_len);
4643
4644 // post-process rule engine
4645
4646 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4647 {
4648 char rule_buf_out[BLOCK_SIZE] = { 0 };
4649
4650 int rule_len_out = -1;
4651
4652 if (line_len < BLOCK_SIZE)
4653 {
4654 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4655 }
4656
4657 if (rule_len_out < 0) continue;
4658
4659 line_buf = rule_buf_out;
4660 line_len = rule_len_out;
4661 }
4662
4663 if (attack_kern == ATTACK_KERN_STRAIGHT)
4664 {
4665 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4666 {
4667 max++;
4668
4669 hc_thread_mutex_lock (mux_counter);
4670
4671 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4672 {
4673 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4674 }
4675
4676 hc_thread_mutex_unlock (mux_counter);
4677
4678 continue;
4679 }
4680 }
4681 else if (attack_kern == ATTACK_KERN_COMBI)
4682 {
4683 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4684 // since we still need to combine the plains
4685
4686 if (line_len > data.pw_max)
4687 {
4688 max++;
4689
4690 hc_thread_mutex_lock (mux_counter);
4691
4692 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4693 {
4694 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4695 }
4696
4697 hc_thread_mutex_unlock (mux_counter);
4698
4699 continue;
4700 }
4701 }
4702
4703 pw_add (device_param, (u8 *) line_buf, line_len);
4704
4705 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4706
4707 if (data.devices_status == STATUS_CRACKED) break;
4708 if (data.devices_status == STATUS_ABORTED) break;
4709 if (data.devices_status == STATUS_QUIT) break;
4710 if (data.devices_status == STATUS_BYPASS) break;
4711 }
4712
4713 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4714
4715 if (data.devices_status == STATUS_CRACKED) break;
4716 if (data.devices_status == STATUS_ABORTED) break;
4717 if (data.devices_status == STATUS_QUIT) break;
4718 if (data.devices_status == STATUS_BYPASS) break;
4719 }
4720
4721 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4722
4723 if (data.devices_status == STATUS_CRACKED) break;
4724 if (data.devices_status == STATUS_ABORTED) break;
4725 if (data.devices_status == STATUS_QUIT) break;
4726 if (data.devices_status == STATUS_BYPASS) break;
4727
4728 //
4729 // flush
4730 //
4731
4732 const uint pws_cnt = device_param->pws_cnt;
4733
4734 if (pws_cnt)
4735 {
4736 run_copy (device_param, pws_cnt);
4737
4738 run_cracker (device_param, pws_cnt);
4739
4740 device_param->pws_cnt = 0;
4741
4742 if (attack_kern == ATTACK_KERN_STRAIGHT)
4743 {
4744 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4745 }
4746 else if (attack_kern == ATTACK_KERN_COMBI)
4747 {
4748 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4749 }
4750 }
4751
4752 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4753
4754 if (data.devices_status == STATUS_CRACKED) break;
4755 if (data.devices_status == STATUS_ABORTED) break;
4756 if (data.devices_status == STATUS_QUIT) break;
4757 if (data.devices_status == STATUS_BYPASS) break;
4758
4759 if (words_fin == 0) break;
4760
4761 device_param->words_done = words_fin;
4762 }
4763
4764 if (attack_mode == ATTACK_MODE_COMBI)
4765 {
4766 fclose (device_param->combs_fp);
4767 }
4768
4769 free (wl_data->buf);
4770 free (wl_data);
4771
4772 fclose (fd);
4773 }
4774
4775 device_param->kernel_accel = 0;
4776 device_param->kernel_loops = 0;
4777
4778 return NULL;
4779 }
4780
4781 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4782 {
4783 if (!device_param)
4784 {
4785 log_error ("ERROR: %s : Invalid argument", __func__);
4786
4787 exit (-1);
4788 }
4789
4790 salt_t *salt_buf = &data.salts_buf[salt_pos];
4791
4792 device_param->kernel_params_buf32[24] = salt_pos;
4793 device_param->kernel_params_buf32[27] = 1;
4794 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4795 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4796 device_param->kernel_params_buf32[30] = 0;
4797 device_param->kernel_params_buf32[31] = 1;
4798
4799 char *dictfile_old = data.dictfile;
4800
4801 const char *weak_hash_check = "weak-hash-check";
4802
4803 data.dictfile = (char *) weak_hash_check;
4804
4805 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4806
4807 data.kernel_rules_buf[0].cmds[0] = 0;
4808
4809 /**
4810 * run the kernel
4811 */
4812
4813 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4814 {
4815 run_kernel (KERN_RUN_1, device_param, 1, false);
4816 }
4817 else
4818 {
4819 run_kernel (KERN_RUN_1, device_param, 1, false);
4820
4821 uint loop_step = 16;
4822
4823 const uint iter = salt_buf->salt_iter;
4824
4825 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4826 {
4827 uint loop_left = iter - loop_pos;
4828
4829 loop_left = MIN (loop_left, loop_step);
4830
4831 device_param->kernel_params_buf32[25] = loop_pos;
4832 device_param->kernel_params_buf32[26] = loop_left;
4833
4834 run_kernel (KERN_RUN_2, device_param, 1, false);
4835 }
4836
4837 run_kernel (KERN_RUN_3, device_param, 1, false);
4838 }
4839
4840 /**
4841 * result
4842 */
4843
4844 check_cracked (device_param, salt_pos);
4845
4846 /**
4847 * cleanup
4848 */
4849
4850 device_param->kernel_params_buf32[24] = 0;
4851 device_param->kernel_params_buf32[25] = 0;
4852 device_param->kernel_params_buf32[26] = 0;
4853 device_param->kernel_params_buf32[27] = 0;
4854 device_param->kernel_params_buf32[28] = 0;
4855 device_param->kernel_params_buf32[29] = 0;
4856 device_param->kernel_params_buf32[30] = 0;
4857 device_param->kernel_params_buf32[31] = 0;
4858
4859 data.dictfile = dictfile_old;
4860
4861 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4862 }
4863
4864 // hlfmt hashcat
4865
4866 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4867 {
4868 if (data.username == 0)
4869 {
4870 *hashbuf_pos = line_buf;
4871 *hashbuf_len = line_len;
4872 }
4873 else
4874 {
4875 char *pos = line_buf;
4876 int len = line_len;
4877
4878 for (int i = 0; i < line_len; i++, pos++, len--)
4879 {
4880 if (line_buf[i] == data.separator)
4881 {
4882 pos++;
4883
4884 len--;
4885
4886 break;
4887 }
4888 }
4889
4890 *hashbuf_pos = pos;
4891 *hashbuf_len = len;
4892 }
4893 }
4894
4895 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4896 {
4897 char *pos = NULL;
4898 int len = 0;
4899
4900 int sep_cnt = 0;
4901
4902 for (int i = 0; i < line_len; i++)
4903 {
4904 if (line_buf[i] == data.separator)
4905 {
4906 sep_cnt++;
4907
4908 continue;
4909 }
4910
4911 if (sep_cnt == 0)
4912 {
4913 if (pos == NULL) pos = line_buf + i;
4914
4915 len++;
4916 }
4917 }
4918
4919 *userbuf_pos = pos;
4920 *userbuf_len = len;
4921 }
4922
4923 // hlfmt pwdump
4924
4925 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4926 {
4927 int sep_cnt = 0;
4928
4929 int sep2_len = 0;
4930 int sep3_len = 0;
4931
4932 for (int i = 0; i < line_len; i++)
4933 {
4934 if (line_buf[i] == ':')
4935 {
4936 sep_cnt++;
4937
4938 continue;
4939 }
4940
4941 if (sep_cnt == 2) sep2_len++;
4942 if (sep_cnt == 3) sep3_len++;
4943 }
4944
4945 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4946
4947 return 0;
4948 }
4949
4950 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4951 {
4952 char *pos = NULL;
4953 int len = 0;
4954
4955 int sep_cnt = 0;
4956
4957 for (int i = 0; i < line_len; i++)
4958 {
4959 if (line_buf[i] == ':')
4960 {
4961 sep_cnt++;
4962
4963 continue;
4964 }
4965
4966 if (data.hash_mode == 1000)
4967 {
4968 if (sep_cnt == 3)
4969 {
4970 if (pos == NULL) pos = line_buf + i;
4971
4972 len++;
4973 }
4974 }
4975 else if (data.hash_mode == 3000)
4976 {
4977 if (sep_cnt == 2)
4978 {
4979 if (pos == NULL) pos = line_buf + i;
4980
4981 len++;
4982 }
4983 }
4984 }
4985
4986 *hashbuf_pos = pos;
4987 *hashbuf_len = len;
4988 }
4989
4990 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4991 {
4992 char *pos = NULL;
4993 int len = 0;
4994
4995 int sep_cnt = 0;
4996
4997 for (int i = 0; i < line_len; i++)
4998 {
4999 if (line_buf[i] == ':')
5000 {
5001 sep_cnt++;
5002
5003 continue;
5004 }
5005
5006 if (sep_cnt == 0)
5007 {
5008 if (pos == NULL) pos = line_buf + i;
5009
5010 len++;
5011 }
5012 }
5013
5014 *userbuf_pos = pos;
5015 *userbuf_len = len;
5016 }
5017
5018 // hlfmt passwd
5019
5020 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
5021 {
5022 int sep_cnt = 0;
5023
5024 char sep5_first = 0;
5025 char sep6_first = 0;
5026
5027 for (int i = 0; i < line_len; i++)
5028 {
5029 if (line_buf[i] == ':')
5030 {
5031 sep_cnt++;
5032
5033 continue;
5034 }
5035
5036 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5037 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5038 }
5039
5040 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5041
5042 return 0;
5043 }
5044
5045 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5046 {
5047 char *pos = NULL;
5048 int len = 0;
5049
5050 int sep_cnt = 0;
5051
5052 for (int i = 0; i < line_len; i++)
5053 {
5054 if (line_buf[i] == ':')
5055 {
5056 sep_cnt++;
5057
5058 continue;
5059 }
5060
5061 if (sep_cnt == 1)
5062 {
5063 if (pos == NULL) pos = line_buf + i;
5064
5065 len++;
5066 }
5067 }
5068
5069 *hashbuf_pos = pos;
5070 *hashbuf_len = len;
5071 }
5072
5073 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5074 {
5075 char *pos = NULL;
5076 int len = 0;
5077
5078 int sep_cnt = 0;
5079
5080 for (int i = 0; i < line_len; i++)
5081 {
5082 if (line_buf[i] == ':')
5083 {
5084 sep_cnt++;
5085
5086 continue;
5087 }
5088
5089 if (sep_cnt == 0)
5090 {
5091 if (pos == NULL) pos = line_buf + i;
5092
5093 len++;
5094 }
5095 }
5096
5097 *userbuf_pos = pos;
5098 *userbuf_len = len;
5099 }
5100
5101 // hlfmt shadow
5102
5103 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
5104 {
5105 int sep_cnt = 0;
5106
5107 for (int i = 0; i < line_len; i++)
5108 {
5109 if (line_buf[i] == ':') sep_cnt++;
5110 }
5111
5112 if (sep_cnt == 8) return 1;
5113
5114 return 0;
5115 }
5116
5117 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5118 {
5119 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5120 }
5121
5122 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5123 {
5124 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5125 }
5126
5127 // hlfmt main
5128
5129 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5130 {
5131 switch (hashfile_format)
5132 {
5133 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5134 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5135 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5136 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5137 }
5138 }
5139
5140 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5141 {
5142 switch (hashfile_format)
5143 {
5144 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5145 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5146 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5147 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5148 }
5149 }
5150
5151 static uint hlfmt_detect (FILE *fp, uint max_check)
5152 {
5153 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5154
5155 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5156 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5157
5158 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5159
5160 uint num_check = 0;
5161
5162 while (!feof (fp))
5163 {
5164 char line_buf[BUFSIZ] = { 0 };
5165
5166 int line_len = fgetl (fp, line_buf);
5167
5168 if (line_len == 0) continue;
5169
5170 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5171 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5172 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5173
5174 if (num_check == max_check) break;
5175
5176 num_check++;
5177 }
5178
5179 uint hashlist_format = HLFMT_HASHCAT;
5180
5181 for (int i = 1; i < HLFMTS_CNT; i++)
5182 {
5183 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5184
5185 hashlist_format = i;
5186 }
5187
5188 free (formats_cnt);
5189
5190 return hashlist_format;
5191 }
5192
5193 /**
5194 * some further helper function
5195 */
5196
5197 // wrapper around mymalloc for ADL
5198
5199 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5200 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5201 {
5202 return mymalloc (iSize);
5203 }
5204 #endif
5205
5206 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)
5207 {
5208 u64 collisions = 0;
5209
5210 const uint dgst_pos0 = data.dgst_pos0;
5211 const uint dgst_pos1 = data.dgst_pos1;
5212 const uint dgst_pos2 = data.dgst_pos2;
5213 const uint dgst_pos3 = data.dgst_pos3;
5214
5215 memset (bitmap_a, 0, bitmap_size);
5216 memset (bitmap_b, 0, bitmap_size);
5217 memset (bitmap_c, 0, bitmap_size);
5218 memset (bitmap_d, 0, bitmap_size);
5219
5220 for (uint i = 0; i < digests_cnt; i++)
5221 {
5222 uint *digest_ptr = (uint *) digests_buf_ptr;
5223
5224 digests_buf_ptr += dgst_size;
5225
5226 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5227 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5228 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5229 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5230
5231 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5232 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5233 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5234 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5235
5236 if (bitmap_a[idx0] & val0) collisions++;
5237 if (bitmap_b[idx1] & val1) collisions++;
5238 if (bitmap_c[idx2] & val2) collisions++;
5239 if (bitmap_d[idx3] & val3) collisions++;
5240
5241 bitmap_a[idx0] |= val0;
5242 bitmap_b[idx1] |= val1;
5243 bitmap_c[idx2] |= val2;
5244 bitmap_d[idx3] |= val3;
5245
5246 if (collisions >= collisions_max) return 0x7fffffff;
5247 }
5248
5249 return collisions;
5250 }
5251
5252 /**
5253 * main
5254 */
5255
5256 int main (int argc, char **argv)
5257 {
5258 /**
5259 * To help users a bit
5260 */
5261
5262 char *compute = getenv ("COMPUTE");
5263
5264 if (compute)
5265 {
5266 static char display[100];
5267
5268 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5269
5270 putenv (display);
5271 }
5272 else
5273 {
5274 if (getenv ("DISPLAY") == NULL)
5275 putenv ((char *) "DISPLAY=:0");
5276 }
5277
5278 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5279 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5280
5281 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5282 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5283
5284 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5285 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5286
5287 /**
5288 * Real init
5289 */
5290
5291 memset (&data, 0, sizeof (hc_global_data_t));
5292
5293 time_t proc_start;
5294
5295 time (&proc_start);
5296
5297 data.proc_start = proc_start;
5298
5299 int myargc = argc;
5300 char **myargv = argv;
5301
5302 hc_thread_mutex_init (mux_dispatcher);
5303 hc_thread_mutex_init (mux_counter);
5304 hc_thread_mutex_init (mux_display);
5305 hc_thread_mutex_init (mux_adl);
5306
5307 /**
5308 * commandline parameters
5309 */
5310
5311 uint usage = USAGE;
5312 uint version = VERSION;
5313 uint quiet = QUIET;
5314 uint benchmark = BENCHMARK;
5315 uint benchmark_repeats = BENCHMARK_REPEATS;
5316 uint show = SHOW;
5317 uint left = LEFT;
5318 uint username = USERNAME;
5319 uint remove = REMOVE;
5320 uint remove_timer = REMOVE_TIMER;
5321 u64 skip = SKIP;
5322 u64 limit = LIMIT;
5323 uint keyspace = KEYSPACE;
5324 uint potfile_disable = POTFILE_DISABLE;
5325 uint debug_mode = DEBUG_MODE;
5326 char *debug_file = NULL;
5327 char *induction_dir = NULL;
5328 char *outfile_check_dir = NULL;
5329 uint force = FORCE;
5330 uint runtime = RUNTIME;
5331 uint hash_mode = HASH_MODE;
5332 uint attack_mode = ATTACK_MODE;
5333 uint markov_disable = MARKOV_DISABLE;
5334 uint markov_classic = MARKOV_CLASSIC;
5335 uint markov_threshold = MARKOV_THRESHOLD;
5336 char *markov_hcstat = NULL;
5337 char *outfile = NULL;
5338 uint outfile_format = OUTFILE_FORMAT;
5339 uint outfile_autohex = OUTFILE_AUTOHEX;
5340 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5341 uint restore = RESTORE;
5342 uint restore_timer = RESTORE_TIMER;
5343 uint restore_disable = RESTORE_DISABLE;
5344 uint status = STATUS;
5345 uint status_timer = STATUS_TIMER;
5346 uint status_automat = STATUS_AUTOMAT;
5347 uint loopback = LOOPBACK;
5348 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5349 char *session = NULL;
5350 uint hex_charset = HEX_CHARSET;
5351 uint hex_salt = HEX_SALT;
5352 uint hex_wordlist = HEX_WORDLIST;
5353 uint rp_gen = RP_GEN;
5354 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5355 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5356 uint rp_gen_seed = RP_GEN_SEED;
5357 char *rule_buf_l = (char *) RULE_BUF_L;
5358 char *rule_buf_r = (char *) RULE_BUF_R;
5359 uint increment = INCREMENT;
5360 uint increment_min = INCREMENT_MIN;
5361 uint increment_max = INCREMENT_MAX;
5362 char *cpu_affinity = NULL;
5363 OCL_PTR *ocl = NULL;
5364 char *opencl_devices = NULL;
5365 char *opencl_platforms = NULL;
5366 char *opencl_device_types = NULL;
5367 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5368 char *truecrypt_keyfiles = NULL;
5369 uint workload_profile = WORKLOAD_PROFILE;
5370 uint kernel_accel = KERNEL_ACCEL;
5371 uint kernel_loops = KERNEL_LOOPS;
5372 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5373 #ifdef HAVE_HWMON
5374 uint gpu_temp_abort = GPU_TEMP_ABORT;
5375 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5376 #ifdef HAVE_ADL
5377 uint powertune_enable = POWERTUNE_ENABLE;
5378 #endif
5379 #endif
5380 uint logfile_disable = LOGFILE_DISABLE;
5381 uint segment_size = SEGMENT_SIZE;
5382 uint scrypt_tmto = SCRYPT_TMTO;
5383 char separator = SEPARATOR;
5384 uint bitmap_min = BITMAP_MIN;
5385 uint bitmap_max = BITMAP_MAX;
5386 char *custom_charset_1 = NULL;
5387 char *custom_charset_2 = NULL;
5388 char *custom_charset_3 = NULL;
5389 char *custom_charset_4 = NULL;
5390
5391 #define IDX_HELP 'h'
5392 #define IDX_VERSION 'V'
5393 #define IDX_VERSION_LOWER 'v'
5394 #define IDX_QUIET 0xff02
5395 #define IDX_SHOW 0xff03
5396 #define IDX_LEFT 0xff04
5397 #define IDX_REMOVE 0xff05
5398 #define IDX_REMOVE_TIMER 0xff37
5399 #define IDX_SKIP 's'
5400 #define IDX_LIMIT 'l'
5401 #define IDX_KEYSPACE 0xff35
5402 #define IDX_POTFILE_DISABLE 0xff06
5403 #define IDX_DEBUG_MODE 0xff43
5404 #define IDX_DEBUG_FILE 0xff44
5405 #define IDX_INDUCTION_DIR 0xff46
5406 #define IDX_OUTFILE_CHECK_DIR 0xff47
5407 #define IDX_USERNAME 0xff07
5408 #define IDX_FORCE 0xff08
5409 #define IDX_RUNTIME 0xff09
5410 #define IDX_BENCHMARK 'b'
5411 #define IDX_BENCHMARK_REPEATS 0xff78
5412 #define IDX_HASH_MODE 'm'
5413 #define IDX_ATTACK_MODE 'a'
5414 #define IDX_RP_FILE 'r'
5415 #define IDX_RP_GEN 'g'
5416 #define IDX_RP_GEN_FUNC_MIN 0xff10
5417 #define IDX_RP_GEN_FUNC_MAX 0xff11
5418 #define IDX_RP_GEN_SEED 0xff34
5419 #define IDX_RULE_BUF_L 'j'
5420 #define IDX_RULE_BUF_R 'k'
5421 #define IDX_INCREMENT 'i'
5422 #define IDX_INCREMENT_MIN 0xff12
5423 #define IDX_INCREMENT_MAX 0xff13
5424 #define IDX_OUTFILE 'o'
5425 #define IDX_OUTFILE_FORMAT 0xff14
5426 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5427 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5428 #define IDX_RESTORE 0xff15
5429 #define IDX_RESTORE_DISABLE 0xff27
5430 #define IDX_STATUS 0xff17
5431 #define IDX_STATUS_TIMER 0xff18
5432 #define IDX_STATUS_AUTOMAT 0xff50
5433 #define IDX_LOOPBACK 0xff38
5434 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5435 #define IDX_SESSION 0xff19
5436 #define IDX_HEX_CHARSET 0xff20
5437 #define IDX_HEX_SALT 0xff21
5438 #define IDX_HEX_WORDLIST 0xff40
5439 #define IDX_MARKOV_DISABLE 0xff22
5440 #define IDX_MARKOV_CLASSIC 0xff23
5441 #define IDX_MARKOV_THRESHOLD 't'
5442 #define IDX_MARKOV_HCSTAT 0xff24
5443 #define IDX_CPU_AFFINITY 0xff25
5444 #define IDX_OPENCL_DEVICES 'd'
5445 #define IDX_OPENCL_PLATFORMS 0xff72
5446 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5447 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5448 #define IDX_WORKLOAD_PROFILE 'w'
5449 #define IDX_KERNEL_ACCEL 'n'
5450 #define IDX_KERNEL_LOOPS 'u'
5451 #define IDX_GPU_TEMP_DISABLE 0xff29
5452 #define IDX_GPU_TEMP_ABORT 0xff30
5453 #define IDX_GPU_TEMP_RETAIN 0xff31
5454 #define IDX_POWERTUNE_ENABLE 0xff41
5455 #define IDX_LOGFILE_DISABLE 0xff51
5456 #define IDX_TRUECRYPT_KEYFILES 0xff52
5457 #define IDX_SCRYPT_TMTO 0xff61
5458 #define IDX_SEGMENT_SIZE 'c'
5459 #define IDX_SEPARATOR 'p'
5460 #define IDX_BITMAP_MIN 0xff70
5461 #define IDX_BITMAP_MAX 0xff71
5462 #define IDX_CUSTOM_CHARSET_1 '1'
5463 #define IDX_CUSTOM_CHARSET_2 '2'
5464 #define IDX_CUSTOM_CHARSET_3 '3'
5465 #define IDX_CUSTOM_CHARSET_4 '4'
5466
5467 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5468
5469 struct option long_options[] =
5470 {
5471 {"help", no_argument, 0, IDX_HELP},
5472 {"version", no_argument, 0, IDX_VERSION},
5473 {"quiet", no_argument, 0, IDX_QUIET},
5474 {"show", no_argument, 0, IDX_SHOW},
5475 {"left", no_argument, 0, IDX_LEFT},
5476 {"username", no_argument, 0, IDX_USERNAME},
5477 {"remove", no_argument, 0, IDX_REMOVE},
5478 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5479 {"skip", required_argument, 0, IDX_SKIP},
5480 {"limit", required_argument, 0, IDX_LIMIT},
5481 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5482 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5483 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5484 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5485 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5486 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5487 {"force", no_argument, 0, IDX_FORCE},
5488 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5489 {"benchmark-repeats", required_argument, 0, IDX_BENCHMARK_REPEATS},
5490 {"restore", no_argument, 0, IDX_RESTORE},
5491 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5492 {"status", no_argument, 0, IDX_STATUS},
5493 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5494 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5495 {"loopback", no_argument, 0, IDX_LOOPBACK},
5496 {"weak-hash-threshold",
5497 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5498 {"session", required_argument, 0, IDX_SESSION},
5499 {"runtime", required_argument, 0, IDX_RUNTIME},
5500 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5501 {"generate-rules-func-min",
5502 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5503 {"generate-rules-func-max",
5504 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5505 {"generate-rules-seed",
5506 required_argument, 0, IDX_RP_GEN_SEED},
5507 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5508 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5509 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5510 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5511 {"rules-file", required_argument, 0, IDX_RP_FILE},
5512 {"outfile", required_argument, 0, IDX_OUTFILE},
5513 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5514 {"outfile-autohex-disable",
5515 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5516 {"outfile-check-timer",
5517 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5518 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5519 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5520 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5521 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5522 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5523 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5524 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5525 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5526 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5527 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5528 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5529 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5530 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5531 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5532 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5533 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5534 #ifdef HAVE_HWMON
5535 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5536 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5537 #ifdef HAVE_ADL
5538 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5539 #endif
5540 #endif // HAVE_HWMON
5541 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5542 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5543 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5544 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5545 // deprecated
5546 {"seperator", required_argument, 0, IDX_SEPARATOR},
5547 {"separator", required_argument, 0, IDX_SEPARATOR},
5548 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5549 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5550 {"increment", no_argument, 0, IDX_INCREMENT},
5551 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5552 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5553 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5554 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5555 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5556 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5557
5558 {0, 0, 0, 0}
5559 };
5560
5561 uint rp_files_cnt = 0;
5562
5563 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5564
5565 int option_index = 0;
5566 int c = -1;
5567
5568 optind = 1;
5569 optopt = 0;
5570
5571 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5572 {
5573 switch (c)
5574 {
5575 case IDX_HELP: usage = 1; break;
5576 case IDX_VERSION:
5577 case IDX_VERSION_LOWER: version = 1; break;
5578 case IDX_RESTORE: restore = 1; break;
5579 case IDX_SESSION: session = optarg; break;
5580 case IDX_SHOW: show = 1; break;
5581 case IDX_LEFT: left = 1; break;
5582 case '?': return (-1);
5583 }
5584 }
5585
5586 if (optopt != 0)
5587 {
5588 log_error ("ERROR: Invalid argument specified");
5589
5590 return (-1);
5591 }
5592
5593 /**
5594 * exit functions
5595 */
5596
5597 if (version)
5598 {
5599 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5600
5601 return (0);
5602 }
5603
5604 if (usage)
5605 {
5606 usage_big_print (PROGNAME);
5607
5608 return (0);
5609 }
5610
5611 /**
5612 * session needs to be set, always!
5613 */
5614
5615 if (session == NULL) session = (char *) PROGNAME;
5616
5617 /**
5618 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5619 */
5620
5621 char *exec_path = get_exec_path ();
5622
5623 #ifdef LINUX
5624
5625 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5626 char *resolved_exec_path = realpath (exec_path, NULL);
5627
5628 char *install_dir = get_install_dir (resolved_exec_path);
5629 char *profile_dir = NULL;
5630 char *session_dir = NULL;
5631 char *shared_dir = NULL;
5632
5633 if (strcmp (install_dir, resolved_install_folder) == 0)
5634 {
5635 struct passwd *pw = getpwuid (getuid ());
5636
5637 const char *homedir = pw->pw_dir;
5638
5639 profile_dir = get_profile_dir (homedir);
5640 session_dir = get_session_dir (profile_dir);
5641 shared_dir = strdup (SHARED_FOLDER);
5642
5643 mkdir (profile_dir, 0700);
5644 mkdir (session_dir, 0700);
5645 }
5646 else
5647 {
5648 profile_dir = install_dir;
5649 session_dir = install_dir;
5650 shared_dir = install_dir;
5651 }
5652
5653 myfree (resolved_install_folder);
5654 myfree (resolved_exec_path);
5655
5656 #else
5657
5658 char *install_dir = get_install_dir (exec_path);
5659 char *profile_dir = install_dir;
5660 char *session_dir = install_dir;
5661 char *shared_dir = install_dir;
5662
5663 #endif
5664
5665 data.install_dir = install_dir;
5666 data.profile_dir = profile_dir;
5667 data.session_dir = session_dir;
5668 data.shared_dir = shared_dir;
5669
5670 myfree (exec_path);
5671
5672 /**
5673 * kernel cache, we need to make sure folder exist
5674 */
5675
5676 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5677
5678 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5679
5680 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5681
5682 mkdir (kernels_folder, 0700);
5683
5684 myfree (kernels_folder);
5685
5686 /**
5687 * session
5688 */
5689
5690 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5691
5692 data.session = session;
5693
5694 char *eff_restore_file = (char *) mymalloc (session_size);
5695 char *new_restore_file = (char *) mymalloc (session_size);
5696
5697 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5698 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5699
5700 data.eff_restore_file = eff_restore_file;
5701 data.new_restore_file = new_restore_file;
5702
5703 if (((show == 1) || (left == 1)) && (restore == 1))
5704 {
5705 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5706 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5707
5708 return (-1);
5709 }
5710
5711 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5712 if ((show == 1) || (left == 1))
5713 {
5714 restore_disable = 1;
5715
5716 restore = 0;
5717 }
5718
5719 data.restore_disable = restore_disable;
5720
5721 restore_data_t *rd = init_restore (argc, argv);
5722
5723 data.rd = rd;
5724
5725 /**
5726 * restore file
5727 */
5728
5729 if (restore == 1)
5730 {
5731 read_restore (eff_restore_file, rd);
5732
5733 if (rd->version_bin < RESTORE_MIN)
5734 {
5735 log_error ("ERROR: Incompatible restore-file version");
5736
5737 return (-1);
5738 }
5739
5740 myargc = rd->argc;
5741 myargv = rd->argv;
5742
5743 #ifdef _POSIX
5744 rd->pid = getpid ();
5745 #elif _WIN
5746 rd->pid = GetCurrentProcessId ();
5747 #endif
5748 }
5749
5750 uint hash_mode_chgd = 0;
5751 uint runtime_chgd = 0;
5752 uint kernel_loops_chgd = 0;
5753 uint kernel_accel_chgd = 0;
5754 uint attack_mode_chgd = 0;
5755 uint outfile_format_chgd = 0;
5756 uint rp_gen_seed_chgd = 0;
5757 uint remove_timer_chgd = 0;
5758 uint increment_min_chgd = 0;
5759 uint increment_max_chgd = 0;
5760 uint workload_profile_chgd = 0;
5761 uint opencl_vector_width_chgd = 0;
5762
5763 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5764 uint gpu_temp_retain_chgd = 0;
5765 uint gpu_temp_abort_chgd = 0;
5766 #endif
5767
5768 optind = 1;
5769 optopt = 0;
5770 option_index = 0;
5771
5772 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5773 {
5774 switch (c)
5775 {
5776 //case IDX_HELP: usage = 1; break;
5777 //case IDX_VERSION: version = 1; break;
5778 //case IDX_RESTORE: restore = 1; break;
5779 case IDX_QUIET: quiet = 1; break;
5780 //case IDX_SHOW: show = 1; break;
5781 case IDX_SHOW: break;
5782 //case IDX_LEFT: left = 1; break;
5783 case IDX_LEFT: break;
5784 case IDX_USERNAME: username = 1; break;
5785 case IDX_REMOVE: remove = 1; break;
5786 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5787 remove_timer_chgd = 1; break;
5788 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5789 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5790 case IDX_DEBUG_FILE: debug_file = optarg; break;
5791 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5792 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5793 case IDX_FORCE: force = 1; break;
5794 case IDX_SKIP: skip = atoll (optarg); break;
5795 case IDX_LIMIT: limit = atoll (optarg); break;
5796 case IDX_KEYSPACE: keyspace = 1; break;
5797 case IDX_BENCHMARK: benchmark = 1; break;
5798 case IDX_BENCHMARK_REPEATS: benchmark_repeats = atoi (optarg); break;
5799 case IDX_RESTORE: break;
5800 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5801 case IDX_STATUS: status = 1; break;
5802 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5803 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5804 case IDX_LOOPBACK: loopback = 1; break;
5805 case IDX_WEAK_HASH_THRESHOLD:
5806 weak_hash_threshold = atoi (optarg); break;
5807 //case IDX_SESSION: session = optarg; break;
5808 case IDX_SESSION: break;
5809 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5810 hash_mode_chgd = 1; break;
5811 case IDX_RUNTIME: runtime = atoi (optarg);
5812 runtime_chgd = 1; break;
5813 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5814 attack_mode_chgd = 1; break;
5815 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5816 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5817 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5818 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5819 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5820 rp_gen_seed_chgd = 1; break;
5821 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5822 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5823 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5824 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5825 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5826 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5827 case IDX_OUTFILE: outfile = optarg; break;
5828 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5829 outfile_format_chgd = 1; break;
5830 case IDX_OUTFILE_AUTOHEX_DISABLE:
5831 outfile_autohex = 0; break;
5832 case IDX_OUTFILE_CHECK_TIMER:
5833 outfile_check_timer = atoi (optarg); break;
5834 case IDX_HEX_CHARSET: hex_charset = 1; break;
5835 case IDX_HEX_SALT: hex_salt = 1; break;
5836 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5837 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5838 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5839 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5840 case IDX_OPENCL_DEVICE_TYPES:
5841 opencl_device_types = optarg; break;
5842 case IDX_OPENCL_VECTOR_WIDTH:
5843 opencl_vector_width = atoi (optarg);
5844 opencl_vector_width_chgd = 1; break;
5845 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5846 workload_profile_chgd = 1; break;
5847 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5848 kernel_accel_chgd = 1; break;
5849 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5850 kernel_loops_chgd = 1; break;
5851 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5852 #ifdef HAVE_HWMON
5853 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5854 #ifdef HAVE_ADL
5855 gpu_temp_abort_chgd = 1;
5856 #endif
5857 break;
5858 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5859 #ifdef HAVE_ADL
5860 gpu_temp_retain_chgd = 1;
5861 #endif
5862 break;
5863 #ifdef HAVE_ADL
5864 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5865 #endif
5866 #endif // HAVE_HWMON
5867 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5868 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5869 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5870 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5871 case IDX_SEPARATOR: separator = optarg[0]; break;
5872 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5873 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5874 case IDX_INCREMENT: increment = 1; break;
5875 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5876 increment_min_chgd = 1; break;
5877 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5878 increment_max_chgd = 1; break;
5879 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5880 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5881 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5882 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5883
5884 default:
5885 log_error ("ERROR: Invalid argument specified");
5886 return (-1);
5887 }
5888 }
5889
5890 if (optopt != 0)
5891 {
5892 log_error ("ERROR: Invalid argument specified");
5893
5894 return (-1);
5895 }
5896
5897 /**
5898 * Inform user things getting started,
5899 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5900 * - we do not need to check algorithm_pos
5901 */
5902
5903 if (quiet == 0)
5904 {
5905 if (benchmark == 1)
5906 {
5907 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5908
5909 log_info ("");
5910 }
5911 else if (restore == 1)
5912 {
5913 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5914
5915 log_info ("");
5916 }
5917 else
5918 {
5919 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5920
5921 log_info ("");
5922 }
5923 }
5924
5925 /**
5926 * sanity check
5927 */
5928
5929 if (attack_mode > 7)
5930 {
5931 log_error ("ERROR: Invalid attack-mode specified");
5932
5933 return (-1);
5934 }
5935
5936 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5937 {
5938 log_error ("ERROR: Invalid runtime specified");
5939
5940 return (-1);
5941 }
5942
5943 if (hash_mode_chgd && hash_mode > 13300) // just added to remove compiler warnings for hash_mode_chgd
5944 {
5945 log_error ("ERROR: Invalid hash-type specified");
5946
5947 return (-1);
5948 }
5949
5950 // renamed hash modes
5951
5952 if (hash_mode_chgd)
5953 {
5954 int n = -1;
5955
5956 switch (hash_mode)
5957 {
5958 case 123: n = 124;
5959 break;
5960 }
5961
5962 if (n >= 0)
5963 {
5964 log_error ("Old -m specified, use -m %d instead", n);
5965
5966 return (-1);
5967 }
5968 }
5969
5970 if (username == 1)
5971 {
5972 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5973 {
5974 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5975
5976 return (-1);
5977 }
5978 }
5979
5980 if (outfile_format > 16)
5981 {
5982 log_error ("ERROR: Invalid outfile-format specified");
5983
5984 return (-1);
5985 }
5986
5987 if (left == 1)
5988 {
5989 if (outfile_format_chgd == 1)
5990 {
5991 if (outfile_format > 1)
5992 {
5993 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5994
5995 return (-1);
5996 }
5997 }
5998 else
5999 {
6000 outfile_format = OUTFILE_FMT_HASH;
6001 }
6002 }
6003
6004 if (show == 1)
6005 {
6006 if (outfile_format_chgd == 1)
6007 {
6008 if ((outfile_format > 7) && (outfile_format < 16))
6009 {
6010 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6011
6012 return (-1);
6013 }
6014 }
6015 }
6016
6017 if (increment_min < INCREMENT_MIN)
6018 {
6019 log_error ("ERROR: Invalid increment-min specified");
6020
6021 return (-1);
6022 }
6023
6024 if (increment_max > INCREMENT_MAX)
6025 {
6026 log_error ("ERROR: Invalid increment-max specified");
6027
6028 return (-1);
6029 }
6030
6031 if (increment_min > increment_max)
6032 {
6033 log_error ("ERROR: Invalid increment-min specified");
6034
6035 return (-1);
6036 }
6037
6038 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6039 {
6040 log_error ("ERROR: increment is not allowed in attack-mode 0");
6041
6042 return (-1);
6043 }
6044
6045 if ((increment == 0) && (increment_min_chgd == 1))
6046 {
6047 log_error ("ERROR: increment-min is only supported together with increment switch");
6048
6049 return (-1);
6050 }
6051
6052 if ((increment == 0) && (increment_max_chgd == 1))
6053 {
6054 log_error ("ERROR: increment-max is only supported together with increment switch");
6055
6056 return (-1);
6057 }
6058
6059 if (rp_files_cnt && rp_gen)
6060 {
6061 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6062
6063 return (-1);
6064 }
6065
6066 if (rp_files_cnt || rp_gen)
6067 {
6068 if (attack_mode != ATTACK_MODE_STRAIGHT)
6069 {
6070 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6071
6072 return (-1);
6073 }
6074 }
6075
6076 if (rp_gen_func_min > rp_gen_func_max)
6077 {
6078 log_error ("ERROR: Invalid rp-gen-func-min specified");
6079
6080 return (-1);
6081 }
6082
6083 if (kernel_accel_chgd == 1)
6084 {
6085 if (kernel_accel < 1)
6086 {
6087 log_error ("ERROR: Invalid kernel-accel specified");
6088
6089 return (-1);
6090 }
6091
6092 if (kernel_accel > 1024)
6093 {
6094 log_error ("ERROR: Invalid kernel-accel specified");
6095
6096 return (-1);
6097 }
6098 }
6099
6100 if (kernel_loops_chgd == 1)
6101 {
6102 if (kernel_loops < 1)
6103 {
6104 log_error ("ERROR: Invalid kernel-loops specified");
6105
6106 return (-1);
6107 }
6108
6109 if (kernel_loops > 1024)
6110 {
6111 log_error ("ERROR: Invalid kernel-loops specified");
6112
6113 return (-1);
6114 }
6115 }
6116
6117 if ((workload_profile < 1) || (workload_profile > 3))
6118 {
6119 log_error ("ERROR: workload-profile %i not available", workload_profile);
6120
6121 return (-1);
6122 }
6123
6124 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6125 {
6126 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6127
6128 return (-1);
6129 }
6130
6131 if (show == 1 || left == 1)
6132 {
6133 attack_mode = ATTACK_MODE_NONE;
6134
6135 if (remove == 1)
6136 {
6137 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6138
6139 return (-1);
6140 }
6141
6142 if (potfile_disable == 1)
6143 {
6144 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6145
6146 return (-1);
6147 }
6148 }
6149
6150 uint attack_kern = ATTACK_KERN_NONE;
6151
6152 switch (attack_mode)
6153 {
6154 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6155 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6156 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6157 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6158 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6159 }
6160
6161 if (benchmark == 0)
6162 {
6163 if (keyspace == 1)
6164 {
6165 int num_additional_params = 1;
6166
6167 if (attack_kern == ATTACK_KERN_COMBI)
6168 {
6169 num_additional_params = 2;
6170 }
6171
6172 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6173
6174 if (keyspace_wordlist_specified == 0) optind--;
6175 }
6176
6177 if (attack_kern == ATTACK_KERN_NONE)
6178 {
6179 if ((optind + 1) != myargc)
6180 {
6181 usage_mini_print (myargv[0]);
6182
6183 return (-1);
6184 }
6185 }
6186 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6187 {
6188 if ((optind + 1) > myargc)
6189 {
6190 usage_mini_print (myargv[0]);
6191
6192 return (-1);
6193 }
6194 }
6195 else if (attack_kern == ATTACK_KERN_COMBI)
6196 {
6197 if ((optind + 3) != myargc)
6198 {
6199 usage_mini_print (myargv[0]);
6200
6201 return (-1);
6202 }
6203 }
6204 else if (attack_kern == ATTACK_KERN_BF)
6205 {
6206 if ((optind + 1) > myargc)
6207 {
6208 usage_mini_print (myargv[0]);
6209
6210 return (-1);
6211 }
6212 }
6213 else
6214 {
6215 usage_mini_print (myargv[0]);
6216
6217 return (-1);
6218 }
6219 }
6220 else
6221 {
6222 if (myargv[optind] != 0)
6223 {
6224 log_error ("ERROR: Invalid argument for benchmark mode specified");
6225
6226 return (-1);
6227 }
6228
6229 if (attack_mode_chgd == 1)
6230 {
6231 if (attack_mode != ATTACK_MODE_BF)
6232 {
6233 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6234
6235 return (-1);
6236 }
6237 }
6238 }
6239
6240 if (skip != 0 && limit != 0)
6241 {
6242 limit += skip;
6243 }
6244
6245 if (keyspace == 1)
6246 {
6247 if (show == 1)
6248 {
6249 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6250
6251 return (-1);
6252 }
6253 else if (left == 1)
6254 {
6255 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6256
6257 return (-1);
6258 }
6259
6260 potfile_disable = 1;
6261
6262 restore_disable = 1;
6263
6264 restore = 0;
6265
6266 weak_hash_threshold = 0;
6267
6268 quiet = 1;
6269 }
6270
6271 if (remove_timer_chgd == 1)
6272 {
6273 if (remove == 0)
6274 {
6275 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6276
6277 return (-1);
6278 }
6279
6280 if (remove_timer < 1)
6281 {
6282 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6283
6284 return (-1);
6285 }
6286 }
6287
6288 if (loopback == 1)
6289 {
6290 if (attack_mode == ATTACK_MODE_BF)
6291 {
6292 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6293
6294 return (-1);
6295 }
6296 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6297 {
6298 if ((rp_files_cnt == 0) && (rp_gen == 0))
6299 {
6300 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6301
6302 return (-1);
6303 }
6304 }
6305 }
6306
6307 if (debug_mode > 0)
6308 {
6309 if (attack_mode != ATTACK_MODE_STRAIGHT)
6310 {
6311 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6312
6313 return (-1);
6314 }
6315
6316 if ((rp_files_cnt == 0) && (rp_gen == 0))
6317 {
6318 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6319
6320 return (-1);
6321 }
6322 }
6323
6324 if (debug_mode > 4)
6325 {
6326 log_error ("ERROR: Invalid debug-mode specified");
6327
6328 return (-1);
6329 }
6330
6331 if (debug_file != NULL)
6332 {
6333 if (debug_mode < 1)
6334 {
6335 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6336
6337 return (-1);
6338 }
6339 }
6340
6341 if (induction_dir != NULL)
6342 {
6343 if (attack_mode == ATTACK_MODE_BF)
6344 {
6345 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6346
6347 return (-1);
6348 }
6349 }
6350
6351 if (attack_mode != ATTACK_MODE_STRAIGHT)
6352 {
6353 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6354 {
6355 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6356
6357 return (-1);
6358 }
6359
6360 weak_hash_threshold = 0;
6361 }
6362
6363 /**
6364 * induction directory
6365 */
6366
6367 char *induction_directory = NULL;
6368
6369 if (attack_mode != ATTACK_MODE_BF)
6370 {
6371 if (induction_dir == NULL)
6372 {
6373 induction_directory = (char *) mymalloc (session_size);
6374
6375 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6376
6377 // create induction folder if it does not already exist
6378
6379 if (keyspace == 0)
6380 {
6381 if (rmdir (induction_directory) == -1)
6382 {
6383 if (errno == ENOENT)
6384 {
6385 // good, we can ignore
6386 }
6387 else if (errno == ENOTEMPTY)
6388 {
6389 char *induction_directory_mv = (char *) mymalloc (session_size);
6390
6391 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6392
6393 if (rename (induction_directory, induction_directory_mv) != 0)
6394 {
6395 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6396
6397 return (-1);
6398 }
6399 }
6400 else
6401 {
6402 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6403
6404 return (-1);
6405 }
6406 }
6407
6408 if (mkdir (induction_directory, 0700) == -1)
6409 {
6410 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6411
6412 return (-1);
6413 }
6414 }
6415 }
6416 else
6417 {
6418 induction_directory = induction_dir;
6419 }
6420 }
6421
6422 data.induction_directory = induction_directory;
6423
6424 /**
6425 * loopback
6426 */
6427
6428 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6429
6430 char *loopback_file = (char *) mymalloc (loopback_size);
6431
6432 /**
6433 * tuning db
6434 */
6435
6436 char tuning_db_file[256] = { 0 };
6437
6438 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6439
6440 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6441
6442 /**
6443 * outfile-check directory
6444 */
6445
6446 char *outfile_check_directory = NULL;
6447
6448 if (outfile_check_dir == NULL)
6449 {
6450 outfile_check_directory = (char *) mymalloc (session_size);
6451
6452 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6453 }
6454 else
6455 {
6456 outfile_check_directory = outfile_check_dir;
6457 }
6458
6459 data.outfile_check_directory = outfile_check_directory;
6460
6461 if (keyspace == 0)
6462 {
6463 struct stat outfile_check_stat;
6464
6465 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6466 {
6467 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6468
6469 if (is_dir == 0)
6470 {
6471 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6472
6473 return (-1);
6474 }
6475 }
6476 else if (outfile_check_dir == NULL)
6477 {
6478 if (mkdir (outfile_check_directory, 0700) == -1)
6479 {
6480 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6481
6482 return (-1);
6483 }
6484 }
6485 }
6486
6487 /**
6488 * special other stuff
6489 */
6490
6491 if (hash_mode == 9710)
6492 {
6493 outfile_format = 5;
6494 outfile_format_chgd = 1;
6495 }
6496
6497 if (hash_mode == 9810)
6498 {
6499 outfile_format = 5;
6500 outfile_format_chgd = 1;
6501 }
6502
6503 if (hash_mode == 10410)
6504 {
6505 outfile_format = 5;
6506 outfile_format_chgd = 1;
6507 }
6508
6509 /**
6510 * store stuff
6511 */
6512
6513 data.hash_mode = hash_mode;
6514 data.restore = restore;
6515 data.restore_timer = restore_timer;
6516 data.restore_disable = restore_disable;
6517 data.status = status;
6518 data.status_timer = status_timer;
6519 data.status_automat = status_automat;
6520 data.loopback = loopback;
6521 data.runtime = runtime;
6522 data.remove = remove;
6523 data.remove_timer = remove_timer;
6524 data.debug_mode = debug_mode;
6525 data.debug_file = debug_file;
6526 data.username = username;
6527 data.quiet = quiet;
6528 data.outfile = outfile;
6529 data.outfile_format = outfile_format;
6530 data.outfile_autohex = outfile_autohex;
6531 data.hex_charset = hex_charset;
6532 data.hex_salt = hex_salt;
6533 data.hex_wordlist = hex_wordlist;
6534 data.separator = separator;
6535 data.rp_files = rp_files;
6536 data.rp_files_cnt = rp_files_cnt;
6537 data.rp_gen = rp_gen;
6538 data.rp_gen_seed = rp_gen_seed;
6539 data.force = force;
6540 data.benchmark = benchmark;
6541 data.benchmark_repeats = benchmark_repeats;
6542 data.skip = skip;
6543 data.limit = limit;
6544 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6545 data.powertune_enable = powertune_enable;
6546 #endif
6547 data.logfile_disable = logfile_disable;
6548 data.truecrypt_keyfiles = truecrypt_keyfiles;
6549 data.scrypt_tmto = scrypt_tmto;
6550 data.workload_profile = workload_profile;
6551
6552 /**
6553 * cpu affinity
6554 */
6555
6556 if (cpu_affinity)
6557 {
6558 set_cpu_affinity (cpu_affinity);
6559 }
6560
6561 if (rp_gen_seed_chgd == 0)
6562 {
6563 srand (proc_start);
6564 }
6565 else
6566 {
6567 srand (rp_gen_seed);
6568 }
6569
6570 /**
6571 * logfile init
6572 */
6573
6574 if (logfile_disable == 0)
6575 {
6576 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6577
6578 char *logfile = (char *) mymalloc (logfile_size);
6579
6580 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6581
6582 data.logfile = logfile;
6583
6584 char *topid = logfile_generate_topid ();
6585
6586 data.topid = topid;
6587 }
6588
6589 // logfile_append() checks for logfile_disable internally to make it easier from here
6590
6591 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6592 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6593 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6594 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6595 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6596 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6597 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6598 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6599 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6600 #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));
6601
6602 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6603 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6604 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6605 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6606 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6607 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6608 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6609 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6610
6611 logfile_top_msg ("START");
6612
6613 logfile_top_uint (attack_mode);
6614 logfile_top_uint (attack_kern);
6615 logfile_top_uint (benchmark);
6616 logfile_top_uint (benchmark_repeats);
6617 logfile_top_uint (bitmap_min);
6618 logfile_top_uint (bitmap_max);
6619 logfile_top_uint (debug_mode);
6620 logfile_top_uint (force);
6621 logfile_top_uint (kernel_accel);
6622 logfile_top_uint (kernel_loops);
6623 logfile_top_uint (gpu_temp_disable);
6624 #ifdef HAVE_HWMON
6625 logfile_top_uint (gpu_temp_abort);
6626 logfile_top_uint (gpu_temp_retain);
6627 #endif
6628 logfile_top_uint (hash_mode);
6629 logfile_top_uint (hex_charset);
6630 logfile_top_uint (hex_salt);
6631 logfile_top_uint (hex_wordlist);
6632 logfile_top_uint (increment);
6633 logfile_top_uint (increment_max);
6634 logfile_top_uint (increment_min);
6635 logfile_top_uint (keyspace);
6636 logfile_top_uint (left);
6637 logfile_top_uint (logfile_disable);
6638 logfile_top_uint (loopback);
6639 logfile_top_uint (markov_classic);
6640 logfile_top_uint (markov_disable);
6641 logfile_top_uint (markov_threshold);
6642 logfile_top_uint (outfile_autohex);
6643 logfile_top_uint (outfile_check_timer);
6644 logfile_top_uint (outfile_format);
6645 logfile_top_uint (potfile_disable);
6646 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6647 logfile_top_uint (powertune_enable);
6648 #endif
6649 logfile_top_uint (scrypt_tmto);
6650 logfile_top_uint (quiet);
6651 logfile_top_uint (remove);
6652 logfile_top_uint (remove_timer);
6653 logfile_top_uint (restore);
6654 logfile_top_uint (restore_disable);
6655 logfile_top_uint (restore_timer);
6656 logfile_top_uint (rp_gen);
6657 logfile_top_uint (rp_gen_func_max);
6658 logfile_top_uint (rp_gen_func_min);
6659 logfile_top_uint (rp_gen_seed);
6660 logfile_top_uint (runtime);
6661 logfile_top_uint (segment_size);
6662 logfile_top_uint (show);
6663 logfile_top_uint (status);
6664 logfile_top_uint (status_automat);
6665 logfile_top_uint (status_timer);
6666 logfile_top_uint (usage);
6667 logfile_top_uint (username);
6668 logfile_top_uint (version);
6669 logfile_top_uint (weak_hash_threshold);
6670 logfile_top_uint (workload_profile);
6671 logfile_top_uint64 (limit);
6672 logfile_top_uint64 (skip);
6673 logfile_top_char (separator);
6674 logfile_top_string (cpu_affinity);
6675 logfile_top_string (custom_charset_1);
6676 logfile_top_string (custom_charset_2);
6677 logfile_top_string (custom_charset_3);
6678 logfile_top_string (custom_charset_4);
6679 logfile_top_string (debug_file);
6680 logfile_top_string (opencl_devices);
6681 logfile_top_string (opencl_platforms);
6682 logfile_top_string (opencl_device_types);
6683 logfile_top_uint (opencl_vector_width);
6684 logfile_top_string (induction_dir);
6685 logfile_top_string (markov_hcstat);
6686 logfile_top_string (outfile);
6687 logfile_top_string (outfile_check_dir);
6688 logfile_top_string (rule_buf_l);
6689 logfile_top_string (rule_buf_r);
6690 logfile_top_string (session);
6691 logfile_top_string (truecrypt_keyfiles);
6692
6693 /**
6694 * Init OpenCL library loader
6695 */
6696
6697 if (keyspace == 0)
6698 {
6699 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6700
6701 ocl_init (ocl);
6702
6703 data.ocl = ocl;
6704 }
6705
6706 /**
6707 * OpenCL platform selection
6708 */
6709
6710 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6711
6712 /**
6713 * OpenCL device selection
6714 */
6715
6716 u32 devices_filter = setup_devices_filter (opencl_devices);
6717
6718 /**
6719 * OpenCL device type selection
6720 */
6721
6722 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6723
6724 /**
6725 * benchmark
6726 */
6727
6728 if (benchmark == 1)
6729 {
6730 /**
6731 * disable useless stuff for benchmark
6732 */
6733
6734 status_timer = 0;
6735 restore_timer = 0;
6736 restore_disable = 1;
6737 potfile_disable = 1;
6738 weak_hash_threshold = 0;
6739 gpu_temp_disable = 1;
6740
6741 data.status_timer = status_timer;
6742 data.restore_timer = restore_timer;
6743 data.restore_disable = restore_disable;
6744
6745 /**
6746 * force attack mode to be bruteforce
6747 */
6748
6749 attack_mode = ATTACK_MODE_BF;
6750 attack_kern = ATTACK_KERN_BF;
6751
6752 if (workload_profile_chgd == 0)
6753 {
6754 workload_profile = 3;
6755
6756 data.workload_profile = workload_profile;
6757 }
6758 }
6759
6760 /**
6761 * config
6762 */
6763
6764 uint hash_type = 0;
6765 uint salt_type = 0;
6766 uint attack_exec = 0;
6767 uint opts_type = 0;
6768 uint kern_type = 0;
6769 uint dgst_size = 0;
6770 uint esalt_size = 0;
6771 uint opti_type = 0;
6772 uint dgst_pos0 = -1;
6773 uint dgst_pos1 = -1;
6774 uint dgst_pos2 = -1;
6775 uint dgst_pos3 = -1;
6776
6777 int (*parse_func) (char *, uint, hash_t *);
6778 int (*sort_by_digest) (const void *, const void *);
6779
6780 uint algorithm_pos = 0;
6781 uint algorithm_max = 1;
6782
6783 uint *algorithms = default_benchmark_algorithms;
6784
6785 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6786
6787 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6788 {
6789 /*
6790 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6791 * the following algos are skipped entirely
6792 */
6793
6794 if (algorithm_pos > 0)
6795 {
6796 local_free (rd);
6797
6798 rd = init_restore (argc, argv);
6799
6800 data.rd = rd;
6801 }
6802
6803 /**
6804 * update hash_mode in case of multihash benchmark
6805 */
6806
6807 if (benchmark == 1)
6808 {
6809 if (hash_mode_chgd == 0)
6810 {
6811 hash_mode = algorithms[algorithm_pos];
6812
6813 data.hash_mode = hash_mode;
6814 }
6815
6816 quiet = 1;
6817
6818 data.quiet = quiet;
6819 }
6820
6821 switch (hash_mode)
6822 {
6823 case 0: hash_type = HASH_TYPE_MD5;
6824 salt_type = SALT_TYPE_NONE;
6825 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6826 opts_type = OPTS_TYPE_PT_GENERATE_LE
6827 | OPTS_TYPE_PT_ADD80
6828 | OPTS_TYPE_PT_ADDBITS14;
6829 kern_type = KERN_TYPE_MD5;
6830 dgst_size = DGST_SIZE_4_4;
6831 parse_func = md5_parse_hash;
6832 sort_by_digest = sort_by_digest_4_4;
6833 opti_type = OPTI_TYPE_ZERO_BYTE
6834 | OPTI_TYPE_PRECOMPUTE_INIT
6835 | OPTI_TYPE_PRECOMPUTE_MERKLE
6836 | OPTI_TYPE_MEET_IN_MIDDLE
6837 | OPTI_TYPE_EARLY_SKIP
6838 | OPTI_TYPE_NOT_ITERATED
6839 | OPTI_TYPE_NOT_SALTED
6840 | OPTI_TYPE_RAW_HASH;
6841 dgst_pos0 = 0;
6842 dgst_pos1 = 3;
6843 dgst_pos2 = 2;
6844 dgst_pos3 = 1;
6845 break;
6846
6847 case 10: hash_type = HASH_TYPE_MD5;
6848 salt_type = SALT_TYPE_INTERN;
6849 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6850 opts_type = OPTS_TYPE_PT_GENERATE_LE
6851 | OPTS_TYPE_ST_ADD80
6852 | OPTS_TYPE_ST_ADDBITS14;
6853 kern_type = KERN_TYPE_MD5_PWSLT;
6854 dgst_size = DGST_SIZE_4_4;
6855 parse_func = md5s_parse_hash;
6856 sort_by_digest = sort_by_digest_4_4;
6857 opti_type = OPTI_TYPE_ZERO_BYTE
6858 | OPTI_TYPE_PRECOMPUTE_INIT
6859 | OPTI_TYPE_PRECOMPUTE_MERKLE
6860 | OPTI_TYPE_MEET_IN_MIDDLE
6861 | OPTI_TYPE_EARLY_SKIP
6862 | OPTI_TYPE_NOT_ITERATED
6863 | OPTI_TYPE_APPENDED_SALT
6864 | OPTI_TYPE_RAW_HASH;
6865 dgst_pos0 = 0;
6866 dgst_pos1 = 3;
6867 dgst_pos2 = 2;
6868 dgst_pos3 = 1;
6869 break;
6870
6871 case 11: hash_type = HASH_TYPE_MD5;
6872 salt_type = SALT_TYPE_INTERN;
6873 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6874 opts_type = OPTS_TYPE_PT_GENERATE_LE
6875 | OPTS_TYPE_ST_ADD80
6876 | OPTS_TYPE_ST_ADDBITS14;
6877 kern_type = KERN_TYPE_MD5_PWSLT;
6878 dgst_size = DGST_SIZE_4_4;
6879 parse_func = joomla_parse_hash;
6880 sort_by_digest = sort_by_digest_4_4;
6881 opti_type = OPTI_TYPE_ZERO_BYTE
6882 | OPTI_TYPE_PRECOMPUTE_INIT
6883 | OPTI_TYPE_PRECOMPUTE_MERKLE
6884 | OPTI_TYPE_MEET_IN_MIDDLE
6885 | OPTI_TYPE_EARLY_SKIP
6886 | OPTI_TYPE_NOT_ITERATED
6887 | OPTI_TYPE_APPENDED_SALT
6888 | OPTI_TYPE_RAW_HASH;
6889 dgst_pos0 = 0;
6890 dgst_pos1 = 3;
6891 dgst_pos2 = 2;
6892 dgst_pos3 = 1;
6893 break;
6894
6895 case 12: hash_type = HASH_TYPE_MD5;
6896 salt_type = SALT_TYPE_INTERN;
6897 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6898 opts_type = OPTS_TYPE_PT_GENERATE_LE
6899 | OPTS_TYPE_ST_ADD80
6900 | OPTS_TYPE_ST_ADDBITS14;
6901 kern_type = KERN_TYPE_MD5_PWSLT;
6902 dgst_size = DGST_SIZE_4_4;
6903 parse_func = postgresql_parse_hash;
6904 sort_by_digest = sort_by_digest_4_4;
6905 opti_type = OPTI_TYPE_ZERO_BYTE
6906 | OPTI_TYPE_PRECOMPUTE_INIT
6907 | OPTI_TYPE_PRECOMPUTE_MERKLE
6908 | OPTI_TYPE_MEET_IN_MIDDLE
6909 | OPTI_TYPE_EARLY_SKIP
6910 | OPTI_TYPE_NOT_ITERATED
6911 | OPTI_TYPE_APPENDED_SALT
6912 | OPTI_TYPE_RAW_HASH;
6913 dgst_pos0 = 0;
6914 dgst_pos1 = 3;
6915 dgst_pos2 = 2;
6916 dgst_pos3 = 1;
6917 break;
6918
6919 case 20: hash_type = HASH_TYPE_MD5;
6920 salt_type = SALT_TYPE_INTERN;
6921 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6922 opts_type = OPTS_TYPE_PT_GENERATE_LE
6923 | OPTS_TYPE_PT_ADD80
6924 | OPTS_TYPE_PT_ADDBITS14;
6925 kern_type = KERN_TYPE_MD5_SLTPW;
6926 dgst_size = DGST_SIZE_4_4;
6927 parse_func = md5s_parse_hash;
6928 sort_by_digest = sort_by_digest_4_4;
6929 opti_type = OPTI_TYPE_ZERO_BYTE
6930 | OPTI_TYPE_PRECOMPUTE_INIT
6931 | OPTI_TYPE_PRECOMPUTE_MERKLE
6932 | OPTI_TYPE_EARLY_SKIP
6933 | OPTI_TYPE_NOT_ITERATED
6934 | OPTI_TYPE_PREPENDED_SALT
6935 | OPTI_TYPE_RAW_HASH;
6936 dgst_pos0 = 0;
6937 dgst_pos1 = 3;
6938 dgst_pos2 = 2;
6939 dgst_pos3 = 1;
6940 break;
6941
6942 case 21: hash_type = HASH_TYPE_MD5;
6943 salt_type = SALT_TYPE_INTERN;
6944 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6945 opts_type = OPTS_TYPE_PT_GENERATE_LE
6946 | OPTS_TYPE_PT_ADD80
6947 | OPTS_TYPE_PT_ADDBITS14;
6948 kern_type = KERN_TYPE_MD5_SLTPW;
6949 dgst_size = DGST_SIZE_4_4;
6950 parse_func = osc_parse_hash;
6951 sort_by_digest = sort_by_digest_4_4;
6952 opti_type = OPTI_TYPE_ZERO_BYTE
6953 | OPTI_TYPE_PRECOMPUTE_INIT
6954 | OPTI_TYPE_PRECOMPUTE_MERKLE
6955 | OPTI_TYPE_EARLY_SKIP
6956 | OPTI_TYPE_NOT_ITERATED
6957 | OPTI_TYPE_PREPENDED_SALT
6958 | OPTI_TYPE_RAW_HASH;
6959 dgst_pos0 = 0;
6960 dgst_pos1 = 3;
6961 dgst_pos2 = 2;
6962 dgst_pos3 = 1;
6963 break;
6964
6965 case 22: hash_type = HASH_TYPE_MD5;
6966 salt_type = SALT_TYPE_EMBEDDED;
6967 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6968 opts_type = OPTS_TYPE_PT_GENERATE_LE
6969 | OPTS_TYPE_PT_ADD80
6970 | OPTS_TYPE_PT_ADDBITS14;
6971 kern_type = KERN_TYPE_MD5_SLTPW;
6972 dgst_size = DGST_SIZE_4_4;
6973 parse_func = netscreen_parse_hash;
6974 sort_by_digest = sort_by_digest_4_4;
6975 opti_type = OPTI_TYPE_ZERO_BYTE
6976 | OPTI_TYPE_PRECOMPUTE_INIT
6977 | OPTI_TYPE_PRECOMPUTE_MERKLE
6978 | OPTI_TYPE_EARLY_SKIP
6979 | OPTI_TYPE_NOT_ITERATED
6980 | OPTI_TYPE_PREPENDED_SALT
6981 | OPTI_TYPE_RAW_HASH;
6982 dgst_pos0 = 0;
6983 dgst_pos1 = 3;
6984 dgst_pos2 = 2;
6985 dgst_pos3 = 1;
6986 break;
6987
6988 case 23: hash_type = HASH_TYPE_MD5;
6989 salt_type = SALT_TYPE_EMBEDDED;
6990 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6991 opts_type = OPTS_TYPE_PT_GENERATE_LE
6992 | OPTS_TYPE_PT_ADD80
6993 | OPTS_TYPE_PT_ADDBITS14;
6994 kern_type = KERN_TYPE_MD5_SLTPW;
6995 dgst_size = DGST_SIZE_4_4;
6996 parse_func = skype_parse_hash;
6997 sort_by_digest = sort_by_digest_4_4;
6998 opti_type = OPTI_TYPE_ZERO_BYTE
6999 | OPTI_TYPE_PRECOMPUTE_INIT
7000 | OPTI_TYPE_PRECOMPUTE_MERKLE
7001 | OPTI_TYPE_EARLY_SKIP
7002 | OPTI_TYPE_NOT_ITERATED
7003 | OPTI_TYPE_PREPENDED_SALT
7004 | OPTI_TYPE_RAW_HASH;
7005 dgst_pos0 = 0;
7006 dgst_pos1 = 3;
7007 dgst_pos2 = 2;
7008 dgst_pos3 = 1;
7009 break;
7010
7011 case 30: hash_type = HASH_TYPE_MD5;
7012 salt_type = SALT_TYPE_INTERN;
7013 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7014 opts_type = OPTS_TYPE_PT_GENERATE_LE
7015 | OPTS_TYPE_PT_UNICODE
7016 | OPTS_TYPE_ST_ADD80
7017 | OPTS_TYPE_ST_ADDBITS14;
7018 kern_type = KERN_TYPE_MD5_PWUSLT;
7019 dgst_size = DGST_SIZE_4_4;
7020 parse_func = md5s_parse_hash;
7021 sort_by_digest = sort_by_digest_4_4;
7022 opti_type = OPTI_TYPE_ZERO_BYTE
7023 | OPTI_TYPE_PRECOMPUTE_INIT
7024 | OPTI_TYPE_PRECOMPUTE_MERKLE
7025 | OPTI_TYPE_MEET_IN_MIDDLE
7026 | OPTI_TYPE_EARLY_SKIP
7027 | OPTI_TYPE_NOT_ITERATED
7028 | OPTI_TYPE_APPENDED_SALT
7029 | OPTI_TYPE_RAW_HASH;
7030 dgst_pos0 = 0;
7031 dgst_pos1 = 3;
7032 dgst_pos2 = 2;
7033 dgst_pos3 = 1;
7034 break;
7035
7036 case 40: hash_type = HASH_TYPE_MD5;
7037 salt_type = SALT_TYPE_INTERN;
7038 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7039 opts_type = OPTS_TYPE_PT_GENERATE_LE
7040 | OPTS_TYPE_PT_ADD80
7041 | OPTS_TYPE_PT_ADDBITS14
7042 | OPTS_TYPE_PT_UNICODE;
7043 kern_type = KERN_TYPE_MD5_SLTPWU;
7044 dgst_size = DGST_SIZE_4_4;
7045 parse_func = md5s_parse_hash;
7046 sort_by_digest = sort_by_digest_4_4;
7047 opti_type = OPTI_TYPE_ZERO_BYTE
7048 | OPTI_TYPE_PRECOMPUTE_INIT
7049 | OPTI_TYPE_PRECOMPUTE_MERKLE
7050 | OPTI_TYPE_EARLY_SKIP
7051 | OPTI_TYPE_NOT_ITERATED
7052 | OPTI_TYPE_PREPENDED_SALT
7053 | OPTI_TYPE_RAW_HASH;
7054 dgst_pos0 = 0;
7055 dgst_pos1 = 3;
7056 dgst_pos2 = 2;
7057 dgst_pos3 = 1;
7058 break;
7059
7060 case 50: hash_type = HASH_TYPE_MD5;
7061 salt_type = SALT_TYPE_INTERN;
7062 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7063 opts_type = OPTS_TYPE_PT_GENERATE_LE
7064 | OPTS_TYPE_ST_ADD80
7065 | OPTS_TYPE_ST_ADDBITS14;
7066 kern_type = KERN_TYPE_HMACMD5_PW;
7067 dgst_size = DGST_SIZE_4_4;
7068 parse_func = hmacmd5_parse_hash;
7069 sort_by_digest = sort_by_digest_4_4;
7070 opti_type = OPTI_TYPE_ZERO_BYTE
7071 | OPTI_TYPE_NOT_ITERATED;
7072 dgst_pos0 = 0;
7073 dgst_pos1 = 3;
7074 dgst_pos2 = 2;
7075 dgst_pos3 = 1;
7076 break;
7077
7078 case 60: hash_type = HASH_TYPE_MD5;
7079 salt_type = SALT_TYPE_INTERN;
7080 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7081 opts_type = OPTS_TYPE_PT_GENERATE_LE
7082 | OPTS_TYPE_PT_ADD80
7083 | OPTS_TYPE_PT_ADDBITS14;
7084 kern_type = KERN_TYPE_HMACMD5_SLT;
7085 dgst_size = DGST_SIZE_4_4;
7086 parse_func = hmacmd5_parse_hash;
7087 sort_by_digest = sort_by_digest_4_4;
7088 opti_type = OPTI_TYPE_ZERO_BYTE
7089 | OPTI_TYPE_NOT_ITERATED;
7090 dgst_pos0 = 0;
7091 dgst_pos1 = 3;
7092 dgst_pos2 = 2;
7093 dgst_pos3 = 1;
7094 break;
7095
7096 case 100: hash_type = HASH_TYPE_SHA1;
7097 salt_type = SALT_TYPE_NONE;
7098 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7099 opts_type = OPTS_TYPE_PT_GENERATE_BE
7100 | OPTS_TYPE_PT_ADD80
7101 | OPTS_TYPE_PT_ADDBITS15;
7102 kern_type = KERN_TYPE_SHA1;
7103 dgst_size = DGST_SIZE_4_5;
7104 parse_func = sha1_parse_hash;
7105 sort_by_digest = sort_by_digest_4_5;
7106 opti_type = OPTI_TYPE_ZERO_BYTE
7107 | OPTI_TYPE_PRECOMPUTE_INIT
7108 | OPTI_TYPE_PRECOMPUTE_MERKLE
7109 | OPTI_TYPE_EARLY_SKIP
7110 | OPTI_TYPE_NOT_ITERATED
7111 | OPTI_TYPE_NOT_SALTED
7112 | OPTI_TYPE_RAW_HASH;
7113 dgst_pos0 = 3;
7114 dgst_pos1 = 4;
7115 dgst_pos2 = 2;
7116 dgst_pos3 = 1;
7117 break;
7118
7119 case 101: hash_type = HASH_TYPE_SHA1;
7120 salt_type = SALT_TYPE_NONE;
7121 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7122 opts_type = OPTS_TYPE_PT_GENERATE_BE
7123 | OPTS_TYPE_PT_ADD80
7124 | OPTS_TYPE_PT_ADDBITS15;
7125 kern_type = KERN_TYPE_SHA1;
7126 dgst_size = DGST_SIZE_4_5;
7127 parse_func = sha1b64_parse_hash;
7128 sort_by_digest = sort_by_digest_4_5;
7129 opti_type = OPTI_TYPE_ZERO_BYTE
7130 | OPTI_TYPE_PRECOMPUTE_INIT
7131 | OPTI_TYPE_PRECOMPUTE_MERKLE
7132 | OPTI_TYPE_EARLY_SKIP
7133 | OPTI_TYPE_NOT_ITERATED
7134 | OPTI_TYPE_NOT_SALTED
7135 | OPTI_TYPE_RAW_HASH;
7136 dgst_pos0 = 3;
7137 dgst_pos1 = 4;
7138 dgst_pos2 = 2;
7139 dgst_pos3 = 1;
7140 break;
7141
7142 case 110: hash_type = HASH_TYPE_SHA1;
7143 salt_type = SALT_TYPE_INTERN;
7144 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7145 opts_type = OPTS_TYPE_PT_GENERATE_BE
7146 | OPTS_TYPE_ST_ADD80
7147 | OPTS_TYPE_ST_ADDBITS15;
7148 kern_type = KERN_TYPE_SHA1_PWSLT;
7149 dgst_size = DGST_SIZE_4_5;
7150 parse_func = sha1s_parse_hash;
7151 sort_by_digest = sort_by_digest_4_5;
7152 opti_type = OPTI_TYPE_ZERO_BYTE
7153 | OPTI_TYPE_PRECOMPUTE_INIT
7154 | OPTI_TYPE_PRECOMPUTE_MERKLE
7155 | OPTI_TYPE_EARLY_SKIP
7156 | OPTI_TYPE_NOT_ITERATED
7157 | OPTI_TYPE_APPENDED_SALT
7158 | OPTI_TYPE_RAW_HASH;
7159 dgst_pos0 = 3;
7160 dgst_pos1 = 4;
7161 dgst_pos2 = 2;
7162 dgst_pos3 = 1;
7163 break;
7164
7165 case 111: hash_type = HASH_TYPE_SHA1;
7166 salt_type = SALT_TYPE_EMBEDDED;
7167 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7168 opts_type = OPTS_TYPE_PT_GENERATE_BE
7169 | OPTS_TYPE_ST_ADD80
7170 | OPTS_TYPE_ST_ADDBITS15;
7171 kern_type = KERN_TYPE_SHA1_PWSLT;
7172 dgst_size = DGST_SIZE_4_5;
7173 parse_func = sha1b64s_parse_hash;
7174 sort_by_digest = sort_by_digest_4_5;
7175 opti_type = OPTI_TYPE_ZERO_BYTE
7176 | OPTI_TYPE_PRECOMPUTE_INIT
7177 | OPTI_TYPE_PRECOMPUTE_MERKLE
7178 | OPTI_TYPE_EARLY_SKIP
7179 | OPTI_TYPE_NOT_ITERATED
7180 | OPTI_TYPE_APPENDED_SALT
7181 | OPTI_TYPE_RAW_HASH;
7182 dgst_pos0 = 3;
7183 dgst_pos1 = 4;
7184 dgst_pos2 = 2;
7185 dgst_pos3 = 1;
7186 break;
7187
7188 case 112: hash_type = HASH_TYPE_SHA1;
7189 salt_type = SALT_TYPE_INTERN;
7190 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7191 opts_type = OPTS_TYPE_PT_GENERATE_BE
7192 | OPTS_TYPE_ST_ADD80
7193 | OPTS_TYPE_ST_ADDBITS15
7194 | OPTS_TYPE_ST_HEX;
7195 kern_type = KERN_TYPE_SHA1_PWSLT;
7196 dgst_size = DGST_SIZE_4_5;
7197 parse_func = oracles_parse_hash;
7198 sort_by_digest = sort_by_digest_4_5;
7199 opti_type = OPTI_TYPE_ZERO_BYTE
7200 | OPTI_TYPE_PRECOMPUTE_INIT
7201 | OPTI_TYPE_PRECOMPUTE_MERKLE
7202 | OPTI_TYPE_EARLY_SKIP
7203 | OPTI_TYPE_NOT_ITERATED
7204 | OPTI_TYPE_APPENDED_SALT
7205 | OPTI_TYPE_RAW_HASH;
7206 dgst_pos0 = 3;
7207 dgst_pos1 = 4;
7208 dgst_pos2 = 2;
7209 dgst_pos3 = 1;
7210 break;
7211
7212 case 120: hash_type = HASH_TYPE_SHA1;
7213 salt_type = SALT_TYPE_INTERN;
7214 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7215 opts_type = OPTS_TYPE_PT_GENERATE_BE
7216 | OPTS_TYPE_PT_ADD80
7217 | OPTS_TYPE_PT_ADDBITS15;
7218 kern_type = KERN_TYPE_SHA1_SLTPW;
7219 dgst_size = DGST_SIZE_4_5;
7220 parse_func = sha1s_parse_hash;
7221 sort_by_digest = sort_by_digest_4_5;
7222 opti_type = OPTI_TYPE_ZERO_BYTE
7223 | OPTI_TYPE_PRECOMPUTE_INIT
7224 | OPTI_TYPE_PRECOMPUTE_MERKLE
7225 | OPTI_TYPE_EARLY_SKIP
7226 | OPTI_TYPE_NOT_ITERATED
7227 | OPTI_TYPE_PREPENDED_SALT
7228 | OPTI_TYPE_RAW_HASH;
7229 dgst_pos0 = 3;
7230 dgst_pos1 = 4;
7231 dgst_pos2 = 2;
7232 dgst_pos3 = 1;
7233 break;
7234
7235 case 121: hash_type = HASH_TYPE_SHA1;
7236 salt_type = SALT_TYPE_INTERN;
7237 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7238 opts_type = OPTS_TYPE_PT_GENERATE_BE
7239 | OPTS_TYPE_PT_ADD80
7240 | OPTS_TYPE_PT_ADDBITS15
7241 | OPTS_TYPE_ST_LOWER;
7242 kern_type = KERN_TYPE_SHA1_SLTPW;
7243 dgst_size = DGST_SIZE_4_5;
7244 parse_func = smf_parse_hash;
7245 sort_by_digest = sort_by_digest_4_5;
7246 opti_type = OPTI_TYPE_ZERO_BYTE
7247 | OPTI_TYPE_PRECOMPUTE_INIT
7248 | OPTI_TYPE_PRECOMPUTE_MERKLE
7249 | OPTI_TYPE_EARLY_SKIP
7250 | OPTI_TYPE_NOT_ITERATED
7251 | OPTI_TYPE_PREPENDED_SALT
7252 | OPTI_TYPE_RAW_HASH;
7253 dgst_pos0 = 3;
7254 dgst_pos1 = 4;
7255 dgst_pos2 = 2;
7256 dgst_pos3 = 1;
7257 break;
7258
7259 case 122: hash_type = HASH_TYPE_SHA1;
7260 salt_type = SALT_TYPE_EMBEDDED;
7261 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7262 opts_type = OPTS_TYPE_PT_GENERATE_BE
7263 | OPTS_TYPE_PT_ADD80
7264 | OPTS_TYPE_PT_ADDBITS15
7265 | OPTS_TYPE_ST_HEX;
7266 kern_type = KERN_TYPE_SHA1_SLTPW;
7267 dgst_size = DGST_SIZE_4_5;
7268 parse_func = osx1_parse_hash;
7269 sort_by_digest = sort_by_digest_4_5;
7270 opti_type = OPTI_TYPE_ZERO_BYTE
7271 | OPTI_TYPE_PRECOMPUTE_INIT
7272 | OPTI_TYPE_PRECOMPUTE_MERKLE
7273 | OPTI_TYPE_EARLY_SKIP
7274 | OPTI_TYPE_NOT_ITERATED
7275 | OPTI_TYPE_PREPENDED_SALT
7276 | OPTI_TYPE_RAW_HASH;
7277 dgst_pos0 = 3;
7278 dgst_pos1 = 4;
7279 dgst_pos2 = 2;
7280 dgst_pos3 = 1;
7281 break;
7282
7283 case 124: hash_type = HASH_TYPE_SHA1;
7284 salt_type = SALT_TYPE_EMBEDDED;
7285 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7286 opts_type = OPTS_TYPE_PT_GENERATE_BE
7287 | OPTS_TYPE_PT_ADD80
7288 | OPTS_TYPE_PT_ADDBITS15;
7289 kern_type = KERN_TYPE_SHA1_SLTPW;
7290 dgst_size = DGST_SIZE_4_5;
7291 parse_func = djangosha1_parse_hash;
7292 sort_by_digest = sort_by_digest_4_5;
7293 opti_type = OPTI_TYPE_ZERO_BYTE
7294 | OPTI_TYPE_PRECOMPUTE_INIT
7295 | OPTI_TYPE_PRECOMPUTE_MERKLE
7296 | OPTI_TYPE_EARLY_SKIP
7297 | OPTI_TYPE_NOT_ITERATED
7298 | OPTI_TYPE_PREPENDED_SALT
7299 | OPTI_TYPE_RAW_HASH;
7300 dgst_pos0 = 3;
7301 dgst_pos1 = 4;
7302 dgst_pos2 = 2;
7303 dgst_pos3 = 1;
7304 break;
7305
7306 case 130: hash_type = HASH_TYPE_SHA1;
7307 salt_type = SALT_TYPE_INTERN;
7308 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7309 opts_type = OPTS_TYPE_PT_GENERATE_BE
7310 | OPTS_TYPE_PT_UNICODE
7311 | OPTS_TYPE_ST_ADD80
7312 | OPTS_TYPE_ST_ADDBITS15;
7313 kern_type = KERN_TYPE_SHA1_PWUSLT;
7314 dgst_size = DGST_SIZE_4_5;
7315 parse_func = sha1s_parse_hash;
7316 sort_by_digest = sort_by_digest_4_5;
7317 opti_type = OPTI_TYPE_ZERO_BYTE
7318 | OPTI_TYPE_PRECOMPUTE_INIT
7319 | OPTI_TYPE_PRECOMPUTE_MERKLE
7320 | OPTI_TYPE_EARLY_SKIP
7321 | OPTI_TYPE_NOT_ITERATED
7322 | OPTI_TYPE_APPENDED_SALT
7323 | OPTI_TYPE_RAW_HASH;
7324 dgst_pos0 = 3;
7325 dgst_pos1 = 4;
7326 dgst_pos2 = 2;
7327 dgst_pos3 = 1;
7328 break;
7329
7330 case 131: hash_type = HASH_TYPE_SHA1;
7331 salt_type = SALT_TYPE_EMBEDDED;
7332 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7333 opts_type = OPTS_TYPE_PT_GENERATE_BE
7334 | OPTS_TYPE_PT_UNICODE
7335 | OPTS_TYPE_PT_UPPER
7336 | OPTS_TYPE_ST_ADD80
7337 | OPTS_TYPE_ST_ADDBITS15
7338 | OPTS_TYPE_ST_HEX;
7339 kern_type = KERN_TYPE_SHA1_PWUSLT;
7340 dgst_size = DGST_SIZE_4_5;
7341 parse_func = mssql2000_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 132: 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_ST_ADD80
7362 | OPTS_TYPE_ST_ADDBITS15
7363 | OPTS_TYPE_ST_HEX;
7364 kern_type = KERN_TYPE_SHA1_PWUSLT;
7365 dgst_size = DGST_SIZE_4_5;
7366 parse_func = mssql2005_parse_hash;
7367 sort_by_digest = sort_by_digest_4_5;
7368 opti_type = OPTI_TYPE_ZERO_BYTE
7369 | OPTI_TYPE_PRECOMPUTE_INIT
7370 | OPTI_TYPE_PRECOMPUTE_MERKLE
7371 | OPTI_TYPE_EARLY_SKIP
7372 | OPTI_TYPE_NOT_ITERATED
7373 | OPTI_TYPE_APPENDED_SALT
7374 | OPTI_TYPE_RAW_HASH;
7375 dgst_pos0 = 3;
7376 dgst_pos1 = 4;
7377 dgst_pos2 = 2;
7378 dgst_pos3 = 1;
7379 break;
7380
7381 case 133: hash_type = HASH_TYPE_SHA1;
7382 salt_type = SALT_TYPE_EMBEDDED;
7383 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7384 opts_type = OPTS_TYPE_PT_GENERATE_BE
7385 | OPTS_TYPE_PT_UNICODE
7386 | OPTS_TYPE_ST_ADD80
7387 | OPTS_TYPE_ST_ADDBITS15;
7388 kern_type = KERN_TYPE_SHA1_PWUSLT;
7389 dgst_size = DGST_SIZE_4_5;
7390 parse_func = peoplesoft_parse_hash;
7391 sort_by_digest = sort_by_digest_4_5;
7392 opti_type = OPTI_TYPE_ZERO_BYTE
7393 | OPTI_TYPE_PRECOMPUTE_INIT
7394 | OPTI_TYPE_PRECOMPUTE_MERKLE
7395 | OPTI_TYPE_EARLY_SKIP
7396 | OPTI_TYPE_NOT_ITERATED
7397 | OPTI_TYPE_APPENDED_SALT
7398 | OPTI_TYPE_RAW_HASH;
7399 dgst_pos0 = 3;
7400 dgst_pos1 = 4;
7401 dgst_pos2 = 2;
7402 dgst_pos3 = 1;
7403 break;
7404
7405 case 140: hash_type = HASH_TYPE_SHA1;
7406 salt_type = SALT_TYPE_INTERN;
7407 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7408 opts_type = OPTS_TYPE_PT_GENERATE_BE
7409 | OPTS_TYPE_PT_ADD80
7410 | OPTS_TYPE_PT_ADDBITS15
7411 | OPTS_TYPE_PT_UNICODE;
7412 kern_type = KERN_TYPE_SHA1_SLTPWU;
7413 dgst_size = DGST_SIZE_4_5;
7414 parse_func = sha1s_parse_hash;
7415 sort_by_digest = sort_by_digest_4_5;
7416 opti_type = OPTI_TYPE_ZERO_BYTE
7417 | OPTI_TYPE_PRECOMPUTE_INIT
7418 | OPTI_TYPE_PRECOMPUTE_MERKLE
7419 | OPTI_TYPE_EARLY_SKIP
7420 | OPTI_TYPE_NOT_ITERATED
7421 | OPTI_TYPE_PREPENDED_SALT
7422 | OPTI_TYPE_RAW_HASH;
7423 dgst_pos0 = 3;
7424 dgst_pos1 = 4;
7425 dgst_pos2 = 2;
7426 dgst_pos3 = 1;
7427 break;
7428
7429 case 141: hash_type = HASH_TYPE_SHA1;
7430 salt_type = SALT_TYPE_EMBEDDED;
7431 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7432 opts_type = OPTS_TYPE_PT_GENERATE_BE
7433 | OPTS_TYPE_PT_ADD80
7434 | OPTS_TYPE_PT_ADDBITS15
7435 | OPTS_TYPE_PT_UNICODE
7436 | OPTS_TYPE_ST_BASE64;
7437 kern_type = KERN_TYPE_SHA1_SLTPWU;
7438 dgst_size = DGST_SIZE_4_5;
7439 parse_func = episerver_parse_hash;
7440 sort_by_digest = sort_by_digest_4_5;
7441 opti_type = OPTI_TYPE_ZERO_BYTE
7442 | OPTI_TYPE_PRECOMPUTE_INIT
7443 | OPTI_TYPE_PRECOMPUTE_MERKLE
7444 | OPTI_TYPE_EARLY_SKIP
7445 | OPTI_TYPE_NOT_ITERATED
7446 | OPTI_TYPE_PREPENDED_SALT
7447 | OPTI_TYPE_RAW_HASH;
7448 dgst_pos0 = 3;
7449 dgst_pos1 = 4;
7450 dgst_pos2 = 2;
7451 dgst_pos3 = 1;
7452 break;
7453
7454 case 150: hash_type = HASH_TYPE_SHA1;
7455 salt_type = SALT_TYPE_INTERN;
7456 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7457 opts_type = OPTS_TYPE_PT_GENERATE_BE
7458 | OPTS_TYPE_ST_ADD80
7459 | OPTS_TYPE_ST_ADDBITS15;
7460 kern_type = KERN_TYPE_HMACSHA1_PW;
7461 dgst_size = DGST_SIZE_4_5;
7462 parse_func = hmacsha1_parse_hash;
7463 sort_by_digest = sort_by_digest_4_5;
7464 opti_type = OPTI_TYPE_ZERO_BYTE
7465 | OPTI_TYPE_NOT_ITERATED;
7466 dgst_pos0 = 3;
7467 dgst_pos1 = 4;
7468 dgst_pos2 = 2;
7469 dgst_pos3 = 1;
7470 break;
7471
7472 case 160: hash_type = HASH_TYPE_SHA1;
7473 salt_type = SALT_TYPE_INTERN;
7474 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7475 opts_type = OPTS_TYPE_PT_GENERATE_BE
7476 | OPTS_TYPE_PT_ADD80
7477 | OPTS_TYPE_PT_ADDBITS15;
7478 kern_type = KERN_TYPE_HMACSHA1_SLT;
7479 dgst_size = DGST_SIZE_4_5;
7480 parse_func = hmacsha1_parse_hash;
7481 sort_by_digest = sort_by_digest_4_5;
7482 opti_type = OPTI_TYPE_ZERO_BYTE
7483 | OPTI_TYPE_NOT_ITERATED;
7484 dgst_pos0 = 3;
7485 dgst_pos1 = 4;
7486 dgst_pos2 = 2;
7487 dgst_pos3 = 1;
7488 break;
7489
7490 case 190: hash_type = HASH_TYPE_SHA1;
7491 salt_type = SALT_TYPE_NONE;
7492 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7493 opts_type = OPTS_TYPE_PT_GENERATE_BE
7494 | OPTS_TYPE_PT_ADD80
7495 | OPTS_TYPE_PT_ADDBITS15;
7496 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7497 dgst_size = DGST_SIZE_4_5;
7498 parse_func = sha1linkedin_parse_hash;
7499 sort_by_digest = sort_by_digest_4_5;
7500 opti_type = OPTI_TYPE_ZERO_BYTE
7501 | OPTI_TYPE_PRECOMPUTE_INIT
7502 | OPTI_TYPE_EARLY_SKIP
7503 | OPTI_TYPE_NOT_ITERATED
7504 | OPTI_TYPE_NOT_SALTED;
7505 dgst_pos0 = 0;
7506 dgst_pos1 = 4;
7507 dgst_pos2 = 3;
7508 dgst_pos3 = 2;
7509 break;
7510
7511 case 200: hash_type = HASH_TYPE_MYSQL;
7512 salt_type = SALT_TYPE_NONE;
7513 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7514 opts_type = 0;
7515 kern_type = KERN_TYPE_MYSQL;
7516 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7517 parse_func = mysql323_parse_hash;
7518 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7519 opti_type = OPTI_TYPE_ZERO_BYTE;
7520 dgst_pos0 = 0;
7521 dgst_pos1 = 1;
7522 dgst_pos2 = 2;
7523 dgst_pos3 = 3;
7524 break;
7525
7526 case 300: hash_type = HASH_TYPE_SHA1;
7527 salt_type = SALT_TYPE_NONE;
7528 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7529 opts_type = OPTS_TYPE_PT_GENERATE_BE
7530 | OPTS_TYPE_PT_ADD80
7531 | OPTS_TYPE_PT_ADDBITS15;
7532 kern_type = KERN_TYPE_MYSQL41;
7533 dgst_size = DGST_SIZE_4_5;
7534 parse_func = sha1_parse_hash;
7535 sort_by_digest = sort_by_digest_4_5;
7536 opti_type = OPTI_TYPE_ZERO_BYTE
7537 | OPTI_TYPE_PRECOMPUTE_INIT
7538 | OPTI_TYPE_PRECOMPUTE_MERKLE
7539 | OPTI_TYPE_EARLY_SKIP
7540 | OPTI_TYPE_NOT_ITERATED
7541 | OPTI_TYPE_NOT_SALTED;
7542 dgst_pos0 = 3;
7543 dgst_pos1 = 4;
7544 dgst_pos2 = 2;
7545 dgst_pos3 = 1;
7546 break;
7547
7548 case 400: hash_type = HASH_TYPE_MD5;
7549 salt_type = SALT_TYPE_EMBEDDED;
7550 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7551 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7552 kern_type = KERN_TYPE_PHPASS;
7553 dgst_size = DGST_SIZE_4_4;
7554 parse_func = phpass_parse_hash;
7555 sort_by_digest = sort_by_digest_4_4;
7556 opti_type = OPTI_TYPE_ZERO_BYTE;
7557 dgst_pos0 = 0;
7558 dgst_pos1 = 1;
7559 dgst_pos2 = 2;
7560 dgst_pos3 = 3;
7561 break;
7562
7563 case 500: hash_type = HASH_TYPE_MD5;
7564 salt_type = SALT_TYPE_EMBEDDED;
7565 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7566 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7567 kern_type = KERN_TYPE_MD5CRYPT;
7568 dgst_size = DGST_SIZE_4_4;
7569 parse_func = md5crypt_parse_hash;
7570 sort_by_digest = sort_by_digest_4_4;
7571 opti_type = OPTI_TYPE_ZERO_BYTE;
7572 dgst_pos0 = 0;
7573 dgst_pos1 = 1;
7574 dgst_pos2 = 2;
7575 dgst_pos3 = 3;
7576 break;
7577
7578 case 501: hash_type = HASH_TYPE_MD5;
7579 salt_type = SALT_TYPE_EMBEDDED;
7580 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7581 opts_type = OPTS_TYPE_PT_GENERATE_LE
7582 | OPTS_TYPE_HASH_COPY;
7583 kern_type = KERN_TYPE_MD5CRYPT;
7584 dgst_size = DGST_SIZE_4_4;
7585 parse_func = juniper_parse_hash;
7586 sort_by_digest = sort_by_digest_4_4;
7587 opti_type = OPTI_TYPE_ZERO_BYTE;
7588 dgst_pos0 = 0;
7589 dgst_pos1 = 1;
7590 dgst_pos2 = 2;
7591 dgst_pos3 = 3;
7592 break;
7593
7594 case 900: hash_type = HASH_TYPE_MD4;
7595 salt_type = SALT_TYPE_NONE;
7596 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7597 opts_type = OPTS_TYPE_PT_GENERATE_LE
7598 | OPTS_TYPE_PT_ADD80
7599 | OPTS_TYPE_PT_ADDBITS14;
7600 kern_type = KERN_TYPE_MD4;
7601 dgst_size = DGST_SIZE_4_4;
7602 parse_func = md4_parse_hash;
7603 sort_by_digest = sort_by_digest_4_4;
7604 opti_type = OPTI_TYPE_ZERO_BYTE
7605 | OPTI_TYPE_PRECOMPUTE_INIT
7606 | OPTI_TYPE_PRECOMPUTE_MERKLE
7607 | OPTI_TYPE_MEET_IN_MIDDLE
7608 | OPTI_TYPE_EARLY_SKIP
7609 | OPTI_TYPE_NOT_ITERATED
7610 | OPTI_TYPE_NOT_SALTED
7611 | OPTI_TYPE_RAW_HASH;
7612 dgst_pos0 = 0;
7613 dgst_pos1 = 3;
7614 dgst_pos2 = 2;
7615 dgst_pos3 = 1;
7616 break;
7617
7618 case 1000: hash_type = HASH_TYPE_MD4;
7619 salt_type = SALT_TYPE_NONE;
7620 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7621 opts_type = OPTS_TYPE_PT_GENERATE_LE
7622 | OPTS_TYPE_PT_ADD80
7623 | OPTS_TYPE_PT_ADDBITS14
7624 | OPTS_TYPE_PT_UNICODE;
7625 kern_type = KERN_TYPE_MD4_PWU;
7626 dgst_size = DGST_SIZE_4_4;
7627 parse_func = md4_parse_hash;
7628 sort_by_digest = sort_by_digest_4_4;
7629 opti_type = OPTI_TYPE_ZERO_BYTE
7630 | OPTI_TYPE_PRECOMPUTE_INIT
7631 | OPTI_TYPE_PRECOMPUTE_MERKLE
7632 | OPTI_TYPE_MEET_IN_MIDDLE
7633 | OPTI_TYPE_EARLY_SKIP
7634 | OPTI_TYPE_NOT_ITERATED
7635 | OPTI_TYPE_NOT_SALTED
7636 | OPTI_TYPE_RAW_HASH;
7637 dgst_pos0 = 0;
7638 dgst_pos1 = 3;
7639 dgst_pos2 = 2;
7640 dgst_pos3 = 1;
7641 break;
7642
7643 case 1100: hash_type = HASH_TYPE_MD4;
7644 salt_type = SALT_TYPE_INTERN;
7645 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7646 opts_type = OPTS_TYPE_PT_GENERATE_LE
7647 | OPTS_TYPE_PT_ADD80
7648 | OPTS_TYPE_PT_ADDBITS14
7649 | OPTS_TYPE_PT_UNICODE
7650 | OPTS_TYPE_ST_ADD80
7651 | OPTS_TYPE_ST_UNICODE
7652 | OPTS_TYPE_ST_LOWER;
7653 kern_type = KERN_TYPE_MD44_PWUSLT;
7654 dgst_size = DGST_SIZE_4_4;
7655 parse_func = dcc_parse_hash;
7656 sort_by_digest = sort_by_digest_4_4;
7657 opti_type = OPTI_TYPE_ZERO_BYTE
7658 | OPTI_TYPE_PRECOMPUTE_INIT
7659 | OPTI_TYPE_PRECOMPUTE_MERKLE
7660 | OPTI_TYPE_EARLY_SKIP
7661 | OPTI_TYPE_NOT_ITERATED;
7662 dgst_pos0 = 0;
7663 dgst_pos1 = 3;
7664 dgst_pos2 = 2;
7665 dgst_pos3 = 1;
7666 break;
7667
7668 case 1400: hash_type = HASH_TYPE_SHA256;
7669 salt_type = SALT_TYPE_NONE;
7670 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7671 opts_type = OPTS_TYPE_PT_GENERATE_BE
7672 | OPTS_TYPE_PT_ADD80
7673 | OPTS_TYPE_PT_ADDBITS15;
7674 kern_type = KERN_TYPE_SHA256;
7675 dgst_size = DGST_SIZE_4_8;
7676 parse_func = sha256_parse_hash;
7677 sort_by_digest = sort_by_digest_4_8;
7678 opti_type = OPTI_TYPE_ZERO_BYTE
7679 | OPTI_TYPE_PRECOMPUTE_INIT
7680 | OPTI_TYPE_PRECOMPUTE_MERKLE
7681 | OPTI_TYPE_EARLY_SKIP
7682 | OPTI_TYPE_NOT_ITERATED
7683 | OPTI_TYPE_NOT_SALTED
7684 | OPTI_TYPE_RAW_HASH;
7685 dgst_pos0 = 3;
7686 dgst_pos1 = 7;
7687 dgst_pos2 = 2;
7688 dgst_pos3 = 6;
7689 break;
7690
7691 case 1410: hash_type = HASH_TYPE_SHA256;
7692 salt_type = SALT_TYPE_INTERN;
7693 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7694 opts_type = OPTS_TYPE_PT_GENERATE_BE
7695 | OPTS_TYPE_ST_ADD80
7696 | OPTS_TYPE_ST_ADDBITS15;
7697 kern_type = KERN_TYPE_SHA256_PWSLT;
7698 dgst_size = DGST_SIZE_4_8;
7699 parse_func = sha256s_parse_hash;
7700 sort_by_digest = sort_by_digest_4_8;
7701 opti_type = OPTI_TYPE_ZERO_BYTE
7702 | OPTI_TYPE_PRECOMPUTE_INIT
7703 | OPTI_TYPE_PRECOMPUTE_MERKLE
7704 | OPTI_TYPE_EARLY_SKIP
7705 | OPTI_TYPE_NOT_ITERATED
7706 | OPTI_TYPE_APPENDED_SALT
7707 | OPTI_TYPE_RAW_HASH;
7708 dgst_pos0 = 3;
7709 dgst_pos1 = 7;
7710 dgst_pos2 = 2;
7711 dgst_pos3 = 6;
7712 break;
7713
7714 case 1420: hash_type = HASH_TYPE_SHA256;
7715 salt_type = SALT_TYPE_INTERN;
7716 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7717 opts_type = OPTS_TYPE_PT_GENERATE_BE
7718 | OPTS_TYPE_PT_ADD80
7719 | OPTS_TYPE_PT_ADDBITS15;
7720 kern_type = KERN_TYPE_SHA256_SLTPW;
7721 dgst_size = DGST_SIZE_4_8;
7722 parse_func = sha256s_parse_hash;
7723 sort_by_digest = sort_by_digest_4_8;
7724 opti_type = OPTI_TYPE_ZERO_BYTE
7725 | OPTI_TYPE_PRECOMPUTE_INIT
7726 | OPTI_TYPE_PRECOMPUTE_MERKLE
7727 | OPTI_TYPE_EARLY_SKIP
7728 | OPTI_TYPE_NOT_ITERATED
7729 | OPTI_TYPE_PREPENDED_SALT
7730 | OPTI_TYPE_RAW_HASH;
7731 dgst_pos0 = 3;
7732 dgst_pos1 = 7;
7733 dgst_pos2 = 2;
7734 dgst_pos3 = 6;
7735 break;
7736
7737 case 1421: hash_type = HASH_TYPE_SHA256;
7738 salt_type = SALT_TYPE_EMBEDDED;
7739 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7740 opts_type = OPTS_TYPE_PT_GENERATE_BE
7741 | OPTS_TYPE_PT_ADD80
7742 | OPTS_TYPE_PT_ADDBITS15;
7743 kern_type = KERN_TYPE_SHA256_SLTPW;
7744 dgst_size = DGST_SIZE_4_8;
7745 parse_func = hmailserver_parse_hash;
7746 sort_by_digest = sort_by_digest_4_8;
7747 opti_type = OPTI_TYPE_ZERO_BYTE
7748 | OPTI_TYPE_PRECOMPUTE_INIT
7749 | OPTI_TYPE_PRECOMPUTE_MERKLE
7750 | OPTI_TYPE_EARLY_SKIP
7751 | OPTI_TYPE_NOT_ITERATED
7752 | OPTI_TYPE_PREPENDED_SALT
7753 | OPTI_TYPE_RAW_HASH;
7754 dgst_pos0 = 3;
7755 dgst_pos1 = 7;
7756 dgst_pos2 = 2;
7757 dgst_pos3 = 6;
7758 break;
7759
7760 case 1430: hash_type = HASH_TYPE_SHA256;
7761 salt_type = SALT_TYPE_INTERN;
7762 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7763 opts_type = OPTS_TYPE_PT_GENERATE_BE
7764 | OPTS_TYPE_PT_UNICODE
7765 | OPTS_TYPE_ST_ADD80
7766 | OPTS_TYPE_ST_ADDBITS15;
7767 kern_type = KERN_TYPE_SHA256_PWUSLT;
7768 dgst_size = DGST_SIZE_4_8;
7769 parse_func = sha256s_parse_hash;
7770 sort_by_digest = sort_by_digest_4_8;
7771 opti_type = OPTI_TYPE_ZERO_BYTE
7772 | OPTI_TYPE_PRECOMPUTE_INIT
7773 | OPTI_TYPE_PRECOMPUTE_MERKLE
7774 | OPTI_TYPE_EARLY_SKIP
7775 | OPTI_TYPE_NOT_ITERATED
7776 | OPTI_TYPE_APPENDED_SALT
7777 | OPTI_TYPE_RAW_HASH;
7778 dgst_pos0 = 3;
7779 dgst_pos1 = 7;
7780 dgst_pos2 = 2;
7781 dgst_pos3 = 6;
7782 break;
7783
7784 case 1440: hash_type = HASH_TYPE_SHA256;
7785 salt_type = SALT_TYPE_INTERN;
7786 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7787 opts_type = OPTS_TYPE_PT_GENERATE_BE
7788 | OPTS_TYPE_PT_ADD80
7789 | OPTS_TYPE_PT_ADDBITS15
7790 | OPTS_TYPE_PT_UNICODE;
7791 kern_type = KERN_TYPE_SHA256_SLTPWU;
7792 dgst_size = DGST_SIZE_4_8;
7793 parse_func = sha256s_parse_hash;
7794 sort_by_digest = sort_by_digest_4_8;
7795 opti_type = OPTI_TYPE_ZERO_BYTE
7796 | OPTI_TYPE_PRECOMPUTE_INIT
7797 | OPTI_TYPE_PRECOMPUTE_MERKLE
7798 | OPTI_TYPE_EARLY_SKIP
7799 | OPTI_TYPE_NOT_ITERATED
7800 | OPTI_TYPE_PREPENDED_SALT
7801 | OPTI_TYPE_RAW_HASH;
7802 dgst_pos0 = 3;
7803 dgst_pos1 = 7;
7804 dgst_pos2 = 2;
7805 dgst_pos3 = 6;
7806 break;
7807
7808 case 1441: hash_type = HASH_TYPE_SHA256;
7809 salt_type = SALT_TYPE_EMBEDDED;
7810 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7811 opts_type = OPTS_TYPE_PT_GENERATE_BE
7812 | OPTS_TYPE_PT_ADD80
7813 | OPTS_TYPE_PT_ADDBITS15
7814 | OPTS_TYPE_PT_UNICODE
7815 | OPTS_TYPE_ST_BASE64;
7816 kern_type = KERN_TYPE_SHA256_SLTPWU;
7817 dgst_size = DGST_SIZE_4_8;
7818 parse_func = episerver4_parse_hash;
7819 sort_by_digest = sort_by_digest_4_8;
7820 opti_type = OPTI_TYPE_ZERO_BYTE
7821 | OPTI_TYPE_PRECOMPUTE_INIT
7822 | OPTI_TYPE_PRECOMPUTE_MERKLE
7823 | OPTI_TYPE_EARLY_SKIP
7824 | OPTI_TYPE_NOT_ITERATED
7825 | OPTI_TYPE_PREPENDED_SALT
7826 | OPTI_TYPE_RAW_HASH;
7827 dgst_pos0 = 3;
7828 dgst_pos1 = 7;
7829 dgst_pos2 = 2;
7830 dgst_pos3 = 6;
7831 break;
7832
7833 case 1450: hash_type = HASH_TYPE_SHA256;
7834 salt_type = SALT_TYPE_INTERN;
7835 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7836 opts_type = OPTS_TYPE_PT_GENERATE_BE
7837 | OPTS_TYPE_ST_ADD80;
7838 kern_type = KERN_TYPE_HMACSHA256_PW;
7839 dgst_size = DGST_SIZE_4_8;
7840 parse_func = hmacsha256_parse_hash;
7841 sort_by_digest = sort_by_digest_4_8;
7842 opti_type = OPTI_TYPE_ZERO_BYTE
7843 | OPTI_TYPE_NOT_ITERATED;
7844 dgst_pos0 = 3;
7845 dgst_pos1 = 7;
7846 dgst_pos2 = 2;
7847 dgst_pos3 = 6;
7848 break;
7849
7850 case 1460: hash_type = HASH_TYPE_SHA256;
7851 salt_type = SALT_TYPE_INTERN;
7852 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7853 opts_type = OPTS_TYPE_PT_GENERATE_BE
7854 | OPTS_TYPE_PT_ADD80
7855 | OPTS_TYPE_PT_ADDBITS15;
7856 kern_type = KERN_TYPE_HMACSHA256_SLT;
7857 dgst_size = DGST_SIZE_4_8;
7858 parse_func = hmacsha256_parse_hash;
7859 sort_by_digest = sort_by_digest_4_8;
7860 opti_type = OPTI_TYPE_ZERO_BYTE
7861 | OPTI_TYPE_NOT_ITERATED;
7862 dgst_pos0 = 3;
7863 dgst_pos1 = 7;
7864 dgst_pos2 = 2;
7865 dgst_pos3 = 6;
7866 break;
7867
7868 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7869 salt_type = SALT_TYPE_EMBEDDED;
7870 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7871 opts_type = OPTS_TYPE_PT_GENERATE_LE
7872 | OPTS_TYPE_PT_BITSLICE;
7873 kern_type = KERN_TYPE_DESCRYPT;
7874 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7875 parse_func = descrypt_parse_hash;
7876 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7877 opti_type = OPTI_TYPE_ZERO_BYTE
7878 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7879 dgst_pos0 = 0;
7880 dgst_pos1 = 1;
7881 dgst_pos2 = 2;
7882 dgst_pos3 = 3;
7883 break;
7884
7885 case 1600: hash_type = HASH_TYPE_MD5;
7886 salt_type = SALT_TYPE_EMBEDDED;
7887 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7888 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7889 kern_type = KERN_TYPE_APR1CRYPT;
7890 dgst_size = DGST_SIZE_4_4;
7891 parse_func = md5apr1_parse_hash;
7892 sort_by_digest = sort_by_digest_4_4;
7893 opti_type = OPTI_TYPE_ZERO_BYTE;
7894 dgst_pos0 = 0;
7895 dgst_pos1 = 1;
7896 dgst_pos2 = 2;
7897 dgst_pos3 = 3;
7898 break;
7899
7900 case 1700: hash_type = HASH_TYPE_SHA512;
7901 salt_type = SALT_TYPE_NONE;
7902 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7903 opts_type = OPTS_TYPE_PT_GENERATE_BE
7904 | OPTS_TYPE_PT_ADD80
7905 | OPTS_TYPE_PT_ADDBITS15;
7906 kern_type = KERN_TYPE_SHA512;
7907 dgst_size = DGST_SIZE_8_8;
7908 parse_func = sha512_parse_hash;
7909 sort_by_digest = sort_by_digest_8_8;
7910 opti_type = OPTI_TYPE_ZERO_BYTE
7911 | OPTI_TYPE_PRECOMPUTE_INIT
7912 | OPTI_TYPE_PRECOMPUTE_MERKLE
7913 | OPTI_TYPE_EARLY_SKIP
7914 | OPTI_TYPE_NOT_ITERATED
7915 | OPTI_TYPE_NOT_SALTED
7916 | OPTI_TYPE_USES_BITS_64
7917 | OPTI_TYPE_RAW_HASH;
7918 dgst_pos0 = 14;
7919 dgst_pos1 = 15;
7920 dgst_pos2 = 6;
7921 dgst_pos3 = 7;
7922 break;
7923
7924 case 1710: hash_type = HASH_TYPE_SHA512;
7925 salt_type = SALT_TYPE_INTERN;
7926 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7927 opts_type = OPTS_TYPE_PT_GENERATE_BE
7928 | OPTS_TYPE_ST_ADD80
7929 | OPTS_TYPE_ST_ADDBITS15;
7930 kern_type = KERN_TYPE_SHA512_PWSLT;
7931 dgst_size = DGST_SIZE_8_8;
7932 parse_func = sha512s_parse_hash;
7933 sort_by_digest = sort_by_digest_8_8;
7934 opti_type = OPTI_TYPE_ZERO_BYTE
7935 | OPTI_TYPE_PRECOMPUTE_INIT
7936 | OPTI_TYPE_PRECOMPUTE_MERKLE
7937 | OPTI_TYPE_EARLY_SKIP
7938 | OPTI_TYPE_NOT_ITERATED
7939 | OPTI_TYPE_APPENDED_SALT
7940 | OPTI_TYPE_USES_BITS_64
7941 | OPTI_TYPE_RAW_HASH;
7942 dgst_pos0 = 14;
7943 dgst_pos1 = 15;
7944 dgst_pos2 = 6;
7945 dgst_pos3 = 7;
7946 break;
7947
7948 case 1711: hash_type = HASH_TYPE_SHA512;
7949 salt_type = SALT_TYPE_EMBEDDED;
7950 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7951 opts_type = OPTS_TYPE_PT_GENERATE_BE
7952 | OPTS_TYPE_ST_ADD80
7953 | OPTS_TYPE_ST_ADDBITS15;
7954 kern_type = KERN_TYPE_SHA512_PWSLT;
7955 dgst_size = DGST_SIZE_8_8;
7956 parse_func = sha512b64s_parse_hash;
7957 sort_by_digest = sort_by_digest_8_8;
7958 opti_type = OPTI_TYPE_ZERO_BYTE
7959 | OPTI_TYPE_PRECOMPUTE_INIT
7960 | OPTI_TYPE_PRECOMPUTE_MERKLE
7961 | OPTI_TYPE_EARLY_SKIP
7962 | OPTI_TYPE_NOT_ITERATED
7963 | OPTI_TYPE_APPENDED_SALT
7964 | OPTI_TYPE_USES_BITS_64
7965 | OPTI_TYPE_RAW_HASH;
7966 dgst_pos0 = 14;
7967 dgst_pos1 = 15;
7968 dgst_pos2 = 6;
7969 dgst_pos3 = 7;
7970 break;
7971
7972 case 1720: hash_type = HASH_TYPE_SHA512;
7973 salt_type = SALT_TYPE_INTERN;
7974 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7975 opts_type = OPTS_TYPE_PT_GENERATE_BE
7976 | OPTS_TYPE_PT_ADD80
7977 | OPTS_TYPE_PT_ADDBITS15;
7978 kern_type = KERN_TYPE_SHA512_SLTPW;
7979 dgst_size = DGST_SIZE_8_8;
7980 parse_func = sha512s_parse_hash;
7981 sort_by_digest = sort_by_digest_8_8;
7982 opti_type = OPTI_TYPE_ZERO_BYTE
7983 | OPTI_TYPE_PRECOMPUTE_INIT
7984 | OPTI_TYPE_PRECOMPUTE_MERKLE
7985 | OPTI_TYPE_EARLY_SKIP
7986 | OPTI_TYPE_NOT_ITERATED
7987 | OPTI_TYPE_PREPENDED_SALT
7988 | OPTI_TYPE_USES_BITS_64
7989 | OPTI_TYPE_RAW_HASH;
7990 dgst_pos0 = 14;
7991 dgst_pos1 = 15;
7992 dgst_pos2 = 6;
7993 dgst_pos3 = 7;
7994 break;
7995
7996 case 1722: hash_type = HASH_TYPE_SHA512;
7997 salt_type = SALT_TYPE_EMBEDDED;
7998 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7999 opts_type = OPTS_TYPE_PT_GENERATE_BE
8000 | OPTS_TYPE_PT_ADD80
8001 | OPTS_TYPE_PT_ADDBITS15
8002 | OPTS_TYPE_ST_HEX;
8003 kern_type = KERN_TYPE_SHA512_SLTPW;
8004 dgst_size = DGST_SIZE_8_8;
8005 parse_func = osx512_parse_hash;
8006 sort_by_digest = sort_by_digest_8_8;
8007 opti_type = OPTI_TYPE_ZERO_BYTE
8008 | OPTI_TYPE_PRECOMPUTE_INIT
8009 | OPTI_TYPE_PRECOMPUTE_MERKLE
8010 | OPTI_TYPE_EARLY_SKIP
8011 | OPTI_TYPE_NOT_ITERATED
8012 | OPTI_TYPE_PREPENDED_SALT
8013 | OPTI_TYPE_USES_BITS_64
8014 | OPTI_TYPE_RAW_HASH;
8015 dgst_pos0 = 14;
8016 dgst_pos1 = 15;
8017 dgst_pos2 = 6;
8018 dgst_pos3 = 7;
8019 break;
8020
8021 case 1730: hash_type = HASH_TYPE_SHA512;
8022 salt_type = SALT_TYPE_INTERN;
8023 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8024 opts_type = OPTS_TYPE_PT_GENERATE_BE
8025 | OPTS_TYPE_PT_UNICODE
8026 | OPTS_TYPE_ST_ADD80
8027 | OPTS_TYPE_ST_ADDBITS15;
8028 kern_type = KERN_TYPE_SHA512_PWSLTU;
8029 dgst_size = DGST_SIZE_8_8;
8030 parse_func = sha512s_parse_hash;
8031 sort_by_digest = sort_by_digest_8_8;
8032 opti_type = OPTI_TYPE_ZERO_BYTE
8033 | OPTI_TYPE_PRECOMPUTE_INIT
8034 | OPTI_TYPE_PRECOMPUTE_MERKLE
8035 | OPTI_TYPE_EARLY_SKIP
8036 | OPTI_TYPE_NOT_ITERATED
8037 | OPTI_TYPE_APPENDED_SALT
8038 | OPTI_TYPE_USES_BITS_64
8039 | OPTI_TYPE_RAW_HASH;
8040 dgst_pos0 = 14;
8041 dgst_pos1 = 15;
8042 dgst_pos2 = 6;
8043 dgst_pos3 = 7;
8044 break;
8045
8046 case 1731: hash_type = HASH_TYPE_SHA512;
8047 salt_type = SALT_TYPE_EMBEDDED;
8048 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8049 opts_type = OPTS_TYPE_PT_GENERATE_BE
8050 | OPTS_TYPE_PT_UNICODE
8051 | OPTS_TYPE_ST_ADD80
8052 | OPTS_TYPE_ST_ADDBITS15
8053 | OPTS_TYPE_ST_HEX;
8054 kern_type = KERN_TYPE_SHA512_PWSLTU;
8055 dgst_size = DGST_SIZE_8_8;
8056 parse_func = mssql2012_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 1740: hash_type = HASH_TYPE_SHA512;
8073 salt_type = SALT_TYPE_INTERN;
8074 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8075 opts_type = OPTS_TYPE_PT_GENERATE_BE
8076 | OPTS_TYPE_PT_ADD80
8077 | OPTS_TYPE_PT_ADDBITS15
8078 | OPTS_TYPE_PT_UNICODE;
8079 kern_type = KERN_TYPE_SHA512_SLTPWU;
8080 dgst_size = DGST_SIZE_8_8;
8081 parse_func = sha512s_parse_hash;
8082 sort_by_digest = sort_by_digest_8_8;
8083 opti_type = OPTI_TYPE_ZERO_BYTE
8084 | OPTI_TYPE_PRECOMPUTE_INIT
8085 | OPTI_TYPE_PRECOMPUTE_MERKLE
8086 | OPTI_TYPE_EARLY_SKIP
8087 | OPTI_TYPE_NOT_ITERATED
8088 | OPTI_TYPE_PREPENDED_SALT
8089 | OPTI_TYPE_USES_BITS_64
8090 | OPTI_TYPE_RAW_HASH;
8091 dgst_pos0 = 14;
8092 dgst_pos1 = 15;
8093 dgst_pos2 = 6;
8094 dgst_pos3 = 7;
8095 break;
8096
8097 case 1750: hash_type = HASH_TYPE_SHA512;
8098 salt_type = SALT_TYPE_INTERN;
8099 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8100 opts_type = OPTS_TYPE_PT_GENERATE_BE
8101 | OPTS_TYPE_ST_ADD80;
8102 kern_type = KERN_TYPE_HMACSHA512_PW;
8103 dgst_size = DGST_SIZE_8_8;
8104 parse_func = hmacsha512_parse_hash;
8105 sort_by_digest = sort_by_digest_8_8;
8106 opti_type = OPTI_TYPE_ZERO_BYTE
8107 | OPTI_TYPE_USES_BITS_64
8108 | OPTI_TYPE_NOT_ITERATED;
8109 dgst_pos0 = 14;
8110 dgst_pos1 = 15;
8111 dgst_pos2 = 6;
8112 dgst_pos3 = 7;
8113 break;
8114
8115 case 1760: hash_type = HASH_TYPE_SHA512;
8116 salt_type = SALT_TYPE_INTERN;
8117 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8118 opts_type = OPTS_TYPE_PT_GENERATE_BE
8119 | OPTS_TYPE_PT_ADD80
8120 | OPTS_TYPE_PT_ADDBITS15;
8121 kern_type = KERN_TYPE_HMACSHA512_SLT;
8122 dgst_size = DGST_SIZE_8_8;
8123 parse_func = hmacsha512_parse_hash;
8124 sort_by_digest = sort_by_digest_8_8;
8125 opti_type = OPTI_TYPE_ZERO_BYTE
8126 | OPTI_TYPE_USES_BITS_64
8127 | OPTI_TYPE_NOT_ITERATED;
8128 dgst_pos0 = 14;
8129 dgst_pos1 = 15;
8130 dgst_pos2 = 6;
8131 dgst_pos3 = 7;
8132 break;
8133
8134 case 1800: hash_type = HASH_TYPE_SHA512;
8135 salt_type = SALT_TYPE_EMBEDDED;
8136 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8137 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8138 kern_type = KERN_TYPE_SHA512CRYPT;
8139 dgst_size = DGST_SIZE_8_8;
8140 parse_func = sha512crypt_parse_hash;
8141 sort_by_digest = sort_by_digest_8_8;
8142 opti_type = OPTI_TYPE_ZERO_BYTE
8143 | OPTI_TYPE_USES_BITS_64;
8144 dgst_pos0 = 0;
8145 dgst_pos1 = 1;
8146 dgst_pos2 = 2;
8147 dgst_pos3 = 3;
8148 break;
8149
8150 case 2100: hash_type = HASH_TYPE_DCC2;
8151 salt_type = SALT_TYPE_EMBEDDED;
8152 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8153 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8154 | OPTS_TYPE_ST_LOWER
8155 | OPTS_TYPE_ST_UNICODE;
8156 kern_type = KERN_TYPE_DCC2;
8157 dgst_size = DGST_SIZE_4_4;
8158 parse_func = dcc2_parse_hash;
8159 sort_by_digest = sort_by_digest_4_4;
8160 opti_type = OPTI_TYPE_ZERO_BYTE;
8161 dgst_pos0 = 0;
8162 dgst_pos1 = 1;
8163 dgst_pos2 = 2;
8164 dgst_pos3 = 3;
8165 break;
8166
8167 case 2400: hash_type = HASH_TYPE_MD5;
8168 salt_type = SALT_TYPE_NONE;
8169 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8170 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8171 kern_type = KERN_TYPE_MD5PIX;
8172 dgst_size = DGST_SIZE_4_4;
8173 parse_func = md5pix_parse_hash;
8174 sort_by_digest = sort_by_digest_4_4;
8175 opti_type = OPTI_TYPE_ZERO_BYTE
8176 | OPTI_TYPE_PRECOMPUTE_INIT
8177 | OPTI_TYPE_PRECOMPUTE_MERKLE
8178 | OPTI_TYPE_EARLY_SKIP
8179 | OPTI_TYPE_NOT_ITERATED
8180 | OPTI_TYPE_NOT_SALTED;
8181 dgst_pos0 = 0;
8182 dgst_pos1 = 3;
8183 dgst_pos2 = 2;
8184 dgst_pos3 = 1;
8185 break;
8186
8187 case 2410: hash_type = HASH_TYPE_MD5;
8188 salt_type = SALT_TYPE_INTERN;
8189 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8190 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8191 kern_type = KERN_TYPE_MD5ASA;
8192 dgst_size = DGST_SIZE_4_4;
8193 parse_func = md5asa_parse_hash;
8194 sort_by_digest = sort_by_digest_4_4;
8195 opti_type = OPTI_TYPE_ZERO_BYTE
8196 | OPTI_TYPE_PRECOMPUTE_INIT
8197 | OPTI_TYPE_PRECOMPUTE_MERKLE
8198 | OPTI_TYPE_EARLY_SKIP
8199 | OPTI_TYPE_NOT_ITERATED;
8200 dgst_pos0 = 0;
8201 dgst_pos1 = 3;
8202 dgst_pos2 = 2;
8203 dgst_pos3 = 1;
8204 break;
8205
8206 case 2500: hash_type = HASH_TYPE_WPA;
8207 salt_type = SALT_TYPE_EMBEDDED;
8208 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8209 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8210 kern_type = KERN_TYPE_WPA;
8211 dgst_size = DGST_SIZE_4_4;
8212 parse_func = wpa_parse_hash;
8213 sort_by_digest = sort_by_digest_4_4;
8214 opti_type = OPTI_TYPE_ZERO_BYTE;
8215 dgst_pos0 = 0;
8216 dgst_pos1 = 1;
8217 dgst_pos2 = 2;
8218 dgst_pos3 = 3;
8219 break;
8220
8221 case 2600: hash_type = HASH_TYPE_MD5;
8222 salt_type = SALT_TYPE_VIRTUAL;
8223 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8224 opts_type = OPTS_TYPE_PT_GENERATE_LE
8225 | OPTS_TYPE_PT_ADD80
8226 | OPTS_TYPE_PT_ADDBITS14
8227 | OPTS_TYPE_ST_ADD80;
8228 kern_type = KERN_TYPE_MD55_PWSLT1;
8229 dgst_size = DGST_SIZE_4_4;
8230 parse_func = md5md5_parse_hash;
8231 sort_by_digest = sort_by_digest_4_4;
8232 opti_type = OPTI_TYPE_ZERO_BYTE
8233 | OPTI_TYPE_PRECOMPUTE_INIT
8234 | OPTI_TYPE_PRECOMPUTE_MERKLE
8235 | OPTI_TYPE_EARLY_SKIP;
8236 dgst_pos0 = 0;
8237 dgst_pos1 = 3;
8238 dgst_pos2 = 2;
8239 dgst_pos3 = 1;
8240 break;
8241
8242 case 2611: hash_type = HASH_TYPE_MD5;
8243 salt_type = SALT_TYPE_INTERN;
8244 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8245 opts_type = OPTS_TYPE_PT_GENERATE_LE
8246 | OPTS_TYPE_PT_ADD80
8247 | OPTS_TYPE_PT_ADDBITS14
8248 | OPTS_TYPE_ST_ADD80;
8249 kern_type = KERN_TYPE_MD55_PWSLT1;
8250 dgst_size = DGST_SIZE_4_4;
8251 parse_func = vb3_parse_hash;
8252 sort_by_digest = sort_by_digest_4_4;
8253 opti_type = OPTI_TYPE_ZERO_BYTE
8254 | OPTI_TYPE_PRECOMPUTE_INIT
8255 | OPTI_TYPE_PRECOMPUTE_MERKLE
8256 | OPTI_TYPE_EARLY_SKIP;
8257 dgst_pos0 = 0;
8258 dgst_pos1 = 3;
8259 dgst_pos2 = 2;
8260 dgst_pos3 = 1;
8261 break;
8262
8263 case 2612: hash_type = HASH_TYPE_MD5;
8264 salt_type = SALT_TYPE_EMBEDDED;
8265 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8266 opts_type = OPTS_TYPE_PT_GENERATE_LE
8267 | OPTS_TYPE_PT_ADD80
8268 | OPTS_TYPE_PT_ADDBITS14
8269 | OPTS_TYPE_ST_ADD80
8270 | OPTS_TYPE_ST_HEX;
8271 kern_type = KERN_TYPE_MD55_PWSLT1;
8272 dgst_size = DGST_SIZE_4_4;
8273 parse_func = phps_parse_hash;
8274 sort_by_digest = sort_by_digest_4_4;
8275 opti_type = OPTI_TYPE_ZERO_BYTE
8276 | OPTI_TYPE_PRECOMPUTE_INIT
8277 | OPTI_TYPE_PRECOMPUTE_MERKLE
8278 | OPTI_TYPE_EARLY_SKIP;
8279 dgst_pos0 = 0;
8280 dgst_pos1 = 3;
8281 dgst_pos2 = 2;
8282 dgst_pos3 = 1;
8283 break;
8284
8285 case 2711: hash_type = HASH_TYPE_MD5;
8286 salt_type = SALT_TYPE_INTERN;
8287 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8288 opts_type = OPTS_TYPE_PT_GENERATE_LE
8289 | OPTS_TYPE_PT_ADD80
8290 | OPTS_TYPE_PT_ADDBITS14
8291 | OPTS_TYPE_ST_ADD80;
8292 kern_type = KERN_TYPE_MD55_PWSLT2;
8293 dgst_size = DGST_SIZE_4_4;
8294 parse_func = vb30_parse_hash;
8295 sort_by_digest = sort_by_digest_4_4;
8296 opti_type = OPTI_TYPE_ZERO_BYTE
8297 | OPTI_TYPE_PRECOMPUTE_INIT
8298 | OPTI_TYPE_EARLY_SKIP;
8299 dgst_pos0 = 0;
8300 dgst_pos1 = 3;
8301 dgst_pos2 = 2;
8302 dgst_pos3 = 1;
8303 break;
8304
8305 case 2811: hash_type = HASH_TYPE_MD5;
8306 salt_type = SALT_TYPE_INTERN;
8307 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8308 opts_type = OPTS_TYPE_PT_GENERATE_LE
8309 | OPTS_TYPE_PT_ADD80
8310 | OPTS_TYPE_PT_ADDBITS14;
8311 kern_type = KERN_TYPE_MD55_SLTPW;
8312 dgst_size = DGST_SIZE_4_4;
8313 parse_func = ipb2_parse_hash;
8314 sort_by_digest = sort_by_digest_4_4;
8315 opti_type = OPTI_TYPE_ZERO_BYTE
8316 | OPTI_TYPE_PRECOMPUTE_INIT
8317 | OPTI_TYPE_EARLY_SKIP;
8318 dgst_pos0 = 0;
8319 dgst_pos1 = 3;
8320 dgst_pos2 = 2;
8321 dgst_pos3 = 1;
8322 break;
8323
8324 case 3000: hash_type = HASH_TYPE_LM;
8325 salt_type = SALT_TYPE_NONE;
8326 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8327 opts_type = OPTS_TYPE_PT_GENERATE_LE
8328 | OPTS_TYPE_PT_UPPER
8329 | OPTS_TYPE_PT_BITSLICE;
8330 kern_type = KERN_TYPE_LM;
8331 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8332 parse_func = lm_parse_hash;
8333 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8334 opti_type = OPTI_TYPE_ZERO_BYTE
8335 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8336 dgst_pos0 = 0;
8337 dgst_pos1 = 1;
8338 dgst_pos2 = 2;
8339 dgst_pos3 = 3;
8340 break;
8341
8342 case 3100: hash_type = HASH_TYPE_ORACLEH;
8343 salt_type = SALT_TYPE_INTERN;
8344 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8345 opts_type = OPTS_TYPE_PT_GENERATE_LE
8346 | OPTS_TYPE_PT_UPPER
8347 | OPTS_TYPE_ST_UPPER;
8348 kern_type = KERN_TYPE_ORACLEH;
8349 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8350 parse_func = oracleh_parse_hash;
8351 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8352 opti_type = OPTI_TYPE_ZERO_BYTE;
8353 dgst_pos0 = 0;
8354 dgst_pos1 = 1;
8355 dgst_pos2 = 2;
8356 dgst_pos3 = 3;
8357 break;
8358
8359 case 3200: hash_type = HASH_TYPE_BCRYPT;
8360 salt_type = SALT_TYPE_EMBEDDED;
8361 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8362 opts_type = OPTS_TYPE_PT_GENERATE_LE
8363 | OPTS_TYPE_ST_GENERATE_LE;
8364 kern_type = KERN_TYPE_BCRYPT;
8365 dgst_size = DGST_SIZE_4_6;
8366 parse_func = bcrypt_parse_hash;
8367 sort_by_digest = sort_by_digest_4_6;
8368 opti_type = OPTI_TYPE_ZERO_BYTE;
8369 dgst_pos0 = 0;
8370 dgst_pos1 = 1;
8371 dgst_pos2 = 2;
8372 dgst_pos3 = 3;
8373 break;
8374
8375 case 3710: hash_type = HASH_TYPE_MD5;
8376 salt_type = SALT_TYPE_INTERN;
8377 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8378 opts_type = OPTS_TYPE_PT_GENERATE_LE
8379 | OPTS_TYPE_PT_ADD80
8380 | OPTS_TYPE_PT_ADDBITS14;
8381 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8382 dgst_size = DGST_SIZE_4_4;
8383 parse_func = md5s_parse_hash;
8384 sort_by_digest = sort_by_digest_4_4;
8385 opti_type = OPTI_TYPE_ZERO_BYTE
8386 | OPTI_TYPE_PRECOMPUTE_INIT
8387 | OPTI_TYPE_PRECOMPUTE_MERKLE
8388 | OPTI_TYPE_EARLY_SKIP;
8389 dgst_pos0 = 0;
8390 dgst_pos1 = 3;
8391 dgst_pos2 = 2;
8392 dgst_pos3 = 1;
8393 break;
8394
8395 case 3711: hash_type = HASH_TYPE_MD5;
8396 salt_type = SALT_TYPE_EMBEDDED;
8397 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8398 opts_type = OPTS_TYPE_PT_GENERATE_LE
8399 | OPTS_TYPE_PT_ADD80
8400 | OPTS_TYPE_PT_ADDBITS14;
8401 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8402 dgst_size = DGST_SIZE_4_4;
8403 parse_func = mediawiki_b_parse_hash;
8404 sort_by_digest = sort_by_digest_4_4;
8405 opti_type = OPTI_TYPE_ZERO_BYTE
8406 | OPTI_TYPE_PRECOMPUTE_INIT
8407 | OPTI_TYPE_PRECOMPUTE_MERKLE
8408 | OPTI_TYPE_EARLY_SKIP;
8409 dgst_pos0 = 0;
8410 dgst_pos1 = 3;
8411 dgst_pos2 = 2;
8412 dgst_pos3 = 1;
8413 break;
8414
8415 case 3800: hash_type = HASH_TYPE_MD5;
8416 salt_type = SALT_TYPE_INTERN;
8417 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8418 opts_type = OPTS_TYPE_PT_GENERATE_LE
8419 | OPTS_TYPE_ST_ADDBITS14;
8420 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8421 dgst_size = DGST_SIZE_4_4;
8422 parse_func = md5s_parse_hash;
8423 sort_by_digest = sort_by_digest_4_4;
8424 opti_type = OPTI_TYPE_ZERO_BYTE
8425 | OPTI_TYPE_PRECOMPUTE_INIT
8426 | OPTI_TYPE_PRECOMPUTE_MERKLE
8427 | OPTI_TYPE_EARLY_SKIP
8428 | OPTI_TYPE_NOT_ITERATED
8429 | OPTI_TYPE_RAW_HASH;
8430 dgst_pos0 = 0;
8431 dgst_pos1 = 3;
8432 dgst_pos2 = 2;
8433 dgst_pos3 = 1;
8434 break;
8435
8436 case 4300: hash_type = HASH_TYPE_MD5;
8437 salt_type = SALT_TYPE_VIRTUAL;
8438 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8439 opts_type = OPTS_TYPE_PT_GENERATE_LE
8440 | OPTS_TYPE_PT_ADD80
8441 | OPTS_TYPE_PT_ADDBITS14
8442 | OPTS_TYPE_ST_ADD80;
8443 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8444 dgst_size = DGST_SIZE_4_4;
8445 parse_func = md5md5_parse_hash;
8446 sort_by_digest = sort_by_digest_4_4;
8447 opti_type = OPTI_TYPE_ZERO_BYTE
8448 | OPTI_TYPE_PRECOMPUTE_INIT
8449 | OPTI_TYPE_PRECOMPUTE_MERKLE
8450 | OPTI_TYPE_EARLY_SKIP;
8451 dgst_pos0 = 0;
8452 dgst_pos1 = 3;
8453 dgst_pos2 = 2;
8454 dgst_pos3 = 1;
8455 break;
8456
8457
8458 case 4400: hash_type = HASH_TYPE_MD5;
8459 salt_type = SALT_TYPE_NONE;
8460 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8461 opts_type = OPTS_TYPE_PT_GENERATE_BE
8462 | OPTS_TYPE_PT_ADD80
8463 | OPTS_TYPE_PT_ADDBITS15;
8464 kern_type = KERN_TYPE_MD5_SHA1;
8465 dgst_size = DGST_SIZE_4_4;
8466 parse_func = md5_parse_hash;
8467 sort_by_digest = sort_by_digest_4_4;
8468 opti_type = OPTI_TYPE_ZERO_BYTE
8469 | OPTI_TYPE_PRECOMPUTE_INIT
8470 | OPTI_TYPE_PRECOMPUTE_MERKLE
8471 | OPTI_TYPE_EARLY_SKIP
8472 | OPTI_TYPE_NOT_ITERATED
8473 | OPTI_TYPE_NOT_SALTED
8474 | OPTI_TYPE_RAW_HASH;
8475 dgst_pos0 = 0;
8476 dgst_pos1 = 3;
8477 dgst_pos2 = 2;
8478 dgst_pos3 = 1;
8479 break;
8480
8481 case 4500: hash_type = HASH_TYPE_SHA1;
8482 salt_type = SALT_TYPE_NONE;
8483 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8484 opts_type = OPTS_TYPE_PT_GENERATE_BE
8485 | OPTS_TYPE_PT_ADD80
8486 | OPTS_TYPE_PT_ADDBITS15;
8487 kern_type = KERN_TYPE_SHA11;
8488 dgst_size = DGST_SIZE_4_5;
8489 parse_func = sha1_parse_hash;
8490 sort_by_digest = sort_by_digest_4_5;
8491 opti_type = OPTI_TYPE_ZERO_BYTE
8492 | OPTI_TYPE_PRECOMPUTE_INIT
8493 | OPTI_TYPE_PRECOMPUTE_MERKLE
8494 | OPTI_TYPE_EARLY_SKIP
8495 | OPTI_TYPE_NOT_SALTED;
8496 dgst_pos0 = 3;
8497 dgst_pos1 = 4;
8498 dgst_pos2 = 2;
8499 dgst_pos3 = 1;
8500 break;
8501
8502 case 4700: hash_type = HASH_TYPE_SHA1;
8503 salt_type = SALT_TYPE_NONE;
8504 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8505 opts_type = OPTS_TYPE_PT_GENERATE_LE
8506 | OPTS_TYPE_PT_ADD80
8507 | OPTS_TYPE_PT_ADDBITS14;
8508 kern_type = KERN_TYPE_SHA1_MD5;
8509 dgst_size = DGST_SIZE_4_5;
8510 parse_func = sha1_parse_hash;
8511 sort_by_digest = sort_by_digest_4_5;
8512 opti_type = OPTI_TYPE_ZERO_BYTE
8513 | OPTI_TYPE_PRECOMPUTE_INIT
8514 | OPTI_TYPE_PRECOMPUTE_MERKLE
8515 | OPTI_TYPE_EARLY_SKIP
8516 | OPTI_TYPE_NOT_ITERATED
8517 | OPTI_TYPE_NOT_SALTED
8518 | OPTI_TYPE_RAW_HASH;
8519 dgst_pos0 = 3;
8520 dgst_pos1 = 4;
8521 dgst_pos2 = 2;
8522 dgst_pos3 = 1;
8523 break;
8524
8525 case 4800: hash_type = HASH_TYPE_MD5;
8526 salt_type = SALT_TYPE_EMBEDDED;
8527 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8528 opts_type = OPTS_TYPE_PT_GENERATE_LE
8529 | OPTS_TYPE_PT_ADDBITS14;
8530 kern_type = KERN_TYPE_MD5_CHAP;
8531 dgst_size = DGST_SIZE_4_4;
8532 parse_func = chap_parse_hash;
8533 sort_by_digest = sort_by_digest_4_4;
8534 opti_type = OPTI_TYPE_ZERO_BYTE
8535 | OPTI_TYPE_PRECOMPUTE_INIT
8536 | OPTI_TYPE_PRECOMPUTE_MERKLE
8537 | OPTI_TYPE_MEET_IN_MIDDLE
8538 | OPTI_TYPE_EARLY_SKIP
8539 | OPTI_TYPE_NOT_ITERATED
8540 | OPTI_TYPE_RAW_HASH;
8541 dgst_pos0 = 0;
8542 dgst_pos1 = 3;
8543 dgst_pos2 = 2;
8544 dgst_pos3 = 1;
8545 break;
8546
8547 case 4900: hash_type = HASH_TYPE_SHA1;
8548 salt_type = SALT_TYPE_INTERN;
8549 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8550 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8551 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8552 dgst_size = DGST_SIZE_4_5;
8553 parse_func = sha1s_parse_hash;
8554 sort_by_digest = sort_by_digest_4_5;
8555 opti_type = OPTI_TYPE_ZERO_BYTE
8556 | OPTI_TYPE_PRECOMPUTE_INIT
8557 | OPTI_TYPE_PRECOMPUTE_MERKLE
8558 | OPTI_TYPE_EARLY_SKIP;
8559 dgst_pos0 = 3;
8560 dgst_pos1 = 4;
8561 dgst_pos2 = 2;
8562 dgst_pos3 = 1;
8563 break;
8564
8565 case 5000: hash_type = HASH_TYPE_KECCAK;
8566 salt_type = SALT_TYPE_EMBEDDED;
8567 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8568 opts_type = OPTS_TYPE_PT_GENERATE_LE
8569 | OPTS_TYPE_PT_ADD01;
8570 kern_type = KERN_TYPE_KECCAK;
8571 dgst_size = DGST_SIZE_8_25;
8572 parse_func = keccak_parse_hash;
8573 sort_by_digest = sort_by_digest_8_25;
8574 opti_type = OPTI_TYPE_ZERO_BYTE
8575 | OPTI_TYPE_USES_BITS_64
8576 | OPTI_TYPE_RAW_HASH;
8577 dgst_pos0 = 2;
8578 dgst_pos1 = 3;
8579 dgst_pos2 = 4;
8580 dgst_pos3 = 5;
8581 break;
8582
8583 case 5100: hash_type = HASH_TYPE_MD5H;
8584 salt_type = SALT_TYPE_NONE;
8585 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8586 opts_type = OPTS_TYPE_PT_GENERATE_LE
8587 | OPTS_TYPE_PT_ADD80
8588 | OPTS_TYPE_PT_ADDBITS14;
8589 kern_type = KERN_TYPE_MD5H;
8590 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8591 parse_func = md5half_parse_hash;
8592 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8593 opti_type = OPTI_TYPE_ZERO_BYTE
8594 | OPTI_TYPE_RAW_HASH;
8595 dgst_pos0 = 0;
8596 dgst_pos1 = 1;
8597 dgst_pos2 = 2;
8598 dgst_pos3 = 3;
8599 break;
8600
8601 case 5200: hash_type = HASH_TYPE_SHA256;
8602 salt_type = SALT_TYPE_EMBEDDED;
8603 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8604 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8605 kern_type = KERN_TYPE_PSAFE3;
8606 dgst_size = DGST_SIZE_4_8;
8607 parse_func = psafe3_parse_hash;
8608 sort_by_digest = sort_by_digest_4_8;
8609 opti_type = OPTI_TYPE_ZERO_BYTE;
8610 dgst_pos0 = 0;
8611 dgst_pos1 = 1;
8612 dgst_pos2 = 2;
8613 dgst_pos3 = 3;
8614 break;
8615
8616 case 5300: hash_type = HASH_TYPE_MD5;
8617 salt_type = SALT_TYPE_EMBEDDED;
8618 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8619 opts_type = OPTS_TYPE_PT_GENERATE_LE
8620 | OPTS_TYPE_ST_ADD80;
8621 kern_type = KERN_TYPE_IKEPSK_MD5;
8622 dgst_size = DGST_SIZE_4_4;
8623 parse_func = ikepsk_md5_parse_hash;
8624 sort_by_digest = sort_by_digest_4_4;
8625 opti_type = OPTI_TYPE_ZERO_BYTE;
8626 dgst_pos0 = 0;
8627 dgst_pos1 = 3;
8628 dgst_pos2 = 2;
8629 dgst_pos3 = 1;
8630 break;
8631
8632 case 5400: hash_type = HASH_TYPE_SHA1;
8633 salt_type = SALT_TYPE_EMBEDDED;
8634 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8635 opts_type = OPTS_TYPE_PT_GENERATE_BE
8636 | OPTS_TYPE_ST_ADD80;
8637 kern_type = KERN_TYPE_IKEPSK_SHA1;
8638 dgst_size = DGST_SIZE_4_5;
8639 parse_func = ikepsk_sha1_parse_hash;
8640 sort_by_digest = sort_by_digest_4_5;
8641 opti_type = OPTI_TYPE_ZERO_BYTE;
8642 dgst_pos0 = 3;
8643 dgst_pos1 = 4;
8644 dgst_pos2 = 2;
8645 dgst_pos3 = 1;
8646 break;
8647
8648 case 5500: hash_type = HASH_TYPE_NETNTLM;
8649 salt_type = SALT_TYPE_EMBEDDED;
8650 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8651 opts_type = OPTS_TYPE_PT_GENERATE_LE
8652 | OPTS_TYPE_PT_ADD80
8653 | OPTS_TYPE_PT_ADDBITS14
8654 | OPTS_TYPE_PT_UNICODE
8655 | OPTS_TYPE_ST_HEX;
8656 kern_type = KERN_TYPE_NETNTLMv1;
8657 dgst_size = DGST_SIZE_4_4;
8658 parse_func = netntlmv1_parse_hash;
8659 sort_by_digest = sort_by_digest_4_4;
8660 opti_type = OPTI_TYPE_ZERO_BYTE
8661 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8662 dgst_pos0 = 0;
8663 dgst_pos1 = 1;
8664 dgst_pos2 = 2;
8665 dgst_pos3 = 3;
8666 break;
8667
8668 case 5600: hash_type = HASH_TYPE_MD5;
8669 salt_type = SALT_TYPE_EMBEDDED;
8670 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8671 opts_type = OPTS_TYPE_PT_GENERATE_LE
8672 | OPTS_TYPE_PT_ADD80
8673 | OPTS_TYPE_PT_ADDBITS14
8674 | OPTS_TYPE_PT_UNICODE;
8675 kern_type = KERN_TYPE_NETNTLMv2;
8676 dgst_size = DGST_SIZE_4_4;
8677 parse_func = netntlmv2_parse_hash;
8678 sort_by_digest = sort_by_digest_4_4;
8679 opti_type = OPTI_TYPE_ZERO_BYTE;
8680 dgst_pos0 = 0;
8681 dgst_pos1 = 3;
8682 dgst_pos2 = 2;
8683 dgst_pos3 = 1;
8684 break;
8685
8686 case 5700: hash_type = HASH_TYPE_SHA256;
8687 salt_type = SALT_TYPE_NONE;
8688 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8689 opts_type = OPTS_TYPE_PT_GENERATE_BE
8690 | OPTS_TYPE_PT_ADD80
8691 | OPTS_TYPE_PT_ADDBITS15;
8692 kern_type = KERN_TYPE_SHA256;
8693 dgst_size = DGST_SIZE_4_8;
8694 parse_func = cisco4_parse_hash;
8695 sort_by_digest = sort_by_digest_4_8;
8696 opti_type = OPTI_TYPE_ZERO_BYTE
8697 | OPTI_TYPE_PRECOMPUTE_INIT
8698 | OPTI_TYPE_PRECOMPUTE_MERKLE
8699 | OPTI_TYPE_EARLY_SKIP
8700 | OPTI_TYPE_NOT_ITERATED
8701 | OPTI_TYPE_NOT_SALTED
8702 | OPTI_TYPE_RAW_HASH;
8703 dgst_pos0 = 3;
8704 dgst_pos1 = 7;
8705 dgst_pos2 = 2;
8706 dgst_pos3 = 6;
8707 break;
8708
8709 case 5800: hash_type = HASH_TYPE_SHA1;
8710 salt_type = SALT_TYPE_INTERN;
8711 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8712 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8713 | OPTS_TYPE_ST_ADD80;
8714 kern_type = KERN_TYPE_ANDROIDPIN;
8715 dgst_size = DGST_SIZE_4_5;
8716 parse_func = androidpin_parse_hash;
8717 sort_by_digest = sort_by_digest_4_5;
8718 opti_type = OPTI_TYPE_ZERO_BYTE;
8719 dgst_pos0 = 0;
8720 dgst_pos1 = 1;
8721 dgst_pos2 = 2;
8722 dgst_pos3 = 3;
8723 break;
8724
8725 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8726 salt_type = SALT_TYPE_NONE;
8727 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8728 opts_type = OPTS_TYPE_PT_GENERATE_LE
8729 | OPTS_TYPE_PT_ADD80;
8730 kern_type = KERN_TYPE_RIPEMD160;
8731 dgst_size = DGST_SIZE_4_5;
8732 parse_func = ripemd160_parse_hash;
8733 sort_by_digest = sort_by_digest_4_5;
8734 opti_type = OPTI_TYPE_ZERO_BYTE;
8735 dgst_pos0 = 0;
8736 dgst_pos1 = 1;
8737 dgst_pos2 = 2;
8738 dgst_pos3 = 3;
8739 break;
8740
8741 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8742 salt_type = SALT_TYPE_NONE;
8743 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8744 opts_type = OPTS_TYPE_PT_GENERATE_BE
8745 | OPTS_TYPE_PT_ADD80;
8746 kern_type = KERN_TYPE_WHIRLPOOL;
8747 dgst_size = DGST_SIZE_4_16;
8748 parse_func = whirlpool_parse_hash;
8749 sort_by_digest = sort_by_digest_4_16;
8750 opti_type = OPTI_TYPE_ZERO_BYTE;
8751 dgst_pos0 = 0;
8752 dgst_pos1 = 1;
8753 dgst_pos2 = 2;
8754 dgst_pos3 = 3;
8755 break;
8756
8757 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8758 salt_type = SALT_TYPE_EMBEDDED;
8759 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8760 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8761 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8762 dgst_size = DGST_SIZE_4_5;
8763 parse_func = truecrypt_parse_hash_2k;
8764 sort_by_digest = sort_by_digest_4_5;
8765 opti_type = OPTI_TYPE_ZERO_BYTE;
8766 dgst_pos0 = 0;
8767 dgst_pos1 = 1;
8768 dgst_pos2 = 2;
8769 dgst_pos3 = 3;
8770 break;
8771
8772 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8773 salt_type = SALT_TYPE_EMBEDDED;
8774 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8775 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8776 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8777 dgst_size = DGST_SIZE_4_5;
8778 parse_func = truecrypt_parse_hash_2k;
8779 sort_by_digest = sort_by_digest_4_5;
8780 opti_type = OPTI_TYPE_ZERO_BYTE;
8781 dgst_pos0 = 0;
8782 dgst_pos1 = 1;
8783 dgst_pos2 = 2;
8784 dgst_pos3 = 3;
8785 break;
8786
8787 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8788 salt_type = SALT_TYPE_EMBEDDED;
8789 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8790 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8791 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8792 dgst_size = DGST_SIZE_4_5;
8793 parse_func = truecrypt_parse_hash_2k;
8794 sort_by_digest = sort_by_digest_4_5;
8795 opti_type = OPTI_TYPE_ZERO_BYTE;
8796 dgst_pos0 = 0;
8797 dgst_pos1 = 1;
8798 dgst_pos2 = 2;
8799 dgst_pos3 = 3;
8800 break;
8801
8802 case 6221: hash_type = HASH_TYPE_SHA512;
8803 salt_type = SALT_TYPE_EMBEDDED;
8804 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8805 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8806 kern_type = KERN_TYPE_TCSHA512_XTS512;
8807 dgst_size = DGST_SIZE_8_8;
8808 parse_func = truecrypt_parse_hash_1k;
8809 sort_by_digest = sort_by_digest_8_8;
8810 opti_type = OPTI_TYPE_ZERO_BYTE
8811 | OPTI_TYPE_USES_BITS_64;
8812 dgst_pos0 = 0;
8813 dgst_pos1 = 1;
8814 dgst_pos2 = 2;
8815 dgst_pos3 = 3;
8816 break;
8817
8818 case 6222: hash_type = HASH_TYPE_SHA512;
8819 salt_type = SALT_TYPE_EMBEDDED;
8820 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8821 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8822 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8823 dgst_size = DGST_SIZE_8_8;
8824 parse_func = truecrypt_parse_hash_1k;
8825 sort_by_digest = sort_by_digest_8_8;
8826 opti_type = OPTI_TYPE_ZERO_BYTE
8827 | OPTI_TYPE_USES_BITS_64;
8828 dgst_pos0 = 0;
8829 dgst_pos1 = 1;
8830 dgst_pos2 = 2;
8831 dgst_pos3 = 3;
8832 break;
8833
8834 case 6223: hash_type = HASH_TYPE_SHA512;
8835 salt_type = SALT_TYPE_EMBEDDED;
8836 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8837 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8838 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8839 dgst_size = DGST_SIZE_8_8;
8840 parse_func = truecrypt_parse_hash_1k;
8841 sort_by_digest = sort_by_digest_8_8;
8842 opti_type = OPTI_TYPE_ZERO_BYTE
8843 | OPTI_TYPE_USES_BITS_64;
8844 dgst_pos0 = 0;
8845 dgst_pos1 = 1;
8846 dgst_pos2 = 2;
8847 dgst_pos3 = 3;
8848 break;
8849
8850 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8851 salt_type = SALT_TYPE_EMBEDDED;
8852 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8853 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8854 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8855 dgst_size = DGST_SIZE_4_8;
8856 parse_func = truecrypt_parse_hash_1k;
8857 sort_by_digest = sort_by_digest_4_8;
8858 opti_type = OPTI_TYPE_ZERO_BYTE;
8859 dgst_pos0 = 0;
8860 dgst_pos1 = 1;
8861 dgst_pos2 = 2;
8862 dgst_pos3 = 3;
8863 break;
8864
8865 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8866 salt_type = SALT_TYPE_EMBEDDED;
8867 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8868 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8869 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8870 dgst_size = DGST_SIZE_4_8;
8871 parse_func = truecrypt_parse_hash_1k;
8872 sort_by_digest = sort_by_digest_4_8;
8873 opti_type = OPTI_TYPE_ZERO_BYTE;
8874 dgst_pos0 = 0;
8875 dgst_pos1 = 1;
8876 dgst_pos2 = 2;
8877 dgst_pos3 = 3;
8878 break;
8879
8880 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8881 salt_type = SALT_TYPE_EMBEDDED;
8882 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8883 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8884 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8885 dgst_size = DGST_SIZE_4_8;
8886 parse_func = truecrypt_parse_hash_1k;
8887 sort_by_digest = sort_by_digest_4_8;
8888 opti_type = OPTI_TYPE_ZERO_BYTE;
8889 dgst_pos0 = 0;
8890 dgst_pos1 = 1;
8891 dgst_pos2 = 2;
8892 dgst_pos3 = 3;
8893 break;
8894
8895 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8896 salt_type = SALT_TYPE_EMBEDDED;
8897 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8898 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8899 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8900 dgst_size = DGST_SIZE_4_5;
8901 parse_func = truecrypt_parse_hash_1k;
8902 sort_by_digest = sort_by_digest_4_5;
8903 opti_type = OPTI_TYPE_ZERO_BYTE;
8904 dgst_pos0 = 0;
8905 dgst_pos1 = 1;
8906 dgst_pos2 = 2;
8907 dgst_pos3 = 3;
8908 break;
8909
8910 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8911 salt_type = SALT_TYPE_EMBEDDED;
8912 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8913 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8914 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8915 dgst_size = DGST_SIZE_4_5;
8916 parse_func = truecrypt_parse_hash_1k;
8917 sort_by_digest = sort_by_digest_4_5;
8918 opti_type = OPTI_TYPE_ZERO_BYTE;
8919 dgst_pos0 = 0;
8920 dgst_pos1 = 1;
8921 dgst_pos2 = 2;
8922 dgst_pos3 = 3;
8923 break;
8924
8925 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8926 salt_type = SALT_TYPE_EMBEDDED;
8927 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8928 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8929 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8930 dgst_size = DGST_SIZE_4_5;
8931 parse_func = truecrypt_parse_hash_1k;
8932 sort_by_digest = sort_by_digest_4_5;
8933 opti_type = OPTI_TYPE_ZERO_BYTE;
8934 dgst_pos0 = 0;
8935 dgst_pos1 = 1;
8936 dgst_pos2 = 2;
8937 dgst_pos3 = 3;
8938 break;
8939
8940 case 6300: hash_type = HASH_TYPE_MD5;
8941 salt_type = SALT_TYPE_EMBEDDED;
8942 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8943 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8944 kern_type = KERN_TYPE_MD5AIX;
8945 dgst_size = DGST_SIZE_4_4;
8946 parse_func = md5aix_parse_hash;
8947 sort_by_digest = sort_by_digest_4_4;
8948 opti_type = OPTI_TYPE_ZERO_BYTE;
8949 dgst_pos0 = 0;
8950 dgst_pos1 = 1;
8951 dgst_pos2 = 2;
8952 dgst_pos3 = 3;
8953 break;
8954
8955 case 6400: hash_type = HASH_TYPE_SHA256;
8956 salt_type = SALT_TYPE_EMBEDDED;
8957 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8958 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8959 kern_type = KERN_TYPE_SHA256AIX;
8960 dgst_size = DGST_SIZE_4_8;
8961 parse_func = sha256aix_parse_hash;
8962 sort_by_digest = sort_by_digest_4_8;
8963 opti_type = OPTI_TYPE_ZERO_BYTE;
8964 dgst_pos0 = 0;
8965 dgst_pos1 = 1;
8966 dgst_pos2 = 2;
8967 dgst_pos3 = 3;
8968 break;
8969
8970 case 6500: hash_type = HASH_TYPE_SHA512;
8971 salt_type = SALT_TYPE_EMBEDDED;
8972 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8973 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8974 kern_type = KERN_TYPE_SHA512AIX;
8975 dgst_size = DGST_SIZE_8_8;
8976 parse_func = sha512aix_parse_hash;
8977 sort_by_digest = sort_by_digest_8_8;
8978 opti_type = OPTI_TYPE_ZERO_BYTE
8979 | OPTI_TYPE_USES_BITS_64;
8980 dgst_pos0 = 0;
8981 dgst_pos1 = 1;
8982 dgst_pos2 = 2;
8983 dgst_pos3 = 3;
8984 break;
8985
8986 case 6600: hash_type = HASH_TYPE_AES;
8987 salt_type = SALT_TYPE_EMBEDDED;
8988 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8989 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8990 kern_type = KERN_TYPE_AGILEKEY;
8991 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8992 parse_func = agilekey_parse_hash;
8993 sort_by_digest = sort_by_digest_4_5;
8994 opti_type = OPTI_TYPE_ZERO_BYTE;
8995 dgst_pos0 = 0;
8996 dgst_pos1 = 1;
8997 dgst_pos2 = 2;
8998 dgst_pos3 = 3;
8999 break;
9000
9001 case 6700: hash_type = HASH_TYPE_SHA1;
9002 salt_type = SALT_TYPE_EMBEDDED;
9003 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9004 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9005 kern_type = KERN_TYPE_SHA1AIX;
9006 dgst_size = DGST_SIZE_4_5;
9007 parse_func = sha1aix_parse_hash;
9008 sort_by_digest = sort_by_digest_4_5;
9009 opti_type = OPTI_TYPE_ZERO_BYTE;
9010 dgst_pos0 = 0;
9011 dgst_pos1 = 1;
9012 dgst_pos2 = 2;
9013 dgst_pos3 = 3;
9014 break;
9015
9016 case 6800: hash_type = HASH_TYPE_AES;
9017 salt_type = SALT_TYPE_EMBEDDED;
9018 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9019 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9020 kern_type = KERN_TYPE_LASTPASS;
9021 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9022 parse_func = lastpass_parse_hash;
9023 sort_by_digest = sort_by_digest_4_8;
9024 opti_type = OPTI_TYPE_ZERO_BYTE;
9025 dgst_pos0 = 0;
9026 dgst_pos1 = 1;
9027 dgst_pos2 = 2;
9028 dgst_pos3 = 3;
9029 break;
9030
9031 case 6900: hash_type = HASH_TYPE_GOST;
9032 salt_type = SALT_TYPE_NONE;
9033 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9034 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9035 kern_type = KERN_TYPE_GOST;
9036 dgst_size = DGST_SIZE_4_8;
9037 parse_func = gost_parse_hash;
9038 sort_by_digest = sort_by_digest_4_8;
9039 opti_type = OPTI_TYPE_ZERO_BYTE;
9040 dgst_pos0 = 0;
9041 dgst_pos1 = 1;
9042 dgst_pos2 = 2;
9043 dgst_pos3 = 3;
9044 break;
9045
9046 case 7100: hash_type = HASH_TYPE_SHA512;
9047 salt_type = SALT_TYPE_EMBEDDED;
9048 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9049 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9050 kern_type = KERN_TYPE_PBKDF2_SHA512;
9051 dgst_size = DGST_SIZE_8_16;
9052 parse_func = sha512osx_parse_hash;
9053 sort_by_digest = sort_by_digest_8_16;
9054 opti_type = OPTI_TYPE_ZERO_BYTE
9055 | OPTI_TYPE_USES_BITS_64;
9056 dgst_pos0 = 0;
9057 dgst_pos1 = 1;
9058 dgst_pos2 = 2;
9059 dgst_pos3 = 3;
9060 break;
9061
9062 case 7200: hash_type = HASH_TYPE_SHA512;
9063 salt_type = SALT_TYPE_EMBEDDED;
9064 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9065 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9066 kern_type = KERN_TYPE_PBKDF2_SHA512;
9067 dgst_size = DGST_SIZE_8_16;
9068 parse_func = sha512grub_parse_hash;
9069 sort_by_digest = sort_by_digest_8_16;
9070 opti_type = OPTI_TYPE_ZERO_BYTE
9071 | OPTI_TYPE_USES_BITS_64;
9072 dgst_pos0 = 0;
9073 dgst_pos1 = 1;
9074 dgst_pos2 = 2;
9075 dgst_pos3 = 3;
9076 break;
9077
9078 case 7300: hash_type = HASH_TYPE_SHA1;
9079 salt_type = SALT_TYPE_EMBEDDED;
9080 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9081 opts_type = OPTS_TYPE_PT_GENERATE_BE
9082 | OPTS_TYPE_ST_ADD80
9083 | OPTS_TYPE_ST_ADDBITS15;
9084 kern_type = KERN_TYPE_RAKP;
9085 dgst_size = DGST_SIZE_4_5;
9086 parse_func = rakp_parse_hash;
9087 sort_by_digest = sort_by_digest_4_5;
9088 opti_type = OPTI_TYPE_ZERO_BYTE
9089 | OPTI_TYPE_NOT_ITERATED;
9090 dgst_pos0 = 3;
9091 dgst_pos1 = 4;
9092 dgst_pos2 = 2;
9093 dgst_pos3 = 1;
9094 break;
9095
9096 case 7400: hash_type = HASH_TYPE_SHA256;
9097 salt_type = SALT_TYPE_EMBEDDED;
9098 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9099 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9100 kern_type = KERN_TYPE_SHA256CRYPT;
9101 dgst_size = DGST_SIZE_4_8;
9102 parse_func = sha256crypt_parse_hash;
9103 sort_by_digest = sort_by_digest_4_8;
9104 opti_type = OPTI_TYPE_ZERO_BYTE;
9105 dgst_pos0 = 0;
9106 dgst_pos1 = 1;
9107 dgst_pos2 = 2;
9108 dgst_pos3 = 3;
9109 break;
9110
9111 case 7500: hash_type = HASH_TYPE_KRB5PA;
9112 salt_type = SALT_TYPE_EMBEDDED;
9113 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9114 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9115 kern_type = KERN_TYPE_KRB5PA;
9116 dgst_size = DGST_SIZE_4_4;
9117 parse_func = krb5pa_parse_hash;
9118 sort_by_digest = sort_by_digest_4_4;
9119 opti_type = OPTI_TYPE_ZERO_BYTE
9120 | OPTI_TYPE_NOT_ITERATED;
9121 dgst_pos0 = 0;
9122 dgst_pos1 = 1;
9123 dgst_pos2 = 2;
9124 dgst_pos3 = 3;
9125 break;
9126
9127 case 7600: hash_type = HASH_TYPE_SHA1;
9128 salt_type = SALT_TYPE_INTERN;
9129 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9130 opts_type = OPTS_TYPE_PT_GENERATE_BE
9131 | OPTS_TYPE_PT_ADD80
9132 | OPTS_TYPE_PT_ADDBITS15;
9133 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9134 dgst_size = DGST_SIZE_4_5;
9135 parse_func = redmine_parse_hash;
9136 sort_by_digest = sort_by_digest_4_5;
9137 opti_type = OPTI_TYPE_ZERO_BYTE
9138 | OPTI_TYPE_PRECOMPUTE_INIT
9139 | OPTI_TYPE_EARLY_SKIP
9140 | OPTI_TYPE_NOT_ITERATED
9141 | OPTI_TYPE_PREPENDED_SALT;
9142 dgst_pos0 = 3;
9143 dgst_pos1 = 4;
9144 dgst_pos2 = 2;
9145 dgst_pos3 = 1;
9146 break;
9147
9148 case 7700: hash_type = HASH_TYPE_SAPB;
9149 salt_type = SALT_TYPE_EMBEDDED;
9150 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9151 opts_type = OPTS_TYPE_PT_GENERATE_LE
9152 | OPTS_TYPE_PT_UPPER
9153 | OPTS_TYPE_ST_UPPER;
9154 kern_type = KERN_TYPE_SAPB;
9155 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9156 parse_func = sapb_parse_hash;
9157 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9158 opti_type = OPTI_TYPE_ZERO_BYTE
9159 | OPTI_TYPE_PRECOMPUTE_INIT
9160 | OPTI_TYPE_NOT_ITERATED;
9161 dgst_pos0 = 0;
9162 dgst_pos1 = 1;
9163 dgst_pos2 = 2;
9164 dgst_pos3 = 3;
9165 break;
9166
9167 case 7800: hash_type = HASH_TYPE_SAPG;
9168 salt_type = SALT_TYPE_EMBEDDED;
9169 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9170 opts_type = OPTS_TYPE_PT_GENERATE_BE
9171 | OPTS_TYPE_ST_ADD80
9172 | OPTS_TYPE_ST_UPPER;
9173 kern_type = KERN_TYPE_SAPG;
9174 dgst_size = DGST_SIZE_4_5;
9175 parse_func = sapg_parse_hash;
9176 sort_by_digest = sort_by_digest_4_5;
9177 opti_type = OPTI_TYPE_ZERO_BYTE
9178 | OPTI_TYPE_PRECOMPUTE_INIT
9179 | OPTI_TYPE_NOT_ITERATED;
9180 dgst_pos0 = 3;
9181 dgst_pos1 = 4;
9182 dgst_pos2 = 2;
9183 dgst_pos3 = 1;
9184 break;
9185
9186 case 7900: hash_type = HASH_TYPE_SHA512;
9187 salt_type = SALT_TYPE_EMBEDDED;
9188 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9189 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9190 kern_type = KERN_TYPE_DRUPAL7;
9191 dgst_size = DGST_SIZE_8_8;
9192 parse_func = drupal7_parse_hash;
9193 sort_by_digest = sort_by_digest_8_8;
9194 opti_type = OPTI_TYPE_ZERO_BYTE
9195 | OPTI_TYPE_USES_BITS_64;
9196 dgst_pos0 = 0;
9197 dgst_pos1 = 1;
9198 dgst_pos2 = 2;
9199 dgst_pos3 = 3;
9200 break;
9201
9202 case 8000: hash_type = HASH_TYPE_SHA256;
9203 salt_type = SALT_TYPE_EMBEDDED;
9204 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9205 opts_type = OPTS_TYPE_PT_GENERATE_BE
9206 | OPTS_TYPE_PT_UNICODE
9207 | OPTS_TYPE_ST_ADD80
9208 | OPTS_TYPE_ST_HEX;
9209 kern_type = KERN_TYPE_SYBASEASE;
9210 dgst_size = DGST_SIZE_4_8;
9211 parse_func = sybasease_parse_hash;
9212 sort_by_digest = sort_by_digest_4_8;
9213 opti_type = OPTI_TYPE_ZERO_BYTE
9214 | OPTI_TYPE_PRECOMPUTE_INIT
9215 | OPTI_TYPE_EARLY_SKIP
9216 | OPTI_TYPE_NOT_ITERATED
9217 | OPTI_TYPE_RAW_HASH;
9218 dgst_pos0 = 3;
9219 dgst_pos1 = 7;
9220 dgst_pos2 = 2;
9221 dgst_pos3 = 6;
9222 break;
9223
9224 case 8100: hash_type = HASH_TYPE_SHA1;
9225 salt_type = SALT_TYPE_EMBEDDED;
9226 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9227 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9228 kern_type = KERN_TYPE_NETSCALER;
9229 dgst_size = DGST_SIZE_4_5;
9230 parse_func = netscaler_parse_hash;
9231 sort_by_digest = sort_by_digest_4_5;
9232 opti_type = OPTI_TYPE_ZERO_BYTE
9233 | OPTI_TYPE_PRECOMPUTE_INIT
9234 | OPTI_TYPE_PRECOMPUTE_MERKLE
9235 | OPTI_TYPE_EARLY_SKIP
9236 | OPTI_TYPE_NOT_ITERATED
9237 | OPTI_TYPE_PREPENDED_SALT
9238 | OPTI_TYPE_RAW_HASH;
9239 dgst_pos0 = 3;
9240 dgst_pos1 = 4;
9241 dgst_pos2 = 2;
9242 dgst_pos3 = 1;
9243 break;
9244
9245 case 8200: hash_type = HASH_TYPE_SHA256;
9246 salt_type = SALT_TYPE_EMBEDDED;
9247 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9248 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9249 kern_type = KERN_TYPE_CLOUDKEY;
9250 dgst_size = DGST_SIZE_4_8;
9251 parse_func = cloudkey_parse_hash;
9252 sort_by_digest = sort_by_digest_4_8;
9253 opti_type = OPTI_TYPE_ZERO_BYTE;
9254 dgst_pos0 = 0;
9255 dgst_pos1 = 1;
9256 dgst_pos2 = 2;
9257 dgst_pos3 = 3;
9258 break;
9259
9260 case 8300: hash_type = HASH_TYPE_SHA1;
9261 salt_type = SALT_TYPE_EMBEDDED;
9262 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9263 opts_type = OPTS_TYPE_PT_GENERATE_LE
9264 | OPTS_TYPE_ST_HEX
9265 | OPTS_TYPE_ST_ADD80;
9266 kern_type = KERN_TYPE_NSEC3;
9267 dgst_size = DGST_SIZE_4_5;
9268 parse_func = nsec3_parse_hash;
9269 sort_by_digest = sort_by_digest_4_5;
9270 opti_type = OPTI_TYPE_ZERO_BYTE;
9271 dgst_pos0 = 3;
9272 dgst_pos1 = 4;
9273 dgst_pos2 = 2;
9274 dgst_pos3 = 1;
9275 break;
9276
9277 case 8400: hash_type = HASH_TYPE_SHA1;
9278 salt_type = SALT_TYPE_INTERN;
9279 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9280 opts_type = OPTS_TYPE_PT_GENERATE_BE
9281 | OPTS_TYPE_PT_ADD80
9282 | OPTS_TYPE_PT_ADDBITS15;
9283 kern_type = KERN_TYPE_WBB3;
9284 dgst_size = DGST_SIZE_4_5;
9285 parse_func = wbb3_parse_hash;
9286 sort_by_digest = sort_by_digest_4_5;
9287 opti_type = OPTI_TYPE_ZERO_BYTE
9288 | OPTI_TYPE_PRECOMPUTE_INIT
9289 | OPTI_TYPE_NOT_ITERATED;
9290 dgst_pos0 = 3;
9291 dgst_pos1 = 4;
9292 dgst_pos2 = 2;
9293 dgst_pos3 = 1;
9294 break;
9295
9296 case 8500: hash_type = HASH_TYPE_DESRACF;
9297 salt_type = SALT_TYPE_EMBEDDED;
9298 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9299 opts_type = OPTS_TYPE_PT_GENERATE_LE
9300 | OPTS_TYPE_ST_UPPER;
9301 kern_type = KERN_TYPE_RACF;
9302 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9303 parse_func = racf_parse_hash;
9304 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9305 opti_type = OPTI_TYPE_ZERO_BYTE
9306 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9307 dgst_pos0 = 0;
9308 dgst_pos1 = 1;
9309 dgst_pos2 = 2;
9310 dgst_pos3 = 3;
9311 break;
9312
9313 case 8600: hash_type = HASH_TYPE_LOTUS5;
9314 salt_type = SALT_TYPE_NONE;
9315 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9316 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9317 kern_type = KERN_TYPE_LOTUS5;
9318 dgst_size = DGST_SIZE_4_4;
9319 parse_func = lotus5_parse_hash;
9320 sort_by_digest = sort_by_digest_4_4;
9321 opti_type = OPTI_TYPE_EARLY_SKIP
9322 | OPTI_TYPE_NOT_ITERATED
9323 | OPTI_TYPE_NOT_SALTED
9324 | OPTI_TYPE_RAW_HASH;
9325 dgst_pos0 = 0;
9326 dgst_pos1 = 1;
9327 dgst_pos2 = 2;
9328 dgst_pos3 = 3;
9329 break;
9330
9331 case 8700: hash_type = HASH_TYPE_LOTUS6;
9332 salt_type = SALT_TYPE_EMBEDDED;
9333 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9334 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9335 kern_type = KERN_TYPE_LOTUS6;
9336 dgst_size = DGST_SIZE_4_4;
9337 parse_func = lotus6_parse_hash;
9338 sort_by_digest = sort_by_digest_4_4;
9339 opti_type = OPTI_TYPE_EARLY_SKIP
9340 | OPTI_TYPE_NOT_ITERATED
9341 | OPTI_TYPE_RAW_HASH;
9342 dgst_pos0 = 0;
9343 dgst_pos1 = 1;
9344 dgst_pos2 = 2;
9345 dgst_pos3 = 3;
9346 break;
9347
9348 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9349 salt_type = SALT_TYPE_EMBEDDED;
9350 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9351 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9352 kern_type = KERN_TYPE_ANDROIDFDE;
9353 dgst_size = DGST_SIZE_4_4;
9354 parse_func = androidfde_parse_hash;
9355 sort_by_digest = sort_by_digest_4_4;
9356 opti_type = OPTI_TYPE_ZERO_BYTE;
9357 dgst_pos0 = 0;
9358 dgst_pos1 = 1;
9359 dgst_pos2 = 2;
9360 dgst_pos3 = 3;
9361 break;
9362
9363 case 8900: hash_type = HASH_TYPE_SCRYPT;
9364 salt_type = SALT_TYPE_EMBEDDED;
9365 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9366 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9367 kern_type = KERN_TYPE_SCRYPT;
9368 dgst_size = DGST_SIZE_4_8;
9369 parse_func = scrypt_parse_hash;
9370 sort_by_digest = sort_by_digest_4_8;
9371 opti_type = OPTI_TYPE_ZERO_BYTE;
9372 dgst_pos0 = 0;
9373 dgst_pos1 = 1;
9374 dgst_pos2 = 2;
9375 dgst_pos3 = 3;
9376 break;
9377
9378 case 9000: hash_type = HASH_TYPE_SHA1;
9379 salt_type = SALT_TYPE_EMBEDDED;
9380 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9381 opts_type = OPTS_TYPE_PT_GENERATE_LE
9382 | OPTS_TYPE_ST_GENERATE_LE;
9383 kern_type = KERN_TYPE_PSAFE2;
9384 dgst_size = DGST_SIZE_4_5;
9385 parse_func = psafe2_parse_hash;
9386 sort_by_digest = sort_by_digest_4_5;
9387 opti_type = OPTI_TYPE_ZERO_BYTE;
9388 dgst_pos0 = 0;
9389 dgst_pos1 = 1;
9390 dgst_pos2 = 2;
9391 dgst_pos3 = 3;
9392 break;
9393
9394 case 9100: hash_type = HASH_TYPE_LOTUS8;
9395 salt_type = SALT_TYPE_EMBEDDED;
9396 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9397 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9398 kern_type = KERN_TYPE_LOTUS8;
9399 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9400 parse_func = lotus8_parse_hash;
9401 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9402 opti_type = OPTI_TYPE_ZERO_BYTE;
9403 dgst_pos0 = 0;
9404 dgst_pos1 = 1;
9405 dgst_pos2 = 2;
9406 dgst_pos3 = 3;
9407 break;
9408
9409 case 9200: hash_type = HASH_TYPE_SHA256;
9410 salt_type = SALT_TYPE_EMBEDDED;
9411 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9412 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9413 kern_type = KERN_TYPE_PBKDF2_SHA256;
9414 dgst_size = DGST_SIZE_4_32;
9415 parse_func = cisco8_parse_hash;
9416 sort_by_digest = sort_by_digest_4_32;
9417 opti_type = OPTI_TYPE_ZERO_BYTE;
9418 dgst_pos0 = 0;
9419 dgst_pos1 = 1;
9420 dgst_pos2 = 2;
9421 dgst_pos3 = 3;
9422 break;
9423
9424 case 9300: hash_type = HASH_TYPE_SCRYPT;
9425 salt_type = SALT_TYPE_EMBEDDED;
9426 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9427 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9428 kern_type = KERN_TYPE_SCRYPT;
9429 dgst_size = DGST_SIZE_4_8;
9430 parse_func = cisco9_parse_hash;
9431 sort_by_digest = sort_by_digest_4_8;
9432 opti_type = OPTI_TYPE_ZERO_BYTE;
9433 dgst_pos0 = 0;
9434 dgst_pos1 = 1;
9435 dgst_pos2 = 2;
9436 dgst_pos3 = 3;
9437 break;
9438
9439 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9440 salt_type = SALT_TYPE_EMBEDDED;
9441 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9442 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9443 kern_type = KERN_TYPE_OFFICE2007;
9444 dgst_size = DGST_SIZE_4_4;
9445 parse_func = office2007_parse_hash;
9446 sort_by_digest = sort_by_digest_4_4;
9447 opti_type = OPTI_TYPE_ZERO_BYTE;
9448 dgst_pos0 = 0;
9449 dgst_pos1 = 1;
9450 dgst_pos2 = 2;
9451 dgst_pos3 = 3;
9452 break;
9453
9454 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9455 salt_type = SALT_TYPE_EMBEDDED;
9456 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9457 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9458 kern_type = KERN_TYPE_OFFICE2010;
9459 dgst_size = DGST_SIZE_4_4;
9460 parse_func = office2010_parse_hash;
9461 sort_by_digest = sort_by_digest_4_4;
9462 opti_type = OPTI_TYPE_ZERO_BYTE;
9463 dgst_pos0 = 0;
9464 dgst_pos1 = 1;
9465 dgst_pos2 = 2;
9466 dgst_pos3 = 3;
9467 break;
9468
9469 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9470 salt_type = SALT_TYPE_EMBEDDED;
9471 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9472 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9473 kern_type = KERN_TYPE_OFFICE2013;
9474 dgst_size = DGST_SIZE_4_4;
9475 parse_func = office2013_parse_hash;
9476 sort_by_digest = sort_by_digest_4_4;
9477 opti_type = OPTI_TYPE_ZERO_BYTE;
9478 dgst_pos0 = 0;
9479 dgst_pos1 = 1;
9480 dgst_pos2 = 2;
9481 dgst_pos3 = 3;
9482 break;
9483
9484 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9485 salt_type = SALT_TYPE_EMBEDDED;
9486 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9487 opts_type = OPTS_TYPE_PT_GENERATE_LE
9488 | OPTS_TYPE_PT_ADD80
9489 | OPTS_TYPE_PT_UNICODE;
9490 kern_type = KERN_TYPE_OLDOFFICE01;
9491 dgst_size = DGST_SIZE_4_4;
9492 parse_func = oldoffice01_parse_hash;
9493 sort_by_digest = sort_by_digest_4_4;
9494 opti_type = OPTI_TYPE_ZERO_BYTE
9495 | OPTI_TYPE_PRECOMPUTE_INIT
9496 | OPTI_TYPE_NOT_ITERATED;
9497 dgst_pos0 = 0;
9498 dgst_pos1 = 1;
9499 dgst_pos2 = 2;
9500 dgst_pos3 = 3;
9501 break;
9502
9503 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9504 salt_type = SALT_TYPE_EMBEDDED;
9505 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9506 opts_type = OPTS_TYPE_PT_GENERATE_LE
9507 | OPTS_TYPE_PT_ADD80;
9508 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9509 dgst_size = DGST_SIZE_4_4;
9510 parse_func = oldoffice01cm1_parse_hash;
9511 sort_by_digest = sort_by_digest_4_4;
9512 opti_type = OPTI_TYPE_ZERO_BYTE
9513 | OPTI_TYPE_PRECOMPUTE_INIT
9514 | OPTI_TYPE_NOT_ITERATED;
9515 dgst_pos0 = 0;
9516 dgst_pos1 = 1;
9517 dgst_pos2 = 2;
9518 dgst_pos3 = 3;
9519 break;
9520
9521 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9522 salt_type = SALT_TYPE_EMBEDDED;
9523 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9524 opts_type = OPTS_TYPE_PT_GENERATE_LE
9525 | OPTS_TYPE_PT_ADD80
9526 | OPTS_TYPE_PT_UNICODE
9527 | OPTS_TYPE_PT_NEVERCRACK;
9528 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9529 dgst_size = DGST_SIZE_4_4;
9530 parse_func = oldoffice01cm2_parse_hash;
9531 sort_by_digest = sort_by_digest_4_4;
9532 opti_type = OPTI_TYPE_ZERO_BYTE
9533 | OPTI_TYPE_PRECOMPUTE_INIT
9534 | OPTI_TYPE_NOT_ITERATED;
9535 dgst_pos0 = 0;
9536 dgst_pos1 = 1;
9537 dgst_pos2 = 2;
9538 dgst_pos3 = 3;
9539 break;
9540
9541 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9542 salt_type = SALT_TYPE_EMBEDDED;
9543 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9544 opts_type = OPTS_TYPE_PT_GENERATE_BE
9545 | OPTS_TYPE_PT_ADD80
9546 | OPTS_TYPE_PT_UNICODE;
9547 kern_type = KERN_TYPE_OLDOFFICE34;
9548 dgst_size = DGST_SIZE_4_4;
9549 parse_func = oldoffice34_parse_hash;
9550 sort_by_digest = sort_by_digest_4_4;
9551 opti_type = OPTI_TYPE_ZERO_BYTE
9552 | OPTI_TYPE_PRECOMPUTE_INIT
9553 | OPTI_TYPE_NOT_ITERATED;
9554 dgst_pos0 = 0;
9555 dgst_pos1 = 1;
9556 dgst_pos2 = 2;
9557 dgst_pos3 = 3;
9558 break;
9559
9560 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9561 salt_type = SALT_TYPE_EMBEDDED;
9562 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9563 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9564 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9565 dgst_size = DGST_SIZE_4_4;
9566 parse_func = oldoffice34cm1_parse_hash;
9567 sort_by_digest = sort_by_digest_4_4;
9568 opti_type = OPTI_TYPE_ZERO_BYTE
9569 | OPTI_TYPE_PRECOMPUTE_INIT
9570 | OPTI_TYPE_NOT_ITERATED;
9571 dgst_pos0 = 0;
9572 dgst_pos1 = 1;
9573 dgst_pos2 = 2;
9574 dgst_pos3 = 3;
9575 break;
9576
9577 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9578 salt_type = SALT_TYPE_EMBEDDED;
9579 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9580 opts_type = OPTS_TYPE_PT_GENERATE_BE
9581 | OPTS_TYPE_PT_ADD80
9582 | OPTS_TYPE_PT_UNICODE
9583 | OPTS_TYPE_PT_NEVERCRACK;
9584 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9585 dgst_size = DGST_SIZE_4_4;
9586 parse_func = oldoffice34cm2_parse_hash;
9587 sort_by_digest = sort_by_digest_4_4;
9588 opti_type = OPTI_TYPE_ZERO_BYTE
9589 | OPTI_TYPE_PRECOMPUTE_INIT
9590 | OPTI_TYPE_NOT_ITERATED;
9591 dgst_pos0 = 0;
9592 dgst_pos1 = 1;
9593 dgst_pos2 = 2;
9594 dgst_pos3 = 3;
9595 break;
9596
9597 case 9900: hash_type = HASH_TYPE_MD5;
9598 salt_type = SALT_TYPE_NONE;
9599 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9600 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9601 kern_type = KERN_TYPE_RADMIN2;
9602 dgst_size = DGST_SIZE_4_4;
9603 parse_func = radmin2_parse_hash;
9604 sort_by_digest = sort_by_digest_4_4;
9605 opti_type = OPTI_TYPE_ZERO_BYTE
9606 | OPTI_TYPE_PRECOMPUTE_INIT
9607 | OPTI_TYPE_EARLY_SKIP
9608 | OPTI_TYPE_NOT_ITERATED
9609 | OPTI_TYPE_NOT_SALTED;
9610 dgst_pos0 = 0;
9611 dgst_pos1 = 3;
9612 dgst_pos2 = 2;
9613 dgst_pos3 = 1;
9614 break;
9615
9616 case 10000: hash_type = HASH_TYPE_SHA256;
9617 salt_type = SALT_TYPE_EMBEDDED;
9618 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9619 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9620 kern_type = KERN_TYPE_PBKDF2_SHA256;
9621 dgst_size = DGST_SIZE_4_32;
9622 parse_func = djangopbkdf2_parse_hash;
9623 sort_by_digest = sort_by_digest_4_32;
9624 opti_type = OPTI_TYPE_ZERO_BYTE;
9625 dgst_pos0 = 0;
9626 dgst_pos1 = 1;
9627 dgst_pos2 = 2;
9628 dgst_pos3 = 3;
9629 break;
9630
9631 case 10100: hash_type = HASH_TYPE_SIPHASH;
9632 salt_type = SALT_TYPE_EMBEDDED;
9633 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9634 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9635 kern_type = KERN_TYPE_SIPHASH;
9636 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9637 parse_func = siphash_parse_hash;
9638 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9639 opti_type = OPTI_TYPE_ZERO_BYTE
9640 | OPTI_TYPE_NOT_ITERATED
9641 | OPTI_TYPE_RAW_HASH;
9642 dgst_pos0 = 0;
9643 dgst_pos1 = 1;
9644 dgst_pos2 = 2;
9645 dgst_pos3 = 3;
9646 break;
9647
9648 case 10200: hash_type = HASH_TYPE_MD5;
9649 salt_type = SALT_TYPE_EMBEDDED;
9650 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9651 opts_type = OPTS_TYPE_PT_GENERATE_LE
9652 | OPTS_TYPE_ST_ADD80
9653 | OPTS_TYPE_ST_ADDBITS14;
9654 kern_type = KERN_TYPE_HMACMD5_PW;
9655 dgst_size = DGST_SIZE_4_4;
9656 parse_func = crammd5_parse_hash;
9657 sort_by_digest = sort_by_digest_4_4;
9658 opti_type = OPTI_TYPE_ZERO_BYTE
9659 | OPTI_TYPE_NOT_ITERATED;
9660 dgst_pos0 = 0;
9661 dgst_pos1 = 3;
9662 dgst_pos2 = 2;
9663 dgst_pos3 = 1;
9664 break;
9665
9666 case 10300: hash_type = HASH_TYPE_SHA1;
9667 salt_type = SALT_TYPE_EMBEDDED;
9668 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9669 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9670 kern_type = KERN_TYPE_SAPH_SHA1;
9671 dgst_size = DGST_SIZE_4_5;
9672 parse_func = saph_sha1_parse_hash;
9673 sort_by_digest = sort_by_digest_4_5;
9674 opti_type = OPTI_TYPE_ZERO_BYTE;
9675 dgst_pos0 = 0;
9676 dgst_pos1 = 1;
9677 dgst_pos2 = 2;
9678 dgst_pos3 = 3;
9679 break;
9680
9681 case 10400: hash_type = HASH_TYPE_PDFU16;
9682 salt_type = SALT_TYPE_EMBEDDED;
9683 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9684 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9685 kern_type = KERN_TYPE_PDF11;
9686 dgst_size = DGST_SIZE_4_4;
9687 parse_func = pdf11_parse_hash;
9688 sort_by_digest = sort_by_digest_4_4;
9689 opti_type = OPTI_TYPE_ZERO_BYTE
9690 | OPTI_TYPE_NOT_ITERATED;
9691 dgst_pos0 = 0;
9692 dgst_pos1 = 1;
9693 dgst_pos2 = 2;
9694 dgst_pos3 = 3;
9695 break;
9696
9697 case 10410: hash_type = HASH_TYPE_PDFU16;
9698 salt_type = SALT_TYPE_EMBEDDED;
9699 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9700 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9701 kern_type = KERN_TYPE_PDF11CM1;
9702 dgst_size = DGST_SIZE_4_4;
9703 parse_func = pdf11cm1_parse_hash;
9704 sort_by_digest = sort_by_digest_4_4;
9705 opti_type = OPTI_TYPE_ZERO_BYTE
9706 | OPTI_TYPE_NOT_ITERATED;
9707 dgst_pos0 = 0;
9708 dgst_pos1 = 1;
9709 dgst_pos2 = 2;
9710 dgst_pos3 = 3;
9711 break;
9712
9713 case 10420: hash_type = HASH_TYPE_PDFU16;
9714 salt_type = SALT_TYPE_EMBEDDED;
9715 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9716 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9717 kern_type = KERN_TYPE_PDF11CM2;
9718 dgst_size = DGST_SIZE_4_4;
9719 parse_func = pdf11cm2_parse_hash;
9720 sort_by_digest = sort_by_digest_4_4;
9721 opti_type = OPTI_TYPE_ZERO_BYTE
9722 | OPTI_TYPE_NOT_ITERATED;
9723 dgst_pos0 = 0;
9724 dgst_pos1 = 1;
9725 dgst_pos2 = 2;
9726 dgst_pos3 = 3;
9727 break;
9728
9729 case 10500: hash_type = HASH_TYPE_PDFU16;
9730 salt_type = SALT_TYPE_EMBEDDED;
9731 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9732 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9733 kern_type = KERN_TYPE_PDF14;
9734 dgst_size = DGST_SIZE_4_4;
9735 parse_func = pdf14_parse_hash;
9736 sort_by_digest = sort_by_digest_4_4;
9737 opti_type = OPTI_TYPE_ZERO_BYTE
9738 | OPTI_TYPE_NOT_ITERATED;
9739 dgst_pos0 = 0;
9740 dgst_pos1 = 1;
9741 dgst_pos2 = 2;
9742 dgst_pos3 = 3;
9743 break;
9744
9745 case 10600: hash_type = HASH_TYPE_SHA256;
9746 salt_type = SALT_TYPE_EMBEDDED;
9747 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9748 opts_type = OPTS_TYPE_PT_GENERATE_BE
9749 | OPTS_TYPE_ST_ADD80
9750 | OPTS_TYPE_ST_ADDBITS15
9751 | OPTS_TYPE_HASH_COPY;
9752 kern_type = KERN_TYPE_SHA256_PWSLT;
9753 dgst_size = DGST_SIZE_4_8;
9754 parse_func = pdf17l3_parse_hash;
9755 sort_by_digest = sort_by_digest_4_8;
9756 opti_type = OPTI_TYPE_ZERO_BYTE
9757 | OPTI_TYPE_PRECOMPUTE_INIT
9758 | OPTI_TYPE_PRECOMPUTE_MERKLE
9759 | OPTI_TYPE_EARLY_SKIP
9760 | OPTI_TYPE_NOT_ITERATED
9761 | OPTI_TYPE_APPENDED_SALT
9762 | OPTI_TYPE_RAW_HASH;
9763 dgst_pos0 = 3;
9764 dgst_pos1 = 7;
9765 dgst_pos2 = 2;
9766 dgst_pos3 = 6;
9767 break;
9768
9769 case 10700: hash_type = HASH_TYPE_PDFU32;
9770 salt_type = SALT_TYPE_EMBEDDED;
9771 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9772 opts_type = OPTS_TYPE_PT_GENERATE_LE
9773 | OPTS_TYPE_HASH_COPY;
9774 kern_type = KERN_TYPE_PDF17L8;
9775 dgst_size = DGST_SIZE_4_8;
9776 parse_func = pdf17l8_parse_hash;
9777 sort_by_digest = sort_by_digest_4_8;
9778 opti_type = OPTI_TYPE_ZERO_BYTE
9779 | OPTI_TYPE_NOT_ITERATED;
9780 dgst_pos0 = 0;
9781 dgst_pos1 = 1;
9782 dgst_pos2 = 2;
9783 dgst_pos3 = 3;
9784 break;
9785
9786 case 10800: hash_type = HASH_TYPE_SHA384;
9787 salt_type = SALT_TYPE_NONE;
9788 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9789 opts_type = OPTS_TYPE_PT_GENERATE_BE
9790 | OPTS_TYPE_PT_ADD80
9791 | OPTS_TYPE_PT_ADDBITS15;
9792 kern_type = KERN_TYPE_SHA384;
9793 dgst_size = DGST_SIZE_8_8;
9794 parse_func = sha384_parse_hash;
9795 sort_by_digest = sort_by_digest_8_8;
9796 opti_type = OPTI_TYPE_ZERO_BYTE
9797 | OPTI_TYPE_PRECOMPUTE_INIT
9798 | OPTI_TYPE_PRECOMPUTE_MERKLE
9799 | OPTI_TYPE_EARLY_SKIP
9800 | OPTI_TYPE_NOT_ITERATED
9801 | OPTI_TYPE_NOT_SALTED
9802 | OPTI_TYPE_USES_BITS_64
9803 | OPTI_TYPE_RAW_HASH;
9804 dgst_pos0 = 6;
9805 dgst_pos1 = 7;
9806 dgst_pos2 = 4;
9807 dgst_pos3 = 5;
9808 break;
9809
9810 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9811 salt_type = SALT_TYPE_EMBEDDED;
9812 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9813 opts_type = OPTS_TYPE_PT_GENERATE_LE
9814 | OPTS_TYPE_ST_BASE64
9815 | OPTS_TYPE_HASH_COPY;
9816 kern_type = KERN_TYPE_PBKDF2_SHA256;
9817 dgst_size = DGST_SIZE_4_32;
9818 parse_func = pbkdf2_sha256_parse_hash;
9819 sort_by_digest = sort_by_digest_4_32;
9820 opti_type = OPTI_TYPE_ZERO_BYTE;
9821 dgst_pos0 = 0;
9822 dgst_pos1 = 1;
9823 dgst_pos2 = 2;
9824 dgst_pos3 = 3;
9825 break;
9826
9827 case 11000: hash_type = HASH_TYPE_MD5;
9828 salt_type = SALT_TYPE_INTERN;
9829 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9830 opts_type = OPTS_TYPE_PT_GENERATE_LE
9831 | OPTS_TYPE_PT_ADD80;
9832 kern_type = KERN_TYPE_PRESTASHOP;
9833 dgst_size = DGST_SIZE_4_4;
9834 parse_func = prestashop_parse_hash;
9835 sort_by_digest = sort_by_digest_4_4;
9836 opti_type = OPTI_TYPE_ZERO_BYTE
9837 | OPTI_TYPE_PRECOMPUTE_INIT
9838 | OPTI_TYPE_NOT_ITERATED
9839 | OPTI_TYPE_PREPENDED_SALT;
9840 dgst_pos0 = 0;
9841 dgst_pos1 = 3;
9842 dgst_pos2 = 2;
9843 dgst_pos3 = 1;
9844 break;
9845
9846 case 11100: hash_type = HASH_TYPE_MD5;
9847 salt_type = SALT_TYPE_EMBEDDED;
9848 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9849 opts_type = OPTS_TYPE_PT_GENERATE_LE
9850 | OPTS_TYPE_ST_ADD80;
9851 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9852 dgst_size = DGST_SIZE_4_4;
9853 parse_func = postgresql_auth_parse_hash;
9854 sort_by_digest = sort_by_digest_4_4;
9855 opti_type = OPTI_TYPE_ZERO_BYTE
9856 | OPTI_TYPE_PRECOMPUTE_INIT
9857 | OPTI_TYPE_PRECOMPUTE_MERKLE
9858 | OPTI_TYPE_EARLY_SKIP;
9859 dgst_pos0 = 0;
9860 dgst_pos1 = 3;
9861 dgst_pos2 = 2;
9862 dgst_pos3 = 1;
9863 break;
9864
9865 case 11200: hash_type = HASH_TYPE_SHA1;
9866 salt_type = SALT_TYPE_EMBEDDED;
9867 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9868 opts_type = OPTS_TYPE_PT_GENERATE_BE
9869 | OPTS_TYPE_PT_ADD80
9870 | OPTS_TYPE_ST_HEX;
9871 kern_type = KERN_TYPE_MYSQL_AUTH;
9872 dgst_size = DGST_SIZE_4_5;
9873 parse_func = mysql_auth_parse_hash;
9874 sort_by_digest = sort_by_digest_4_5;
9875 opti_type = OPTI_TYPE_ZERO_BYTE
9876 | OPTI_TYPE_EARLY_SKIP;
9877 dgst_pos0 = 3;
9878 dgst_pos1 = 4;
9879 dgst_pos2 = 2;
9880 dgst_pos3 = 1;
9881 break;
9882
9883 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9884 salt_type = SALT_TYPE_EMBEDDED;
9885 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9886 opts_type = OPTS_TYPE_PT_GENERATE_LE
9887 | OPTS_TYPE_ST_HEX
9888 | OPTS_TYPE_ST_ADD80;
9889 kern_type = KERN_TYPE_BITCOIN_WALLET;
9890 dgst_size = DGST_SIZE_4_4;
9891 parse_func = bitcoin_wallet_parse_hash;
9892 sort_by_digest = sort_by_digest_4_4;
9893 opti_type = OPTI_TYPE_ZERO_BYTE;
9894 dgst_pos0 = 0;
9895 dgst_pos1 = 1;
9896 dgst_pos2 = 2;
9897 dgst_pos3 = 3;
9898 break;
9899
9900 case 11400: hash_type = HASH_TYPE_MD5;
9901 salt_type = SALT_TYPE_EMBEDDED;
9902 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9903 opts_type = OPTS_TYPE_PT_GENERATE_LE
9904 | OPTS_TYPE_PT_ADD80
9905 | OPTS_TYPE_HASH_COPY;
9906 kern_type = KERN_TYPE_SIP_AUTH;
9907 dgst_size = DGST_SIZE_4_4;
9908 parse_func = sip_auth_parse_hash;
9909 sort_by_digest = sort_by_digest_4_4;
9910 opti_type = OPTI_TYPE_ZERO_BYTE;
9911 dgst_pos0 = 0;
9912 dgst_pos1 = 3;
9913 dgst_pos2 = 2;
9914 dgst_pos3 = 1;
9915 break;
9916
9917 case 11500: hash_type = HASH_TYPE_CRC32;
9918 salt_type = SALT_TYPE_INTERN;
9919 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9920 opts_type = OPTS_TYPE_PT_GENERATE_LE
9921 | OPTS_TYPE_ST_GENERATE_LE
9922 | OPTS_TYPE_ST_HEX;
9923 kern_type = KERN_TYPE_CRC32;
9924 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9925 parse_func = crc32_parse_hash;
9926 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9927 opti_type = OPTI_TYPE_ZERO_BYTE;
9928 dgst_pos0 = 0;
9929 dgst_pos1 = 1;
9930 dgst_pos2 = 2;
9931 dgst_pos3 = 3;
9932 break;
9933
9934 case 11600: hash_type = HASH_TYPE_AES;
9935 salt_type = SALT_TYPE_EMBEDDED;
9936 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9937 opts_type = OPTS_TYPE_PT_GENERATE_LE
9938 | OPTS_TYPE_PT_NEVERCRACK;
9939 kern_type = KERN_TYPE_SEVEN_ZIP;
9940 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9941 parse_func = seven_zip_parse_hash;
9942 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9943 opti_type = OPTI_TYPE_ZERO_BYTE;
9944 dgst_pos0 = 0;
9945 dgst_pos1 = 1;
9946 dgst_pos2 = 2;
9947 dgst_pos3 = 3;
9948 break;
9949
9950 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9951 salt_type = SALT_TYPE_NONE;
9952 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9953 opts_type = OPTS_TYPE_PT_GENERATE_LE
9954 | OPTS_TYPE_PT_ADD01;
9955 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9956 dgst_size = DGST_SIZE_4_8;
9957 parse_func = gost2012sbog_256_parse_hash;
9958 sort_by_digest = sort_by_digest_4_8;
9959 opti_type = OPTI_TYPE_ZERO_BYTE;
9960 dgst_pos0 = 0;
9961 dgst_pos1 = 1;
9962 dgst_pos2 = 2;
9963 dgst_pos3 = 3;
9964 break;
9965
9966 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9967 salt_type = SALT_TYPE_NONE;
9968 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9969 opts_type = OPTS_TYPE_PT_GENERATE_LE
9970 | OPTS_TYPE_PT_ADD01;
9971 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9972 dgst_size = DGST_SIZE_4_16;
9973 parse_func = gost2012sbog_512_parse_hash;
9974 sort_by_digest = sort_by_digest_4_16;
9975 opti_type = OPTI_TYPE_ZERO_BYTE;
9976 dgst_pos0 = 0;
9977 dgst_pos1 = 1;
9978 dgst_pos2 = 2;
9979 dgst_pos3 = 3;
9980 break;
9981
9982 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9983 salt_type = SALT_TYPE_EMBEDDED;
9984 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9985 opts_type = OPTS_TYPE_PT_GENERATE_LE
9986 | OPTS_TYPE_ST_BASE64
9987 | OPTS_TYPE_HASH_COPY;
9988 kern_type = KERN_TYPE_PBKDF2_MD5;
9989 dgst_size = DGST_SIZE_4_32;
9990 parse_func = pbkdf2_md5_parse_hash;
9991 sort_by_digest = sort_by_digest_4_32;
9992 opti_type = OPTI_TYPE_ZERO_BYTE;
9993 dgst_pos0 = 0;
9994 dgst_pos1 = 1;
9995 dgst_pos2 = 2;
9996 dgst_pos3 = 3;
9997 break;
9998
9999 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10000 salt_type = SALT_TYPE_EMBEDDED;
10001 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10002 opts_type = OPTS_TYPE_PT_GENERATE_LE
10003 | OPTS_TYPE_ST_BASE64
10004 | OPTS_TYPE_HASH_COPY;
10005 kern_type = KERN_TYPE_PBKDF2_SHA1;
10006 dgst_size = DGST_SIZE_4_32;
10007 parse_func = pbkdf2_sha1_parse_hash;
10008 sort_by_digest = sort_by_digest_4_32;
10009 opti_type = OPTI_TYPE_ZERO_BYTE;
10010 dgst_pos0 = 0;
10011 dgst_pos1 = 1;
10012 dgst_pos2 = 2;
10013 dgst_pos3 = 3;
10014 break;
10015
10016 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10017 salt_type = SALT_TYPE_EMBEDDED;
10018 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10019 opts_type = OPTS_TYPE_PT_GENERATE_LE
10020 | OPTS_TYPE_ST_BASE64
10021 | OPTS_TYPE_HASH_COPY;
10022 kern_type = KERN_TYPE_PBKDF2_SHA512;
10023 dgst_size = DGST_SIZE_8_16;
10024 parse_func = pbkdf2_sha512_parse_hash;
10025 sort_by_digest = sort_by_digest_8_16;
10026 opti_type = OPTI_TYPE_ZERO_BYTE
10027 | OPTI_TYPE_USES_BITS_64;
10028 dgst_pos0 = 0;
10029 dgst_pos1 = 1;
10030 dgst_pos2 = 2;
10031 dgst_pos3 = 3;
10032 break;
10033
10034 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10035 salt_type = SALT_TYPE_EMBEDDED;
10036 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10037 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10038 kern_type = KERN_TYPE_ECRYPTFS;
10039 dgst_size = DGST_SIZE_8_8;
10040 parse_func = ecryptfs_parse_hash;
10041 sort_by_digest = sort_by_digest_8_8;
10042 opti_type = OPTI_TYPE_ZERO_BYTE
10043 | OPTI_TYPE_USES_BITS_64;
10044 dgst_pos0 = 0;
10045 dgst_pos1 = 1;
10046 dgst_pos2 = 2;
10047 dgst_pos3 = 3;
10048 break;
10049
10050 case 12300: hash_type = HASH_TYPE_ORACLET;
10051 salt_type = SALT_TYPE_EMBEDDED;
10052 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10053 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10054 kern_type = KERN_TYPE_ORACLET;
10055 dgst_size = DGST_SIZE_8_16;
10056 parse_func = oraclet_parse_hash;
10057 sort_by_digest = sort_by_digest_8_16;
10058 opti_type = OPTI_TYPE_ZERO_BYTE
10059 | OPTI_TYPE_USES_BITS_64;
10060 dgst_pos0 = 0;
10061 dgst_pos1 = 1;
10062 dgst_pos2 = 2;
10063 dgst_pos3 = 3;
10064 break;
10065
10066 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10067 salt_type = SALT_TYPE_EMBEDDED;
10068 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10069 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10070 kern_type = KERN_TYPE_BSDICRYPT;
10071 dgst_size = DGST_SIZE_4_4;
10072 parse_func = bsdicrypt_parse_hash;
10073 sort_by_digest = sort_by_digest_4_4;
10074 opti_type = OPTI_TYPE_ZERO_BYTE
10075 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10076 dgst_pos0 = 0;
10077 dgst_pos1 = 1;
10078 dgst_pos2 = 2;
10079 dgst_pos3 = 3;
10080 break;
10081
10082 case 12500: hash_type = HASH_TYPE_RAR3HP;
10083 salt_type = SALT_TYPE_EMBEDDED;
10084 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10085 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10086 kern_type = KERN_TYPE_RAR3;
10087 dgst_size = DGST_SIZE_4_4;
10088 parse_func = rar3hp_parse_hash;
10089 sort_by_digest = sort_by_digest_4_4;
10090 opti_type = OPTI_TYPE_ZERO_BYTE;
10091 dgst_pos0 = 0;
10092 dgst_pos1 = 1;
10093 dgst_pos2 = 2;
10094 dgst_pos3 = 3;
10095 break;
10096
10097 case 12600: hash_type = HASH_TYPE_SHA256;
10098 salt_type = SALT_TYPE_INTERN;
10099 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10100 opts_type = OPTS_TYPE_PT_GENERATE_BE
10101 | OPTS_TYPE_PT_ADD80;
10102 kern_type = KERN_TYPE_CF10;
10103 dgst_size = DGST_SIZE_4_8;
10104 parse_func = cf10_parse_hash;
10105 sort_by_digest = sort_by_digest_4_8;
10106 opti_type = OPTI_TYPE_ZERO_BYTE
10107 | OPTI_TYPE_PRECOMPUTE_INIT
10108 | OPTI_TYPE_EARLY_SKIP
10109 | OPTI_TYPE_NOT_ITERATED;
10110 dgst_pos0 = 3;
10111 dgst_pos1 = 7;
10112 dgst_pos2 = 2;
10113 dgst_pos3 = 6;
10114 break;
10115
10116 case 12700: hash_type = HASH_TYPE_AES;
10117 salt_type = SALT_TYPE_EMBEDDED;
10118 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10119 opts_type = OPTS_TYPE_PT_GENERATE_LE
10120 | OPTS_TYPE_HASH_COPY;
10121 kern_type = KERN_TYPE_MYWALLET;
10122 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10123 parse_func = mywallet_parse_hash;
10124 sort_by_digest = sort_by_digest_4_5;
10125 opti_type = OPTI_TYPE_ZERO_BYTE;
10126 dgst_pos0 = 0;
10127 dgst_pos1 = 1;
10128 dgst_pos2 = 2;
10129 dgst_pos3 = 3;
10130 break;
10131
10132 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10133 salt_type = SALT_TYPE_EMBEDDED;
10134 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10135 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10136 kern_type = KERN_TYPE_MS_DRSR;
10137 dgst_size = DGST_SIZE_4_8;
10138 parse_func = ms_drsr_parse_hash;
10139 sort_by_digest = sort_by_digest_4_8;
10140 opti_type = OPTI_TYPE_ZERO_BYTE;
10141 dgst_pos0 = 0;
10142 dgst_pos1 = 1;
10143 dgst_pos2 = 2;
10144 dgst_pos3 = 3;
10145 break;
10146
10147 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10148 salt_type = SALT_TYPE_EMBEDDED;
10149 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10150 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10151 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10152 dgst_size = DGST_SIZE_4_8;
10153 parse_func = androidfde_samsung_parse_hash;
10154 sort_by_digest = sort_by_digest_4_8;
10155 opti_type = OPTI_TYPE_ZERO_BYTE;
10156 dgst_pos0 = 0;
10157 dgst_pos1 = 1;
10158 dgst_pos2 = 2;
10159 dgst_pos3 = 3;
10160 break;
10161
10162 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10163 salt_type = SALT_TYPE_EMBEDDED;
10164 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10165 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10166 kern_type = KERN_TYPE_RAR5;
10167 dgst_size = DGST_SIZE_4_4;
10168 parse_func = rar5_parse_hash;
10169 sort_by_digest = sort_by_digest_4_4;
10170 opti_type = OPTI_TYPE_ZERO_BYTE;
10171 dgst_pos0 = 0;
10172 dgst_pos1 = 1;
10173 dgst_pos2 = 2;
10174 dgst_pos3 = 3;
10175 break;
10176
10177 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10178 salt_type = SALT_TYPE_EMBEDDED;
10179 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10180 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10181 kern_type = KERN_TYPE_KRB5TGS;
10182 dgst_size = DGST_SIZE_4_4;
10183 parse_func = krb5tgs_parse_hash;
10184 sort_by_digest = sort_by_digest_4_4;
10185 opti_type = OPTI_TYPE_ZERO_BYTE
10186 | OPTI_TYPE_NOT_ITERATED;
10187 dgst_pos0 = 0;
10188 dgst_pos1 = 1;
10189 dgst_pos2 = 2;
10190 dgst_pos3 = 3;
10191 break;
10192
10193 case 13200: hash_type = HASH_TYPE_AES;
10194 salt_type = SALT_TYPE_EMBEDDED;
10195 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10196 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10197 kern_type = KERN_TYPE_AXCRYPT;
10198 dgst_size = DGST_SIZE_4_4;
10199 parse_func = axcrypt_parse_hash;
10200 sort_by_digest = sort_by_digest_4_4;
10201 opti_type = OPTI_TYPE_ZERO_BYTE;
10202 dgst_pos0 = 0;
10203 dgst_pos1 = 1;
10204 dgst_pos2 = 2;
10205 dgst_pos3 = 3;
10206 break;
10207
10208 case 13300: hash_type = HASH_TYPE_SHA1;
10209 salt_type = SALT_TYPE_NONE;
10210 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10211 opts_type = OPTS_TYPE_PT_GENERATE_BE
10212 | OPTS_TYPE_PT_ADD80
10213 | OPTS_TYPE_PT_ADDBITS15;
10214 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10215 dgst_size = DGST_SIZE_4_5;
10216 parse_func = sha1axcrypt_parse_hash;
10217 sort_by_digest = sort_by_digest_4_5;
10218 opti_type = OPTI_TYPE_ZERO_BYTE
10219 | OPTI_TYPE_PRECOMPUTE_INIT
10220 | OPTI_TYPE_EARLY_SKIP
10221 | OPTI_TYPE_NOT_ITERATED
10222 | OPTI_TYPE_NOT_SALTED;
10223 dgst_pos0 = 0;
10224 dgst_pos1 = 4;
10225 dgst_pos2 = 3;
10226 dgst_pos3 = 2;
10227 break;
10228
10229 default: usage_mini_print (PROGNAME); return (-1);
10230 }
10231
10232 /**
10233 * parser
10234 */
10235
10236 data.parse_func = parse_func;
10237
10238 /**
10239 * misc stuff
10240 */
10241
10242 if (hex_salt)
10243 {
10244 if (salt_type == SALT_TYPE_INTERN)
10245 {
10246 opts_type |= OPTS_TYPE_ST_HEX;
10247 }
10248 else
10249 {
10250 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10251
10252 return (-1);
10253 }
10254 }
10255
10256 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10257 | (salt_type == SALT_TYPE_EXTERN)
10258 | (salt_type == SALT_TYPE_EMBEDDED)
10259 | (salt_type == SALT_TYPE_VIRTUAL));
10260
10261 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10262
10263 data.hash_type = hash_type;
10264 data.attack_mode = attack_mode;
10265 data.attack_kern = attack_kern;
10266 data.attack_exec = attack_exec;
10267 data.kern_type = kern_type;
10268 data.opts_type = opts_type;
10269 data.dgst_size = dgst_size;
10270 data.salt_type = salt_type;
10271 data.isSalted = isSalted;
10272 data.sort_by_digest = sort_by_digest;
10273 data.dgst_pos0 = dgst_pos0;
10274 data.dgst_pos1 = dgst_pos1;
10275 data.dgst_pos2 = dgst_pos2;
10276 data.dgst_pos3 = dgst_pos3;
10277
10278 esalt_size = 0;
10279
10280 switch (hash_mode)
10281 {
10282 case 2500: esalt_size = sizeof (wpa_t); break;
10283 case 5300: esalt_size = sizeof (ikepsk_t); break;
10284 case 5400: esalt_size = sizeof (ikepsk_t); break;
10285 case 5500: esalt_size = sizeof (netntlm_t); break;
10286 case 5600: esalt_size = sizeof (netntlm_t); break;
10287 case 6211: esalt_size = sizeof (tc_t); break;
10288 case 6212: esalt_size = sizeof (tc_t); break;
10289 case 6213: esalt_size = sizeof (tc_t); break;
10290 case 6221: esalt_size = sizeof (tc_t); break;
10291 case 6222: esalt_size = sizeof (tc_t); break;
10292 case 6223: esalt_size = sizeof (tc_t); break;
10293 case 6231: esalt_size = sizeof (tc_t); break;
10294 case 6232: esalt_size = sizeof (tc_t); break;
10295 case 6233: esalt_size = sizeof (tc_t); break;
10296 case 6241: esalt_size = sizeof (tc_t); break;
10297 case 6242: esalt_size = sizeof (tc_t); break;
10298 case 6243: esalt_size = sizeof (tc_t); break;
10299 case 6600: esalt_size = sizeof (agilekey_t); break;
10300 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10301 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10302 case 7300: esalt_size = sizeof (rakp_t); break;
10303 case 7500: esalt_size = sizeof (krb5pa_t); break;
10304 case 8200: esalt_size = sizeof (cloudkey_t); break;
10305 case 8800: esalt_size = sizeof (androidfde_t); break;
10306 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10307 case 9400: esalt_size = sizeof (office2007_t); break;
10308 case 9500: esalt_size = sizeof (office2010_t); break;
10309 case 9600: esalt_size = sizeof (office2013_t); break;
10310 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10311 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10312 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10313 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10314 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10315 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10316 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10317 case 10200: esalt_size = sizeof (cram_md5_t); break;
10318 case 10400: esalt_size = sizeof (pdf_t); break;
10319 case 10410: esalt_size = sizeof (pdf_t); break;
10320 case 10420: esalt_size = sizeof (pdf_t); break;
10321 case 10500: esalt_size = sizeof (pdf_t); break;
10322 case 10600: esalt_size = sizeof (pdf_t); break;
10323 case 10700: esalt_size = sizeof (pdf_t); break;
10324 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10325 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10326 case 11400: esalt_size = sizeof (sip_t); break;
10327 case 11600: esalt_size = sizeof (seven_zip_t); break;
10328 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10329 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10330 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10331 case 13000: esalt_size = sizeof (rar5_t); break;
10332 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10333 }
10334
10335 data.esalt_size = esalt_size;
10336
10337 /**
10338 * choose dictionary parser
10339 */
10340
10341 if (hash_type == HASH_TYPE_LM)
10342 {
10343 get_next_word_func = get_next_word_lm;
10344 }
10345 else if (opts_type & OPTS_TYPE_PT_UPPER)
10346 {
10347 get_next_word_func = get_next_word_uc;
10348 }
10349 else
10350 {
10351 get_next_word_func = get_next_word_std;
10352 }
10353
10354 /**
10355 * dictstat
10356 */
10357
10358 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10359
10360 #ifdef _POSIX
10361 size_t dictstat_nmemb = 0;
10362 #endif
10363
10364 #ifdef _WIN
10365 uint dictstat_nmemb = 0;
10366 #endif
10367
10368 char dictstat[256] = { 0 };
10369
10370 FILE *dictstat_fp = NULL;
10371
10372 if (keyspace == 0)
10373 {
10374 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10375
10376 dictstat_fp = fopen (dictstat, "rb");
10377
10378 if (dictstat_fp)
10379 {
10380 #ifdef _POSIX
10381 struct stat tmpstat;
10382
10383 fstat (fileno (dictstat_fp), &tmpstat);
10384 #endif
10385
10386 #ifdef _WIN
10387 struct stat64 tmpstat;
10388
10389 _fstat64 (fileno (dictstat_fp), &tmpstat);
10390 #endif
10391
10392 if (tmpstat.st_mtime < COMPTIME)
10393 {
10394 /* with v0.15 the format changed so we have to ensure user is using a good version
10395 since there is no version-header in the dictstat file */
10396
10397 fclose (dictstat_fp);
10398
10399 unlink (dictstat);
10400 }
10401 else
10402 {
10403 while (!feof (dictstat_fp))
10404 {
10405 dictstat_t d;
10406
10407 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10408
10409 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10410
10411 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10412 {
10413 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10414
10415 return -1;
10416 }
10417 }
10418
10419 fclose (dictstat_fp);
10420 }
10421 }
10422 }
10423
10424 /**
10425 * potfile
10426 */
10427
10428 char potfile[256] = { 0 };
10429
10430 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10431
10432 data.pot_fp = NULL;
10433
10434 FILE *out_fp = NULL;
10435 FILE *pot_fp = NULL;
10436
10437 if (show == 1 || left == 1)
10438 {
10439 pot_fp = fopen (potfile, "rb");
10440
10441 if (pot_fp == NULL)
10442 {
10443 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10444
10445 return (-1);
10446 }
10447
10448 if (outfile != NULL)
10449 {
10450 if ((out_fp = fopen (outfile, "ab")) == NULL)
10451 {
10452 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10453
10454 fclose (pot_fp);
10455
10456 return (-1);
10457 }
10458 }
10459 else
10460 {
10461 out_fp = stdout;
10462 }
10463 }
10464 else
10465 {
10466 if (potfile_disable == 0)
10467 {
10468 pot_fp = fopen (potfile, "ab");
10469
10470 if (pot_fp == NULL)
10471 {
10472 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10473
10474 return (-1);
10475 }
10476
10477 data.pot_fp = pot_fp;
10478 }
10479 }
10480
10481 pot_t *pot = NULL;
10482
10483 uint pot_cnt = 0;
10484 uint pot_avail = 0;
10485
10486 if (show == 1 || left == 1)
10487 {
10488 SUPPRESS_OUTPUT = 1;
10489
10490 pot_avail = count_lines (pot_fp);
10491
10492 rewind (pot_fp);
10493
10494 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10495
10496 uint pot_hashes_avail = 0;
10497
10498 uint line_num = 0;
10499
10500 while (!feof (pot_fp))
10501 {
10502 line_num++;
10503
10504 char line_buf[BUFSIZ] = { 0 };
10505
10506 int line_len = fgetl (pot_fp, line_buf);
10507
10508 if (line_len == 0) continue;
10509
10510 char *plain_buf = line_buf + line_len;
10511
10512 pot_t *pot_ptr = &pot[pot_cnt];
10513
10514 hash_t *hashes_buf = &pot_ptr->hash;
10515
10516 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10517 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10518
10519 if (pot_cnt == pot_hashes_avail)
10520 {
10521 uint pos = 0;
10522
10523 for (pos = 0; pos < INCR_POT; pos++)
10524 {
10525 if ((pot_cnt + pos) >= pot_avail) break;
10526
10527 pot_t *tmp_pot = &pot[pot_cnt + pos];
10528
10529 hash_t *tmp_hash = &tmp_pot->hash;
10530
10531 tmp_hash->digest = mymalloc (dgst_size);
10532
10533 if (isSalted)
10534 {
10535 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10536 }
10537
10538 if (esalt_size)
10539 {
10540 tmp_hash->esalt = mymalloc (esalt_size);
10541 }
10542
10543 pot_hashes_avail++;
10544 }
10545 }
10546
10547 int plain_len = 0;
10548
10549 int parser_status;
10550
10551 int iter = MAX_CUT_TRIES;
10552
10553 do
10554 {
10555 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10556 {
10557 if (line_buf[i] == ':')
10558 {
10559 line_len--;
10560
10561 break;
10562 }
10563 }
10564
10565 if (data.hash_mode != 2500)
10566 {
10567 parser_status = parse_func (line_buf, line_len, hashes_buf);
10568 }
10569 else
10570 {
10571 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10572
10573 if (line_len > max_salt_size)
10574 {
10575 parser_status = PARSER_GLOBAL_LENGTH;
10576 }
10577 else
10578 {
10579 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10580
10581 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10582
10583 hashes_buf->salt->salt_len = line_len;
10584
10585 parser_status = PARSER_OK;
10586 }
10587 }
10588
10589 // if NOT parsed without error, we add the ":" to the plain
10590
10591 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10592 {
10593 plain_len++;
10594 plain_buf--;
10595 }
10596
10597 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10598
10599 if (parser_status < PARSER_GLOBAL_ZERO)
10600 {
10601 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10602
10603 continue;
10604 }
10605
10606 if (plain_len >= 255) continue;
10607
10608 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10609
10610 pot_ptr->plain_len = plain_len;
10611
10612 pot_cnt++;
10613 }
10614
10615 fclose (pot_fp);
10616
10617 SUPPRESS_OUTPUT = 0;
10618
10619 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10620 }
10621
10622 /**
10623 * word len
10624 */
10625
10626 uint pw_min = PW_MIN;
10627 uint pw_max = PW_MAX;
10628
10629 switch (hash_mode)
10630 {
10631 case 400: if (pw_max > 40) pw_max = 40;
10632 break;
10633 case 500: if (pw_max > 16) pw_max = 16;
10634 break;
10635 case 1500: if (pw_max > 8) pw_max = 8;
10636 break;
10637 case 1600: if (pw_max > 16) pw_max = 16;
10638 break;
10639 case 1800: if (pw_max > 16) pw_max = 16;
10640 break;
10641 case 2100: if (pw_max > 16) pw_max = 16;
10642 break;
10643 case 2500: if (pw_min < 8) pw_min = 8;
10644 break;
10645 case 3000: if (pw_max > 7) pw_max = 7;
10646 break;
10647 case 5200: if (pw_max > 24) pw_max = 24;
10648 break;
10649 case 5800: if (pw_max > 16) pw_max = 16;
10650 break;
10651 case 6300: if (pw_max > 16) pw_max = 16;
10652 break;
10653 case 7400: if (pw_max > 16) pw_max = 16;
10654 break;
10655 case 7900: if (pw_max > 48) pw_max = 48;
10656 break;
10657 case 8500: if (pw_max > 8) pw_max = 8;
10658 break;
10659 case 8600: if (pw_max > 16) pw_max = 16;
10660 break;
10661 case 9710: pw_min = 5;
10662 pw_max = 5;
10663 break;
10664 case 9810: pw_min = 5;
10665 pw_max = 5;
10666 break;
10667 case 10410: pw_min = 5;
10668 pw_max = 5;
10669 break;
10670 case 10300: if (pw_max < 3) pw_min = 3;
10671 if (pw_max > 40) pw_max = 40;
10672 break;
10673 case 10500: if (pw_max < 3) pw_min = 3;
10674 if (pw_max > 40) pw_max = 40;
10675 break;
10676 case 10700: if (pw_max > 16) pw_max = 16;
10677 break;
10678 case 11300: if (pw_max > 40) pw_max = 40;
10679 break;
10680 case 12500: if (pw_max > 20) pw_max = 20;
10681 break;
10682 case 12800: if (pw_max > 24) pw_max = 24;
10683 break;
10684 }
10685
10686 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10687 {
10688 switch (attack_kern)
10689 {
10690 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10691 break;
10692 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10693 break;
10694 }
10695 }
10696
10697 /**
10698 * charsets : keep them together for more easy maintainnce
10699 */
10700
10701 cs_t mp_sys[6] = { { { 0 }, 0 } };
10702 cs_t mp_usr[4] = { { { 0 }, 0 } };
10703
10704 mp_setup_sys (mp_sys);
10705
10706 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10707 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10708 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10709 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10710
10711 /**
10712 * load hashes, part I: find input mode, count hashes
10713 */
10714
10715 uint hashlist_mode = 0;
10716 uint hashlist_format = HLFMT_HASHCAT;
10717
10718 uint hashes_avail = 0;
10719
10720 if (benchmark == 0)
10721 {
10722 struct stat f;
10723
10724 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10725
10726 if ((hash_mode == 2500) ||
10727 (hash_mode == 5200) ||
10728 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10729 (hash_mode == 9000))
10730 {
10731 hashlist_mode = HL_MODE_ARG;
10732
10733 char *hashfile = myargv[optind];
10734
10735 data.hashfile = hashfile;
10736
10737 logfile_top_var_string ("target", hashfile);
10738 }
10739
10740 if (hashlist_mode == HL_MODE_ARG)
10741 {
10742 if (hash_mode == 2500)
10743 {
10744 struct stat st;
10745
10746 if (stat (data.hashfile, &st) == -1)
10747 {
10748 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10749
10750 return (-1);
10751 }
10752
10753 hashes_avail = st.st_size / sizeof (hccap_t);
10754 }
10755 else
10756 {
10757 hashes_avail = 1;
10758 }
10759 }
10760 else if (hashlist_mode == HL_MODE_FILE)
10761 {
10762 char *hashfile = myargv[optind];
10763
10764 data.hashfile = hashfile;
10765
10766 logfile_top_var_string ("target", hashfile);
10767
10768 FILE *fp = NULL;
10769
10770 if ((fp = fopen (hashfile, "rb")) == NULL)
10771 {
10772 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10773
10774 return (-1);
10775 }
10776
10777 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10778
10779 hashes_avail = count_lines (fp);
10780
10781 rewind (fp);
10782
10783 if (hashes_avail == 0)
10784 {
10785 log_error ("ERROR: hashfile is empty or corrupt");
10786
10787 fclose (fp);
10788
10789 return (-1);
10790 }
10791
10792 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10793
10794 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10795 {
10796 log_error ("ERROR: remove not supported in native hashfile-format mode");
10797
10798 fclose (fp);
10799
10800 return (-1);
10801 }
10802
10803 fclose (fp);
10804 }
10805 }
10806 else
10807 {
10808 hashlist_mode = HL_MODE_ARG;
10809
10810 hashes_avail = 1;
10811 }
10812
10813 if (hash_mode == 3000) hashes_avail *= 2;
10814
10815 data.hashlist_mode = hashlist_mode;
10816 data.hashlist_format = hashlist_format;
10817
10818 logfile_top_uint (hashlist_mode);
10819 logfile_top_uint (hashlist_format);
10820
10821 /**
10822 * load hashes, part II: allocate required memory, set pointers
10823 */
10824
10825 hash_t *hashes_buf = NULL;
10826 void *digests_buf = NULL;
10827 salt_t *salts_buf = NULL;
10828 void *esalts_buf = NULL;
10829
10830 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10831
10832 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10833
10834 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10835 {
10836 u32 hash_pos;
10837
10838 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10839 {
10840 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10841
10842 hashes_buf[hash_pos].hash_info = hash_info;
10843
10844 if (username && (remove || show || left))
10845 {
10846 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10847 }
10848
10849 if (benchmark)
10850 {
10851 hash_info->orighash = (char *) mymalloc (256);
10852 }
10853 }
10854 }
10855
10856 if (isSalted)
10857 {
10858 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10859
10860 if (esalt_size)
10861 {
10862 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10863 }
10864 }
10865 else
10866 {
10867 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10868 }
10869
10870 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10871 {
10872 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10873
10874 if (isSalted)
10875 {
10876 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10877
10878 if (esalt_size)
10879 {
10880 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10881 }
10882 }
10883 else
10884 {
10885 hashes_buf[hash_pos].salt = &salts_buf[0];
10886 }
10887 }
10888
10889 /**
10890 * load hashes, part III: parse hashes or generate them if benchmark
10891 */
10892
10893 uint hashes_cnt = 0;
10894
10895 if (benchmark == 0)
10896 {
10897 if (keyspace == 1)
10898 {
10899 // useless to read hash file for keyspace, cheat a little bit w/ optind
10900 }
10901 else if (hashes_avail == 0)
10902 {
10903 }
10904 else if (hashlist_mode == HL_MODE_ARG)
10905 {
10906 char *input_buf = myargv[optind];
10907
10908 uint input_len = strlen (input_buf);
10909
10910 logfile_top_var_string ("target", input_buf);
10911
10912 char *hash_buf = NULL;
10913 int hash_len = 0;
10914
10915 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10916
10917 if (hash_len)
10918 {
10919 if (opts_type & OPTS_TYPE_HASH_COPY)
10920 {
10921 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10922
10923 hash_info_tmp->orighash = mystrdup (hash_buf);
10924 }
10925
10926 if (isSalted)
10927 {
10928 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10929 }
10930
10931 int parser_status = PARSER_OK;
10932
10933 if (hash_mode == 2500)
10934 {
10935 if (hash_len == 0)
10936 {
10937 log_error ("ERROR: hccap file not specified");
10938
10939 return (-1);
10940 }
10941
10942 hashlist_mode = HL_MODE_FILE;
10943
10944 data.hashlist_mode = hashlist_mode;
10945
10946 FILE *fp = fopen (hash_buf, "rb");
10947
10948 if (fp == NULL)
10949 {
10950 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10951
10952 return (-1);
10953 }
10954
10955 if (hashes_avail < 1)
10956 {
10957 log_error ("ERROR: hccap file is empty or corrupt");
10958
10959 fclose (fp);
10960
10961 return (-1);
10962 }
10963
10964 uint hccap_size = sizeof (hccap_t);
10965
10966 char *in = (char *) mymalloc (hccap_size);
10967
10968 while (!feof (fp))
10969 {
10970 int n = fread (in, hccap_size, 1, fp);
10971
10972 if (n != 1)
10973 {
10974 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10975
10976 break;
10977 }
10978
10979 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10980
10981 if (parser_status != PARSER_OK)
10982 {
10983 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10984
10985 continue;
10986 }
10987
10988 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10989
10990 if ((show == 1) || (left == 1))
10991 {
10992 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10993
10994 char *salt_ptr = (char *) tmp_salt->salt_buf;
10995
10996 int cur_pos = tmp_salt->salt_len;
10997 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10998
10999 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11000
11001 u8 *pke_ptr = (u8 *) wpa->pke;
11002
11003 // do the appending task
11004
11005 snprintf (salt_ptr + cur_pos,
11006 rem_len,
11007 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11008 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
11009 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
11010
11011
11012 // memset () the remaining part of the salt
11013
11014 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11015 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11016
11017 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11018
11019 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11020 }
11021
11022 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);
11023 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);
11024
11025 hashes_cnt++;
11026 }
11027
11028 fclose (fp);
11029
11030 myfree (in);
11031 }
11032 else if (hash_mode == 3000)
11033 {
11034 if (hash_len == 32)
11035 {
11036 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11037
11038 hash_t *lm_hash_left = NULL;
11039
11040 if (parser_status == PARSER_OK)
11041 {
11042 lm_hash_left = &hashes_buf[hashes_cnt];
11043
11044 hashes_cnt++;
11045 }
11046 else
11047 {
11048 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11049 }
11050
11051 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11052
11053 hash_t *lm_hash_right = NULL;
11054
11055 if (parser_status == PARSER_OK)
11056 {
11057 lm_hash_right = &hashes_buf[hashes_cnt];
11058
11059 hashes_cnt++;
11060 }
11061 else
11062 {
11063 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11064 }
11065
11066 // show / left
11067
11068 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11069 {
11070 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);
11071 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);
11072 }
11073 }
11074 else
11075 {
11076 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11077
11078 if (parser_status == PARSER_OK)
11079 {
11080 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11081 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11082 }
11083
11084 if (parser_status == PARSER_OK)
11085 {
11086 hashes_cnt++;
11087 }
11088 else
11089 {
11090 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11091 }
11092 }
11093 }
11094 else
11095 {
11096 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11097
11098 if (parser_status == PARSER_OK)
11099 {
11100 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11101 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11102 }
11103
11104 if (parser_status == PARSER_OK)
11105 {
11106 hashes_cnt++;
11107 }
11108 else
11109 {
11110 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11111 }
11112 }
11113 }
11114 }
11115 else if (hashlist_mode == HL_MODE_FILE)
11116 {
11117 char *hashfile = data.hashfile;
11118
11119 FILE *fp;
11120
11121 if ((fp = fopen (hashfile, "rb")) == NULL)
11122 {
11123 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11124
11125 return (-1);
11126 }
11127
11128 uint line_num = 0;
11129
11130 while (!feof (fp))
11131 {
11132 line_num++;
11133
11134 char line_buf[BUFSIZ] = { 0 };
11135
11136 int line_len = fgetl (fp, line_buf);
11137
11138 if (line_len == 0) continue;
11139
11140 char *hash_buf = NULL;
11141 int hash_len = 0;
11142
11143 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11144
11145 if (hash_len < 1) continue;
11146
11147 if (hash_buf == NULL) continue;
11148
11149 if (username)
11150 {
11151 char *user_buf = NULL;
11152 int user_len = 0;
11153
11154 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11155
11156 if (remove || show)
11157 {
11158 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11159
11160 *user = (user_t *) mymalloc (sizeof (user_t));
11161
11162 user_t *user_ptr = *user;
11163
11164 if (user_buf != NULL)
11165 {
11166 user_ptr->user_name = mystrdup (user_buf);
11167 }
11168 else
11169 {
11170 user_ptr->user_name = mystrdup ("");
11171 }
11172
11173 user_ptr->user_len = user_len;
11174 }
11175 }
11176
11177 if (opts_type & OPTS_TYPE_HASH_COPY)
11178 {
11179 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11180
11181 hash_info_tmp->orighash = mystrdup (hash_buf);
11182 }
11183
11184 if (isSalted)
11185 {
11186 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11187 }
11188
11189 if (hash_mode == 3000)
11190 {
11191 if (hash_len == 32)
11192 {
11193 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11194
11195 if (parser_status < PARSER_GLOBAL_ZERO)
11196 {
11197 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11198
11199 continue;
11200 }
11201
11202 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11203
11204 hashes_cnt++;
11205
11206 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11207
11208 if (parser_status < PARSER_GLOBAL_ZERO)
11209 {
11210 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11211
11212 continue;
11213 }
11214
11215 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11216
11217 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);
11218
11219 hashes_cnt++;
11220
11221 // show / left
11222
11223 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);
11224 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);
11225 }
11226 else
11227 {
11228 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11229
11230 if (parser_status < PARSER_GLOBAL_ZERO)
11231 {
11232 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11233
11234 continue;
11235 }
11236
11237 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);
11238
11239 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11240 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11241
11242 hashes_cnt++;
11243 }
11244 }
11245 else
11246 {
11247 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11248
11249 if (parser_status < PARSER_GLOBAL_ZERO)
11250 {
11251 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11252
11253 continue;
11254 }
11255
11256 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);
11257
11258 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11259 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11260
11261 hashes_cnt++;
11262 }
11263 }
11264
11265 fclose (fp);
11266
11267 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11268
11269 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11270 }
11271 }
11272 else
11273 {
11274 if (isSalted)
11275 {
11276 hashes_buf[0].salt->salt_len = 8;
11277
11278 // special salt handling
11279
11280 switch (hash_mode)
11281 {
11282 case 1500: hashes_buf[0].salt->salt_len = 2;
11283 break;
11284 case 1731: hashes_buf[0].salt->salt_len = 4;
11285 break;
11286 case 2410: hashes_buf[0].salt->salt_len = 4;
11287 break;
11288 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11289 break;
11290 case 3100: hashes_buf[0].salt->salt_len = 1;
11291 break;
11292 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11293 break;
11294 case 5800: hashes_buf[0].salt->salt_len = 16;
11295 break;
11296 case 6800: hashes_buf[0].salt->salt_len = 32;
11297 break;
11298 case 8400: hashes_buf[0].salt->salt_len = 40;
11299 break;
11300 case 8800: hashes_buf[0].salt->salt_len = 16;
11301 break;
11302 case 8900: hashes_buf[0].salt->salt_len = 16;
11303 hashes_buf[0].salt->scrypt_N = 1024;
11304 hashes_buf[0].salt->scrypt_r = 1;
11305 hashes_buf[0].salt->scrypt_p = 1;
11306 break;
11307 case 9100: hashes_buf[0].salt->salt_len = 16;
11308 break;
11309 case 9300: hashes_buf[0].salt->salt_len = 14;
11310 hashes_buf[0].salt->scrypt_N = 16384;
11311 hashes_buf[0].salt->scrypt_r = 1;
11312 hashes_buf[0].salt->scrypt_p = 1;
11313 break;
11314 case 9400: hashes_buf[0].salt->salt_len = 16;
11315 break;
11316 case 9500: hashes_buf[0].salt->salt_len = 16;
11317 break;
11318 case 9600: hashes_buf[0].salt->salt_len = 16;
11319 break;
11320 case 9700: hashes_buf[0].salt->salt_len = 16;
11321 break;
11322 case 9710: hashes_buf[0].salt->salt_len = 16;
11323 break;
11324 case 9720: hashes_buf[0].salt->salt_len = 16;
11325 break;
11326 case 9800: hashes_buf[0].salt->salt_len = 16;
11327 break;
11328 case 9810: hashes_buf[0].salt->salt_len = 16;
11329 break;
11330 case 9820: hashes_buf[0].salt->salt_len = 16;
11331 break;
11332 case 10300: hashes_buf[0].salt->salt_len = 12;
11333 break;
11334 case 11500: hashes_buf[0].salt->salt_len = 4;
11335 break;
11336 case 11600: hashes_buf[0].salt->salt_len = 4;
11337 break;
11338 case 12400: hashes_buf[0].salt->salt_len = 4;
11339 break;
11340 case 12500: hashes_buf[0].salt->salt_len = 8;
11341 break;
11342 case 12600: hashes_buf[0].salt->salt_len = 64;
11343 break;
11344 }
11345
11346 // special esalt handling
11347
11348 switch (hash_mode)
11349 {
11350 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11351 break;
11352 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11353 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11354 break;
11355 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11356 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11357 break;
11358 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11359 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11360 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11361 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11362 break;
11363 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11364 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11365 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11366 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11367 break;
11368 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11369 break;
11370 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11371 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11372 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11373 break;
11374 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11375 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11376 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11377 break;
11378 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11379 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11380 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11381 break;
11382 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11383 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11384 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11385 break;
11386 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11387 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11388 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11389 break;
11390 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11391 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11392 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11393 break;
11394 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11395 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11396 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11397 break;
11398 }
11399 }
11400
11401 // set hashfile
11402
11403 switch (hash_mode)
11404 {
11405 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11406 break;
11407 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11408 break;
11409 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11410 break;
11411 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11412 break;
11413 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11414 break;
11415 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11416 break;
11417 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11418 break;
11419 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11420 break;
11421 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11422 break;
11423 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11424 break;
11425 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11426 break;
11427 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11428 break;
11429 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11430 break;
11431 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11432 break;
11433 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11434 break;
11435 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11436 break;
11437 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11438 break;
11439 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11440 break;
11441 }
11442
11443 // set default iterations
11444
11445 switch (hash_mode)
11446 {
11447 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11448 break;
11449 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11450 break;
11451 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11452 break;
11453 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11454 break;
11455 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11456 break;
11457 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11458 break;
11459 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11460 break;
11461 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11462 break;
11463 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11464 break;
11465 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11466 break;
11467 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11468 break;
11469 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11470 break;
11471 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11472 break;
11473 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11474 break;
11475 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11476 break;
11477 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11478 break;
11479 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11480 break;
11481 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11482 break;
11483 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11484 break;
11485 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11486 break;
11487 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11488 break;
11489 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11490 break;
11491 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11492 break;
11493 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11494 break;
11495 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11496 break;
11497 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11498 break;
11499 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11500 break;
11501 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11502 break;
11503 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11504 break;
11505 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11506 break;
11507 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11508 break;
11509 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11510 break;
11511 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11512 break;
11513 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11514 break;
11515 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11516 break;
11517 case 8900: hashes_buf[0].salt->salt_iter = 1;
11518 break;
11519 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11520 break;
11521 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11522 break;
11523 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11524 break;
11525 case 9300: hashes_buf[0].salt->salt_iter = 1;
11526 break;
11527 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11528 break;
11529 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11530 break;
11531 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11532 break;
11533 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11534 break;
11535 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11536 break;
11537 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11538 break;
11539 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11540 break;
11541 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11542 break;
11543 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11544 break;
11545 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11546 break;
11547 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11548 break;
11549 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11550 break;
11551 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11552 break;
11553 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11554 break;
11555 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11556 break;
11557 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11558 break;
11559 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11560 break;
11561 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11562 break;
11563 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11564 break;
11565 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11566 break;
11567 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11568 break;
11569 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
11570 break;
11571 }
11572
11573 hashes_cnt = 1;
11574 }
11575
11576 if (show == 1 || left == 1)
11577 {
11578 for (uint i = 0; i < pot_cnt; i++)
11579 {
11580 pot_t *pot_ptr = &pot[i];
11581
11582 hash_t *hashes_buf = &pot_ptr->hash;
11583
11584 local_free (hashes_buf->digest);
11585
11586 if (isSalted)
11587 {
11588 local_free (hashes_buf->salt);
11589 }
11590 }
11591
11592 local_free (pot);
11593
11594 if (data.quiet == 0) log_info_nn ("");
11595
11596 return (0);
11597 }
11598
11599 if (keyspace == 0)
11600 {
11601 if (hashes_cnt == 0)
11602 {
11603 log_error ("ERROR: No hashes loaded");
11604
11605 return (-1);
11606 }
11607 }
11608
11609 /**
11610 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11611 */
11612
11613 if (data.outfile != NULL)
11614 {
11615 if (data.hashfile != NULL)
11616 {
11617 #ifdef _POSIX
11618 struct stat tmpstat_outfile;
11619 struct stat tmpstat_hashfile;
11620 #endif
11621
11622 #ifdef _WIN
11623 struct stat64 tmpstat_outfile;
11624 struct stat64 tmpstat_hashfile;
11625 #endif
11626
11627 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11628
11629 if (tmp_outfile_fp)
11630 {
11631 #ifdef _POSIX
11632 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11633 #endif
11634
11635 #ifdef _WIN
11636 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11637 #endif
11638
11639 fclose (tmp_outfile_fp);
11640 }
11641
11642 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11643
11644 if (tmp_hashfile_fp)
11645 {
11646 #ifdef _POSIX
11647 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11648 #endif
11649
11650 #ifdef _WIN
11651 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11652 #endif
11653
11654 fclose (tmp_hashfile_fp);
11655 }
11656
11657 if (tmp_outfile_fp && tmp_outfile_fp)
11658 {
11659 tmpstat_outfile.st_mode = 0;
11660 tmpstat_outfile.st_nlink = 0;
11661 tmpstat_outfile.st_uid = 0;
11662 tmpstat_outfile.st_gid = 0;
11663 tmpstat_outfile.st_rdev = 0;
11664 tmpstat_outfile.st_atime = 0;
11665
11666 tmpstat_hashfile.st_mode = 0;
11667 tmpstat_hashfile.st_nlink = 0;
11668 tmpstat_hashfile.st_uid = 0;
11669 tmpstat_hashfile.st_gid = 0;
11670 tmpstat_hashfile.st_rdev = 0;
11671 tmpstat_hashfile.st_atime = 0;
11672
11673 #ifdef _POSIX
11674 tmpstat_outfile.st_blksize = 0;
11675 tmpstat_outfile.st_blocks = 0;
11676
11677 tmpstat_hashfile.st_blksize = 0;
11678 tmpstat_hashfile.st_blocks = 0;
11679 #endif
11680
11681 #ifdef _POSIX
11682 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11683 {
11684 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11685
11686 return (-1);
11687 }
11688 #endif
11689
11690 #ifdef _WIN
11691 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11692 {
11693 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11694
11695 return (-1);
11696 }
11697 #endif
11698 }
11699 }
11700 }
11701
11702 /**
11703 * Remove duplicates
11704 */
11705
11706 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11707
11708 if (isSalted)
11709 {
11710 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11711 }
11712 else
11713 {
11714 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11715 }
11716
11717 uint hashes_cnt_orig = hashes_cnt;
11718
11719 hashes_cnt = 1;
11720
11721 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11722 {
11723 if (isSalted)
11724 {
11725 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11726 {
11727 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11728 }
11729 }
11730 else
11731 {
11732 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11733 }
11734
11735 if (hashes_pos > hashes_cnt)
11736 {
11737 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11738 }
11739
11740 hashes_cnt++;
11741 }
11742
11743 /**
11744 * Potfile removes
11745 */
11746
11747 uint potfile_remove_cracks = 0;
11748
11749 if (potfile_disable == 0)
11750 {
11751 hash_t hash_buf;
11752
11753 hash_buf.digest = mymalloc (dgst_size);
11754 hash_buf.salt = NULL;
11755 hash_buf.esalt = NULL;
11756 hash_buf.hash_info = NULL;
11757 hash_buf.cracked = 0;
11758
11759 if (isSalted)
11760 {
11761 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11762 }
11763
11764 if (esalt_size)
11765 {
11766 hash_buf.esalt = mymalloc (esalt_size);
11767 }
11768
11769 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11770
11771 // no solution for these special hash types (for instane because they use hashfile in output etc)
11772 if ((hash_mode != 5200) &&
11773 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11774 (hash_mode != 9000))
11775 {
11776 FILE *fp = fopen (potfile, "rb");
11777
11778 if (fp != NULL)
11779 {
11780 while (!feof (fp))
11781 {
11782 char line_buf[BUFSIZ] = { 0 };
11783
11784 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11785
11786 if (ptr == NULL) break;
11787
11788 int line_len = strlen (line_buf);
11789
11790 if (line_len == 0) continue;
11791
11792 int iter = MAX_CUT_TRIES;
11793
11794 for (int i = line_len - 1; i && iter; i--, line_len--)
11795 {
11796 if (line_buf[i] != ':') continue;
11797
11798 if (isSalted)
11799 {
11800 memset (hash_buf.salt, 0, sizeof (salt_t));
11801 }
11802
11803 hash_t *found = NULL;
11804
11805 if (hash_mode == 6800)
11806 {
11807 if (i < 64) // 64 = 16 * uint in salt_buf[]
11808 {
11809 // manipulate salt_buf
11810 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11811
11812 hash_buf.salt->salt_len = i;
11813
11814 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11815 }
11816 }
11817 else if (hash_mode == 2500)
11818 {
11819 if (i < 64) // 64 = 16 * uint in salt_buf[]
11820 {
11821 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11822 // manipulate salt_buf
11823
11824 // to be safe work with a copy (because of line_len loop, i etc)
11825
11826 char line_buf_cpy[BUFSIZ] = { 0 };
11827
11828 memcpy (line_buf_cpy, line_buf, i);
11829
11830 char *mac2_pos = strrchr (line_buf_cpy, ':');
11831
11832 if (mac2_pos == NULL) continue;
11833
11834 mac2_pos[0] = 0;
11835 mac2_pos++;
11836
11837 if (strlen (mac2_pos) != 12) continue;
11838
11839 char *mac1_pos = strrchr (line_buf_cpy, ':');
11840
11841 if (mac1_pos == NULL) continue;
11842
11843 mac1_pos[0] = 0;
11844 mac1_pos++;
11845
11846 if (strlen (mac1_pos) != 12) continue;
11847
11848 uint essid_length = mac1_pos - line_buf_cpy - 1;
11849
11850 // here we need the ESSID
11851 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11852
11853 hash_buf.salt->salt_len = essid_length;
11854
11855 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11856
11857 if (found)
11858 {
11859 wpa_t *wpa = (wpa_t *) found->esalt;
11860
11861 uint pke[25] = { 0 };
11862
11863 char *pke_ptr = (char *) pke;
11864
11865 for (uint i = 0; i < 25; i++)
11866 {
11867 pke[i] = byte_swap_32 (wpa->pke[i]);
11868 }
11869
11870 u8 mac1[6] = { 0 };
11871 u8 mac2[6] = { 0 };
11872
11873 memcpy (mac1, pke_ptr + 23, 6);
11874 memcpy (mac2, pke_ptr + 29, 6);
11875
11876 // compare hex string(s) vs binary MAC address(es)
11877
11878 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11879 {
11880 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11881 {
11882 found = NULL;
11883 break;
11884 }
11885 }
11886
11887 // early skip ;)
11888 if (!found) continue;
11889
11890 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11891 {
11892 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11893 {
11894 found = NULL;
11895 break;
11896 }
11897 }
11898 }
11899 }
11900 }
11901 else
11902 {
11903 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11904
11905 if (parser_status == PARSER_OK)
11906 {
11907 if (isSalted)
11908 {
11909 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11910 }
11911 else
11912 {
11913 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11914 }
11915 }
11916 }
11917
11918 if (found == NULL) continue;
11919
11920 if (!found->cracked) potfile_remove_cracks++;
11921
11922 found->cracked = 1;
11923
11924 if (found) break;
11925
11926 iter--;
11927 }
11928 }
11929
11930 fclose (fp);
11931 }
11932 }
11933
11934 if (esalt_size)
11935 {
11936 local_free (hash_buf.esalt);
11937 }
11938
11939 if (isSalted)
11940 {
11941 local_free (hash_buf.salt);
11942 }
11943
11944 local_free (hash_buf.digest);
11945 }
11946
11947 /**
11948 * Now generate all the buffers required for later
11949 */
11950
11951 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11952
11953 salt_t *salts_buf_new = NULL;
11954 void *esalts_buf_new = NULL;
11955
11956 if (isSalted)
11957 {
11958 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11959
11960 if (esalt_size)
11961 {
11962 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11963 }
11964 }
11965 else
11966 {
11967 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11968 }
11969
11970 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11971
11972 uint digests_cnt = hashes_cnt;
11973 uint digests_done = 0;
11974
11975 uint size_digests = digests_cnt * dgst_size;
11976 uint size_shown = digests_cnt * sizeof (uint);
11977
11978 uint *digests_shown = (uint *) mymalloc (size_shown);
11979 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11980
11981 uint salts_cnt = 0;
11982 uint salts_done = 0;
11983
11984 hashinfo_t **hash_info = NULL;
11985
11986 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11987 {
11988 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11989
11990 if (username && (remove || show))
11991 {
11992 uint user_pos;
11993
11994 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11995 {
11996 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11997
11998 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11999 }
12000 }
12001 }
12002
12003 uint *salts_shown = (uint *) mymalloc (size_shown);
12004
12005 salt_t *salt_buf;
12006
12007 {
12008 // copied from inner loop
12009
12010 salt_buf = &salts_buf_new[salts_cnt];
12011
12012 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12013
12014 if (esalt_size)
12015 {
12016 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12017 }
12018
12019 salt_buf->digests_cnt = 0;
12020 salt_buf->digests_done = 0;
12021 salt_buf->digests_offset = 0;
12022
12023 salts_cnt++;
12024 }
12025
12026 if (hashes_buf[0].cracked == 1)
12027 {
12028 digests_shown[0] = 1;
12029
12030 digests_done++;
12031
12032 salt_buf->digests_done++;
12033 }
12034
12035 salt_buf->digests_cnt++;
12036
12037 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12038
12039 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12040 {
12041 hash_info[0] = hashes_buf[0].hash_info;
12042 }
12043
12044 // copy from inner loop
12045
12046 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12047 {
12048 if (isSalted)
12049 {
12050 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12051 {
12052 salt_buf = &salts_buf_new[salts_cnt];
12053
12054 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12055
12056 if (esalt_size)
12057 {
12058 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12059 }
12060
12061 salt_buf->digests_cnt = 0;
12062 salt_buf->digests_done = 0;
12063 salt_buf->digests_offset = hashes_pos;
12064
12065 salts_cnt++;
12066 }
12067 }
12068
12069 if (hashes_buf[hashes_pos].cracked == 1)
12070 {
12071 digests_shown[hashes_pos] = 1;
12072
12073 digests_done++;
12074
12075 salt_buf->digests_done++;
12076 }
12077
12078 salt_buf->digests_cnt++;
12079
12080 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12081
12082 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12083 {
12084 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12085 }
12086 }
12087
12088 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12089 {
12090 salt_t *salt_buf = &salts_buf_new[salt_pos];
12091
12092 if (salt_buf->digests_done == salt_buf->digests_cnt)
12093 {
12094 salts_shown[salt_pos] = 1;
12095
12096 salts_done++;
12097 }
12098
12099 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12100 }
12101
12102 local_free (digests_buf);
12103 local_free (salts_buf);
12104 local_free (esalts_buf);
12105
12106 digests_buf = digests_buf_new;
12107 salts_buf = salts_buf_new;
12108 esalts_buf = esalts_buf_new;
12109
12110 local_free (hashes_buf);
12111
12112 /**
12113 * special modification not set from parser
12114 */
12115
12116 switch (hash_mode)
12117 {
12118 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12119 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12120 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12121 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12122 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12123 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12124 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12125 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12126 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12127 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12128 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12129 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12130 }
12131
12132 if (truecrypt_keyfiles)
12133 {
12134 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12135
12136 char *keyfiles = strdup (truecrypt_keyfiles);
12137
12138 char *keyfile = strtok (keyfiles, ",");
12139
12140 do
12141 {
12142 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12143
12144 } while ((keyfile = strtok (NULL, ",")) != NULL);
12145
12146 free (keyfiles);
12147 }
12148
12149 data.digests_cnt = digests_cnt;
12150 data.digests_done = digests_done;
12151 data.digests_buf = digests_buf;
12152 data.digests_shown = digests_shown;
12153 data.digests_shown_tmp = digests_shown_tmp;
12154
12155 data.salts_cnt = salts_cnt;
12156 data.salts_done = salts_done;
12157 data.salts_buf = salts_buf;
12158 data.salts_shown = salts_shown;
12159
12160 data.esalts_buf = esalts_buf;
12161 data.hash_info = hash_info;
12162
12163 /**
12164 * Automatic Optimizers
12165 */
12166
12167 if (salts_cnt == 1)
12168 opti_type |= OPTI_TYPE_SINGLE_SALT;
12169
12170 if (digests_cnt == 1)
12171 opti_type |= OPTI_TYPE_SINGLE_HASH;
12172
12173 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12174 opti_type |= OPTI_TYPE_NOT_ITERATED;
12175
12176 if (attack_mode == ATTACK_MODE_BF)
12177 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12178
12179 data.opti_type = opti_type;
12180
12181 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12182 {
12183 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12184 {
12185 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12186 {
12187 if (opts_type & OPTS_TYPE_ST_ADD80)
12188 {
12189 opts_type &= ~OPTS_TYPE_ST_ADD80;
12190 opts_type |= OPTS_TYPE_PT_ADD80;
12191 }
12192
12193 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12194 {
12195 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12196 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12197 }
12198
12199 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12200 {
12201 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12202 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12203 }
12204 }
12205 }
12206 }
12207
12208 /**
12209 * Some algorithm, like descrypt, can benefit from JIT compilation
12210 */
12211
12212 int force_jit_compilation = -1;
12213
12214 if (hash_mode == 8900)
12215 {
12216 force_jit_compilation = 8900;
12217 }
12218 else if (hash_mode == 9300)
12219 {
12220 force_jit_compilation = 8900;
12221 }
12222 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12223 {
12224 force_jit_compilation = 1500;
12225 }
12226
12227 /**
12228 * generate bitmap tables
12229 */
12230
12231 const uint bitmap_shift1 = 5;
12232 const uint bitmap_shift2 = 13;
12233
12234 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12235
12236 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12237 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12238 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12239 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12240 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12241 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12242 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12243 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12244
12245 uint bitmap_bits;
12246 uint bitmap_nums;
12247 uint bitmap_mask;
12248 uint bitmap_size;
12249
12250 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12251 {
12252 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12253
12254 bitmap_nums = 1 << bitmap_bits;
12255
12256 bitmap_mask = bitmap_nums - 1;
12257
12258 bitmap_size = bitmap_nums * sizeof (uint);
12259
12260 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12261
12262 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;
12263 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;
12264
12265 break;
12266 }
12267
12268 bitmap_nums = 1 << bitmap_bits;
12269
12270 bitmap_mask = bitmap_nums - 1;
12271
12272 bitmap_size = bitmap_nums * sizeof (uint);
12273
12274 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);
12275 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);
12276
12277 /**
12278 * prepare quick rule
12279 */
12280
12281 data.rule_buf_l = rule_buf_l;
12282 data.rule_buf_r = rule_buf_r;
12283
12284 int rule_len_l = (int) strlen (rule_buf_l);
12285 int rule_len_r = (int) strlen (rule_buf_r);
12286
12287 data.rule_len_l = rule_len_l;
12288 data.rule_len_r = rule_len_r;
12289
12290 /**
12291 * load rules
12292 */
12293
12294 uint *all_kernel_rules_cnt = NULL;
12295
12296 kernel_rule_t **all_kernel_rules_buf = NULL;
12297
12298 if (rp_files_cnt)
12299 {
12300 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12301
12302 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12303 }
12304
12305 char rule_buf[BUFSIZ] = { 0 };
12306
12307 int rule_len = 0;
12308
12309 for (uint i = 0; i < rp_files_cnt; i++)
12310 {
12311 uint kernel_rules_avail = 0;
12312
12313 uint kernel_rules_cnt = 0;
12314
12315 kernel_rule_t *kernel_rules_buf = NULL;
12316
12317 char *rp_file = rp_files[i];
12318
12319 char in[BLOCK_SIZE] = { 0 };
12320 char out[BLOCK_SIZE] = { 0 };
12321
12322 FILE *fp = NULL;
12323
12324 uint rule_line = 0;
12325
12326 if ((fp = fopen (rp_file, "rb")) == NULL)
12327 {
12328 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12329
12330 return (-1);
12331 }
12332
12333 while (!feof (fp))
12334 {
12335 memset (rule_buf, 0, BUFSIZ);
12336
12337 rule_len = fgetl (fp, rule_buf);
12338
12339 rule_line++;
12340
12341 if (rule_len == 0) continue;
12342
12343 if (rule_buf[0] == '#') continue;
12344
12345 if (kernel_rules_avail == kernel_rules_cnt)
12346 {
12347 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12348
12349 kernel_rules_avail += INCR_RULES;
12350 }
12351
12352 memset (in, 0, BLOCK_SIZE);
12353 memset (out, 0, BLOCK_SIZE);
12354
12355 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12356
12357 if (result == -1)
12358 {
12359 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12360
12361 continue;
12362 }
12363
12364 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12365 {
12366 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12367
12368 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12369
12370 continue;
12371 }
12372
12373 /* its so slow
12374 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12375 {
12376 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12377
12378 continue;
12379 }
12380 */
12381
12382 kernel_rules_cnt++;
12383 }
12384
12385 fclose (fp);
12386
12387 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12388
12389 all_kernel_rules_buf[i] = kernel_rules_buf;
12390 }
12391
12392 /**
12393 * merge rules or automatic rule generator
12394 */
12395
12396 uint kernel_rules_cnt = 0;
12397
12398 kernel_rule_t *kernel_rules_buf = NULL;
12399
12400 if (attack_mode == ATTACK_MODE_STRAIGHT)
12401 {
12402 if (rp_files_cnt)
12403 {
12404 kernel_rules_cnt = 1;
12405
12406 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12407
12408 repeats[0] = kernel_rules_cnt;
12409
12410 for (uint i = 0; i < rp_files_cnt; i++)
12411 {
12412 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12413
12414 repeats[i + 1] = kernel_rules_cnt;
12415 }
12416
12417 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12418
12419 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12420
12421 for (uint i = 0; i < kernel_rules_cnt; i++)
12422 {
12423 uint out_pos = 0;
12424
12425 kernel_rule_t *out = &kernel_rules_buf[i];
12426
12427 for (uint j = 0; j < rp_files_cnt; j++)
12428 {
12429 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12430 uint in_pos;
12431
12432 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12433
12434 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12435 {
12436 if (out_pos == RULES_MAX - 1)
12437 {
12438 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12439
12440 break;
12441 }
12442
12443 out->cmds[out_pos] = in->cmds[in_pos];
12444 }
12445 }
12446 }
12447
12448 local_free (repeats);
12449 }
12450 else if (rp_gen)
12451 {
12452 uint kernel_rules_avail = 0;
12453
12454 while (kernel_rules_cnt < rp_gen)
12455 {
12456 if (kernel_rules_avail == kernel_rules_cnt)
12457 {
12458 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12459
12460 kernel_rules_avail += INCR_RULES;
12461 }
12462
12463 memset (rule_buf, 0, BLOCK_SIZE);
12464
12465 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12466
12467 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12468
12469 kernel_rules_cnt++;
12470 }
12471 }
12472 }
12473
12474 /**
12475 * generate NOP rules
12476 */
12477
12478 if (kernel_rules_cnt == 0)
12479 {
12480 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12481
12482 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12483
12484 kernel_rules_cnt++;
12485 }
12486
12487 data.kernel_rules_cnt = kernel_rules_cnt;
12488 data.kernel_rules_buf = kernel_rules_buf;
12489
12490 /**
12491 * OpenCL platforms: detect
12492 */
12493
12494 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12495 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12496
12497 cl_uint platforms_cnt = 0;
12498 cl_uint platform_devices_cnt = 0;
12499
12500 if (keyspace == 0)
12501 {
12502 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12503
12504 if (platforms_cnt == 0)
12505 {
12506 log_error ("ERROR: No OpenCL compatible platform found");
12507
12508 return (-1);
12509 }
12510
12511 if (opencl_platforms_filter != (uint) -1)
12512 {
12513 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
12514
12515 if (opencl_platforms_filter > platform_cnt_mask)
12516 {
12517 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
12518
12519 return (-1);
12520 }
12521 }
12522 }
12523
12524 /**
12525 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12526 */
12527
12528 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12529 {
12530 cl_platform_id platform = platforms[platform_id];
12531
12532 char platform_vendor[INFOSZ] = { 0 };
12533
12534 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12535
12536 #ifdef HAVE_HWMON
12537 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12538 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12539 {
12540 // make sure that we do not directly control the fan for NVidia
12541
12542 gpu_temp_retain = 0;
12543
12544 data.gpu_temp_retain = gpu_temp_retain;
12545 }
12546 #endif // HAVE_NVML || HAVE_NVAPI
12547 #endif
12548 }
12549
12550 /**
12551 * OpenCL devices: simply push all devices from all platforms into the same device array
12552 */
12553
12554 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12555
12556 data.devices_param = devices_param;
12557
12558 uint devices_cnt = 0;
12559
12560 uint devices_active = 0;
12561
12562 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12563 {
12564 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12565
12566 cl_platform_id platform = platforms[platform_id];
12567
12568 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12569
12570 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12571 {
12572 size_t param_value_size = 0;
12573
12574 const uint device_id = devices_cnt;
12575
12576 hc_device_param_t *device_param = &data.devices_param[device_id];
12577
12578 device_param->device = platform_devices[platform_devices_id];
12579
12580 device_param->device_id = device_id;
12581
12582 device_param->platform_devices_id = platform_devices_id;
12583
12584 // device_type
12585
12586 cl_device_type device_type;
12587
12588 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12589
12590 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12591
12592 device_param->device_type = device_type;
12593
12594 // vendor_id
12595
12596 cl_uint vendor_id = 0;
12597
12598 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12599
12600 device_param->vendor_id = vendor_id;
12601
12602 // device_name
12603
12604 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12605
12606 char *device_name = (char *) mymalloc (param_value_size);
12607
12608 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12609
12610 device_param->device_name = device_name;
12611
12612 // tuning db
12613
12614 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12615
12616 // device_version
12617
12618 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12619
12620 char *device_version = (char *) mymalloc (param_value_size);
12621
12622 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12623
12624 device_param->device_version = device_version;
12625
12626 // device_opencl_version
12627
12628 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12629
12630 char *device_opencl_version = (char *) mymalloc (param_value_size);
12631
12632 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12633
12634 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12635
12636 myfree (device_opencl_version);
12637
12638 if (strstr (device_version, "pocl"))
12639 {
12640 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12641 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12642
12643 cl_uint vendor_id = VENDOR_ID_GENERIC;
12644
12645 device_param->vendor_id = vendor_id;
12646 }
12647
12648 // vector_width
12649
12650 cl_uint vector_width;
12651
12652 if (opencl_vector_width_chgd == 0)
12653 {
12654 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12655 {
12656 if (opti_type & OPTI_TYPE_USES_BITS_64)
12657 {
12658 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12659 }
12660 else
12661 {
12662 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12663 }
12664 }
12665 else
12666 {
12667 vector_width = (cl_uint) tuningdb_entry->vector_width;
12668 }
12669 }
12670 else
12671 {
12672 vector_width = opencl_vector_width;
12673 }
12674
12675 if (vector_width > 16) vector_width = 16;
12676
12677 device_param->vector_width = vector_width;
12678
12679 // max_compute_units
12680
12681 cl_uint device_processors;
12682
12683 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12684
12685 device_param->device_processors = device_processors;
12686
12687 // max_mem_alloc_size
12688
12689 cl_ulong device_maxmem_alloc;
12690
12691 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12692
12693 device_param->device_maxmem_alloc = device_maxmem_alloc;
12694
12695 // max_mem_alloc_size
12696
12697 cl_ulong device_global_mem;
12698
12699 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12700
12701 device_param->device_global_mem = device_global_mem;
12702
12703 // max_clock_frequency
12704
12705 cl_uint device_maxclock_frequency;
12706
12707 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12708
12709 device_param->device_maxclock_frequency = device_maxclock_frequency;
12710
12711 // skipped
12712
12713 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12714 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12715
12716 device_param->skipped = (skipped1 || skipped2);
12717
12718 // driver_version
12719 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12720
12721 char *driver_version = (char *) mymalloc (param_value_size);
12722
12723 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12724
12725 device_param->driver_version = driver_version;
12726
12727 // device_name_chksum
12728
12729 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12730
12731 #if __x86_64__
12732 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);
12733 #else
12734 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);
12735 #endif
12736
12737 uint device_name_digest[4] = { 0 };
12738
12739 md5_64 ((uint *) device_name_chksum, device_name_digest);
12740
12741 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12742
12743 device_param->device_name_chksum = device_name_chksum;
12744
12745 // device_processor_cores
12746
12747 if (device_type & CL_DEVICE_TYPE_CPU)
12748 {
12749 cl_uint device_processor_cores = 1;
12750
12751 device_param->device_processor_cores = device_processor_cores;
12752 }
12753
12754 if (device_type & CL_DEVICE_TYPE_GPU)
12755 {
12756 if (vendor_id == VENDOR_ID_AMD)
12757 {
12758 cl_uint device_processor_cores = 0;
12759
12760 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12761
12762 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12763
12764 device_param->device_processor_cores = device_processor_cores;
12765 }
12766 else if (vendor_id == VENDOR_ID_NV)
12767 {
12768 cl_uint kernel_exec_timeout = 0;
12769
12770 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12771
12772 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12773
12774 device_param->kernel_exec_timeout = kernel_exec_timeout;
12775
12776 cl_uint device_processor_cores = 0;
12777
12778 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12779
12780 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12781
12782 device_param->device_processor_cores = device_processor_cores;
12783
12784 cl_uint sm_minor = 0;
12785 cl_uint sm_major = 0;
12786
12787 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12788 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12789
12790 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12791 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12792
12793 device_param->sm_minor = sm_minor;
12794 device_param->sm_major = sm_major;
12795 }
12796 else
12797 {
12798 cl_uint device_processor_cores = 1;
12799
12800 device_param->device_processor_cores = device_processor_cores;
12801 }
12802 }
12803
12804 // display results
12805
12806 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12807 {
12808 if (device_param->skipped == 0)
12809 {
12810 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12811 device_id + 1,
12812 device_name,
12813 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12814 (unsigned int) (device_global_mem / 1024 / 1024),
12815 (unsigned int) (device_maxclock_frequency),
12816 (unsigned int) device_processors);
12817 }
12818 else
12819 {
12820 log_info ("Device #%u: %s, skipped",
12821 device_id + 1,
12822 device_name);
12823 }
12824 }
12825
12826 // common driver check
12827
12828 if (device_param->skipped == 0)
12829 {
12830 if (strstr (device_version, "pocl"))
12831 {
12832 if (force == 0)
12833 {
12834 log_info ("");
12835 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12836 log_info ("You are STRONGLY encouraged not to use it");
12837 log_info ("You can use --force to override this but do not post error reports if you do so");
12838 log_info ("");
12839
12840 return (-1);
12841 }
12842 }
12843
12844 if (device_type & CL_DEVICE_TYPE_GPU)
12845 {
12846 if (vendor_id == VENDOR_ID_NV)
12847 {
12848 if (device_param->kernel_exec_timeout != 0)
12849 {
12850 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);
12851 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12852 }
12853 }
12854 else if (vendor_id == VENDOR_ID_AMD)
12855 {
12856 int catalyst_check = (force == 1) ? 0 : 1;
12857
12858 int catalyst_warn = 0;
12859
12860 int catalyst_broken = 0;
12861
12862 if (catalyst_check == 1)
12863 {
12864 catalyst_warn = 1;
12865
12866 // v14.9 and higher
12867 if (atoi (device_param->driver_version) >= 1573)
12868 {
12869 catalyst_warn = 0;
12870 }
12871
12872 catalyst_check = 0;
12873 }
12874
12875 if (catalyst_broken == 1)
12876 {
12877 log_info ("");
12878 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12879 log_info ("It will pass over cracked hashes and does not report them as cracked");
12880 log_info ("You are STRONGLY encouraged not to use it");
12881 log_info ("You can use --force to override this but do not post error reports if you do so");
12882 log_info ("");
12883
12884 return (-1);
12885 }
12886
12887 if (catalyst_warn == 1)
12888 {
12889 log_info ("");
12890 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12891 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12892 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12893 #ifdef _WIN
12894 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12895 #endif
12896 log_info ("You can use --force to override this but do not post error reports if you do so");
12897 log_info ("");
12898
12899 return (-1);
12900 }
12901 }
12902 }
12903
12904 /**
12905 * kernel accel and loops tuning db adjustment
12906 */
12907
12908 device_param->kernel_accel_min = 1;
12909 device_param->kernel_accel_max = 1024;
12910
12911 device_param->kernel_loops_min = 1;
12912 device_param->kernel_loops_max = 1024;
12913
12914 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12915
12916 if (tuningdb_entry)
12917 {
12918 u32 _kernel_accel = tuningdb_entry->kernel_accel;
12919 u32 _kernel_loops = tuningdb_entry->kernel_loops;
12920
12921 if (_kernel_accel)
12922 {
12923 device_param->kernel_accel_min = _kernel_accel;
12924 device_param->kernel_accel_max = _kernel_accel;
12925 }
12926
12927 if (_kernel_loops)
12928 {
12929 if (workload_profile == 1)
12930 {
12931 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
12932 }
12933 else if (workload_profile == 2)
12934 {
12935 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
12936 }
12937
12938 device_param->kernel_loops_min = _kernel_loops;
12939 device_param->kernel_loops_max = _kernel_loops;
12940 }
12941 }
12942
12943 // commandline parameters overwrite tuningdb entries
12944
12945 if (kernel_accel)
12946 {
12947 device_param->kernel_accel_min = kernel_accel;
12948 device_param->kernel_accel_max = kernel_accel;
12949 }
12950
12951 if (kernel_loops)
12952 {
12953 device_param->kernel_loops_min = kernel_loops;
12954 device_param->kernel_loops_max = kernel_loops;
12955 }
12956
12957 /**
12958 * activate device
12959 */
12960
12961 devices_active++;
12962 }
12963
12964 // next please
12965
12966 devices_cnt++;
12967 }
12968 }
12969
12970 if (keyspace == 0 && devices_active == 0)
12971 {
12972 log_error ("ERROR: No devices found/left");
12973
12974 return (-1);
12975 }
12976
12977 // additional check to see if the user has chosen a device that is not within the range of available devices (i.e. larger than devices_cnt)
12978
12979 if (devices_filter != (uint) -1)
12980 {
12981 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
12982
12983 if (devices_filter > devices_cnt_mask)
12984 {
12985 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
12986
12987 return (-1);
12988 }
12989 }
12990
12991 data.devices_cnt = devices_cnt;
12992
12993 data.devices_active = devices_active;
12994
12995 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12996 {
12997 log_info ("");
12998 }
12999
13000 /**
13001 * HM devices: init
13002 */
13003
13004 #ifdef HAVE_HWMON
13005 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13006 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13007 #endif
13008
13009 #ifdef HAVE_ADL
13010 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13011 #endif
13012
13013 if (gpu_temp_disable == 0)
13014 {
13015 #if defined(WIN) && defined(HAVE_NVAPI)
13016 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13017
13018 if (nvapi_init (nvapi) == 0)
13019 data.hm_nv = nvapi;
13020
13021 if (data.hm_nv)
13022 {
13023 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13024 {
13025 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13026
13027 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13028
13029 int tmp_out = 0;
13030
13031 for (int i = 0; i < tmp_in; i++)
13032 {
13033 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13034 }
13035
13036 for (int i = 0; i < tmp_out; i++)
13037 {
13038 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13039
13040 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13041
13042 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;
13043 }
13044 }
13045 }
13046 #endif // WIN && HAVE_NVAPI
13047
13048 #if defined(LINUX) && defined(HAVE_NVML)
13049 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13050
13051 if (nvml_init (nvml) == 0)
13052 data.hm_nv = nvml;
13053
13054 if (data.hm_nv)
13055 {
13056 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13057 {
13058 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13059
13060 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13061
13062 int tmp_out = 0;
13063
13064 for (int i = 0; i < tmp_in; i++)
13065 {
13066 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13067 }
13068
13069 for (int i = 0; i < tmp_out; i++)
13070 {
13071 unsigned int speed;
13072
13073 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;
13074 }
13075 }
13076 }
13077 #endif // LINUX && HAVE_NVML
13078
13079 data.hm_amd = NULL;
13080
13081 #ifdef HAVE_ADL
13082 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13083
13084 if (adl_init (adl) == 0)
13085 data.hm_amd = adl;
13086
13087 if (data.hm_amd)
13088 {
13089 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13090 {
13091 // total number of adapters
13092
13093 int hm_adapters_num;
13094
13095 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13096
13097 // adapter info
13098
13099 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13100
13101 if (lpAdapterInfo == NULL) return (-1);
13102
13103 // get a list (of ids of) valid/usable adapters
13104
13105 int num_adl_adapters = 0;
13106
13107 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13108
13109 if (num_adl_adapters > 0)
13110 {
13111 hc_thread_mutex_lock (mux_adl);
13112
13113 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13114
13115 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13116
13117 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13118 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13119
13120 hc_thread_mutex_unlock (mux_adl);
13121 }
13122
13123 myfree (valid_adl_device_list);
13124 myfree (lpAdapterInfo);
13125 }
13126 }
13127 #endif // HAVE_ADL
13128
13129 if (data.hm_amd == NULL && data.hm_nv == NULL)
13130 {
13131 gpu_temp_disable = 1;
13132 }
13133 }
13134
13135 /**
13136 * OpenCL devices: allocate buffer for device specific information
13137 */
13138
13139 #ifdef HAVE_HWMON
13140 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13141
13142 #ifdef HAVE_ADL
13143 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13144
13145 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13146 #endif // ADL
13147 #endif
13148
13149 /**
13150 * enable custom signal handler(s)
13151 */
13152
13153 if (benchmark == 0)
13154 {
13155 hc_signal (sigHandler_default);
13156 }
13157 else
13158 {
13159 hc_signal (sigHandler_benchmark);
13160 }
13161
13162 /**
13163 * User-defined GPU temp handling
13164 */
13165
13166 #ifdef HAVE_HWMON
13167 if (gpu_temp_disable == 1)
13168 {
13169 gpu_temp_abort = 0;
13170 gpu_temp_retain = 0;
13171 }
13172
13173 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13174 {
13175 if (gpu_temp_abort < gpu_temp_retain)
13176 {
13177 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13178
13179 return (-1);
13180 }
13181 }
13182
13183 data.gpu_temp_disable = gpu_temp_disable;
13184 data.gpu_temp_abort = gpu_temp_abort;
13185 data.gpu_temp_retain = gpu_temp_retain;
13186 #endif
13187
13188 /**
13189 * inform the user
13190 */
13191
13192 if (data.quiet == 0)
13193 {
13194 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13195
13196 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);
13197
13198 if (attack_mode == ATTACK_MODE_STRAIGHT)
13199 {
13200 log_info ("Rules: %u", kernel_rules_cnt);
13201 }
13202
13203 if (opti_type)
13204 {
13205 log_info ("Applicable Optimizers:");
13206
13207 for (uint i = 0; i < 32; i++)
13208 {
13209 const uint opti_bit = 1u << i;
13210
13211 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13212 }
13213 }
13214
13215 /**
13216 * Watchdog and Temperature balance
13217 */
13218
13219 #ifdef HAVE_HWMON
13220 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13221 {
13222 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13223 }
13224
13225 if (gpu_temp_abort == 0)
13226 {
13227 log_info ("Watchdog: Temperature abort trigger disabled");
13228 }
13229 else
13230 {
13231 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13232 }
13233
13234 if (gpu_temp_retain == 0)
13235 {
13236 log_info ("Watchdog: Temperature retain trigger disabled");
13237 }
13238 else
13239 {
13240 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13241 }
13242 #endif
13243 }
13244
13245 if (data.quiet == 0) log_info ("");
13246
13247 /**
13248 * HM devices: copy
13249 */
13250
13251 if (gpu_temp_disable == 0)
13252 {
13253 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13254 {
13255 hc_device_param_t *device_param = &data.devices_param[device_id];
13256
13257 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13258
13259 if (device_param->skipped) continue;
13260
13261 const uint platform_devices_id = device_param->platform_devices_id;
13262
13263 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13264 if (device_param->vendor_id == VENDOR_ID_NV)
13265 {
13266 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13267 }
13268 #endif
13269
13270 #ifdef HAVE_ADL
13271 if (device_param->vendor_id == VENDOR_ID_AMD)
13272 {
13273 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13274 }
13275 #endif
13276 }
13277 }
13278
13279 /*
13280 * Temporary fix:
13281 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13282 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13283 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13284 * Driver / ADL bug?
13285 */
13286
13287 #ifdef HAVE_ADL
13288 if (powertune_enable == 1)
13289 {
13290 hc_thread_mutex_lock (mux_adl);
13291
13292 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13293 {
13294 hc_device_param_t *device_param = &data.devices_param[device_id];
13295
13296 if (device_param->skipped) continue;
13297
13298 if (data.hm_device[device_id].od_version == 6)
13299 {
13300 // set powertune value only
13301
13302 int powertune_supported = 0;
13303
13304 int ADL_rc = 0;
13305
13306 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13307 {
13308 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13309
13310 return (-1);
13311 }
13312
13313 if (powertune_supported != 0)
13314 {
13315 // powertune set
13316 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13317
13318 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13319 {
13320 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13321
13322 return (-1);
13323 }
13324
13325 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13326 {
13327 log_error ("ERROR: Failed to set new ADL PowerControl values");
13328
13329 return (-1);
13330 }
13331 }
13332 }
13333 }
13334
13335 hc_thread_mutex_unlock (mux_adl);
13336 }
13337 #endif // HAVE_ADK
13338 #endif // HAVE_HWMON
13339
13340 #ifdef DEBUG
13341 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13342 #endif
13343
13344 uint kernel_power_all = 0;
13345
13346 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13347 {
13348 /**
13349 * host buffer
13350 */
13351
13352 hc_device_param_t *device_param = &data.devices_param[device_id];
13353
13354 if (device_param->skipped) continue;
13355
13356 /**
13357 * device properties
13358 */
13359
13360 const char *device_name_chksum = device_param->device_name_chksum;
13361 const u32 device_processors = device_param->device_processors;
13362 const u32 device_processor_cores = device_param->device_processor_cores;
13363
13364 /**
13365 * create context for each device
13366 */
13367
13368 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13369
13370 /**
13371 * create command-queue
13372 */
13373
13374 // not supported with NV
13375 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13376
13377 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13378
13379 /**
13380 * create input buffers on device : calculate size of fixed memory buffers
13381 */
13382
13383 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13384 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13385
13386 device_param->size_root_css = size_root_css;
13387 device_param->size_markov_css = size_markov_css;
13388
13389 uint size_results = KERNEL_THREADS * sizeof (uint);
13390
13391 device_param->size_results = size_results;
13392
13393 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13394 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13395
13396 uint size_plains = digests_cnt * sizeof (plain_t);
13397 uint size_salts = salts_cnt * sizeof (salt_t);
13398 uint size_esalts = salts_cnt * esalt_size;
13399
13400 device_param->size_plains = size_plains;
13401 device_param->size_digests = size_digests;
13402 device_param->size_shown = size_shown;
13403 device_param->size_salts = size_salts;
13404
13405 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13406 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13407 uint size_tm = 32 * sizeof (bs_word_t);
13408
13409 // scryptV stuff
13410
13411 u64 size_scryptV = 1;
13412
13413 if ((hash_mode == 8900) || (hash_mode == 9300))
13414 {
13415 uint tmto_start = 0;
13416 uint tmto_stop = 10;
13417
13418 if (scrypt_tmto)
13419 {
13420 tmto_start = scrypt_tmto;
13421 }
13422 else
13423 {
13424 // in case the user did not specify the tmto manually
13425 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13426 // but set the lower end only in case the user has a device with too less memory
13427
13428 if (hash_mode == 8900)
13429 {
13430 if (device_param->vendor_id == VENDOR_ID_AMD)
13431 {
13432 tmto_start = 1;
13433 }
13434 else if (device_param->vendor_id == VENDOR_ID_NV)
13435 {
13436 tmto_start = 3;
13437 }
13438 }
13439 else if (hash_mode == 9300)
13440 {
13441 if (device_param->vendor_id == VENDOR_ID_AMD)
13442 {
13443 tmto_start = 3;
13444 }
13445 else if (device_param->vendor_id == VENDOR_ID_NV)
13446 {
13447 tmto_start = 5;
13448 }
13449 }
13450 }
13451
13452 if (quiet == 0) log_info ("");
13453
13454 uint shader_per_mp = 1;
13455
13456 if (device_param->vendor_id == VENDOR_ID_AMD)
13457 {
13458 shader_per_mp = 8;
13459 }
13460 else if (device_param->vendor_id == VENDOR_ID_NV)
13461 {
13462 shader_per_mp = 32;
13463 }
13464
13465 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13466 {
13467 // TODO: in theory the following calculation needs to be done per salt, not global
13468 // we assume all hashes have the same scrypt settings
13469
13470 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13471
13472 size_scryptV /= 1 << tmto;
13473
13474 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13475
13476 if (size_scryptV > device_param->device_maxmem_alloc)
13477 {
13478 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13479
13480 continue;
13481 }
13482
13483 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13484 {
13485 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13486 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13487 }
13488
13489 break;
13490 }
13491
13492 if (data.salts_buf[0].scrypt_phy == 0)
13493 {
13494 log_error ("ERROR: can't allocate enough device memory");
13495
13496 return -1;
13497 }
13498
13499 if (quiet == 0) log_info ("");
13500 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13501 }
13502
13503 /**
13504 * create input buffers on device : calculate size of dynamic size memory buffers
13505 */
13506
13507 uint kernel_threads = KERNEL_THREADS;
13508
13509 // some algorithms need a fixed kernel-threads count (mostly because of shared memory usage)
13510
13511 if (hash_mode == 3200) kernel_threads = 8;
13512 if (hash_mode == 9000) kernel_threads = 8;
13513
13514 /**
13515 * some algorithms need a fixed kernel-loops count
13516 */
13517
13518 if (hash_mode == 1500)
13519 {
13520 const u32 kernel_loops_fixed = 1024;
13521
13522 device_param->kernel_loops_min = kernel_loops_fixed;
13523 device_param->kernel_loops_max = kernel_loops_fixed;
13524 }
13525
13526 if (hash_mode == 3000)
13527 {
13528 const u32 kernel_loops_fixed = 1024;
13529
13530 device_param->kernel_loops_min = kernel_loops_fixed;
13531 device_param->kernel_loops_max = kernel_loops_fixed;
13532 }
13533
13534 if (hash_mode == 8900)
13535 {
13536 const u32 kernel_loops_fixed = 1;
13537
13538 device_param->kernel_loops_min = kernel_loops_fixed;
13539 device_param->kernel_loops_max = kernel_loops_fixed;
13540 }
13541
13542 if (hash_mode == 9300)
13543 {
13544 const u32 kernel_loops_fixed = 1;
13545
13546 device_param->kernel_loops_min = kernel_loops_fixed;
13547 device_param->kernel_loops_max = kernel_loops_fixed;
13548 }
13549
13550 if (hash_mode == 12500)
13551 {
13552 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13553
13554 device_param->kernel_loops_min = kernel_loops_fixed;
13555 device_param->kernel_loops_max = kernel_loops_fixed;
13556 }
13557
13558 /**
13559 * some algorithms have a maximum kernel-loops count
13560 */
13561
13562 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13563 {
13564 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13565 {
13566 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13567 }
13568 }
13569
13570 /**
13571 * some algorithms need a special kernel-accel
13572 */
13573
13574 if (hash_mode == 8900)
13575 {
13576 device_param->kernel_accel_min = 1;
13577 device_param->kernel_accel_max = 64;
13578 }
13579
13580 if (hash_mode == 9300)
13581 {
13582 device_param->kernel_accel_min = 1;
13583 device_param->kernel_accel_max = 64;
13584 }
13585
13586 u32 kernel_accel_min = device_param->kernel_accel_min;
13587 u32 kernel_accel_max = device_param->kernel_accel_max;
13588
13589 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13590
13591 uint size_pws = 4;
13592 uint size_tmps = 4;
13593 uint size_hooks = 4;
13594
13595 while (kernel_accel_max >= kernel_accel_min)
13596 {
13597 uint kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13598
13599 // size_pws
13600
13601 size_pws = kernel_power_max * sizeof (pw_t);
13602
13603 // size_tmps
13604
13605 switch (hash_mode)
13606 {
13607 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13608 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13609 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13610 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13611 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13612 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13613 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13614 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13615 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13616 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13617 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13618 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13619 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13620 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13621 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13622 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13623 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13624 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13625 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13626 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13627 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13628 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13629 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13630 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13631 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13632 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13633 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13634 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13635 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13636 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13637 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13638 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13639 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13640 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13641 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13642 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13643 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13644 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13645 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13646 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13647 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13648 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13649 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13650 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13651 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13652 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13653 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13654 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13655 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13656 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13657 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13658 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13659 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13660 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13661 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13662 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13663 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13664 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13665 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13666 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13667 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13668 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
13669 };
13670
13671 // size_hooks
13672
13673 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13674 {
13675 // none yet
13676 }
13677
13678 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13679 // if not, decrease amplifier and try again
13680
13681 int skip = 0;
13682
13683 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13684 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13685 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13686
13687 if (( bitmap_size
13688 + bitmap_size
13689 + bitmap_size
13690 + bitmap_size
13691 + bitmap_size
13692 + bitmap_size
13693 + bitmap_size
13694 + bitmap_size
13695 + size_bfs
13696 + size_combs
13697 + size_digests
13698 + size_esalts
13699 + size_hooks
13700 + size_markov_css
13701 + size_plains
13702 + size_pws
13703 + size_results
13704 + size_root_css
13705 + size_rules
13706 + size_rules_c
13707 + size_salts
13708 + size_scryptV
13709 + size_shown
13710 + size_tm
13711 + size_tmps) > device_param->device_global_mem) skip = 1;
13712
13713 if (skip == 1)
13714 {
13715 kernel_accel_max--;
13716
13717 continue;
13718 }
13719
13720 break;
13721 }
13722
13723 /*
13724 if (kernel_accel_max == 0)
13725 {
13726 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13727
13728 return -1;
13729 }
13730 */
13731
13732 device_param->kernel_accel_min = kernel_accel_min;
13733 device_param->kernel_accel_max = kernel_accel_max;
13734
13735 /*
13736 if (kernel_accel_max < kernel_accel)
13737 {
13738 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13739
13740 device_param->kernel_accel = kernel_accel_max;
13741 }
13742 */
13743
13744 device_param->size_bfs = size_bfs;
13745 device_param->size_combs = size_combs;
13746 device_param->size_rules = size_rules;
13747 device_param->size_rules_c = size_rules_c;
13748 device_param->size_pws = size_pws;
13749 device_param->size_tmps = size_tmps;
13750 device_param->size_hooks = size_hooks;
13751
13752 // do not confuse kernel_accel_max with kernel_accel here
13753
13754 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13755
13756 device_param->kernel_threads = kernel_threads;
13757 device_param->kernel_power_user = kernel_power;
13758
13759 kernel_power_all += kernel_power;
13760
13761 /**
13762 * default building options
13763 */
13764
13765 char build_opts[1024] = { 0 };
13766
13767 // we don't have sm_* on vendors not NV but it doesn't matter
13768
13769 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);
13770
13771 /**
13772 * main kernel
13773 */
13774
13775 {
13776 /**
13777 * kernel source filename
13778 */
13779
13780 char source_file[256] = { 0 };
13781
13782 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13783
13784 struct stat sst;
13785
13786 if (stat (source_file, &sst) == -1)
13787 {
13788 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13789
13790 return -1;
13791 }
13792
13793 /**
13794 * kernel cached filename
13795 */
13796
13797 char cached_file[256] = { 0 };
13798
13799 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13800
13801 int cached = 1;
13802
13803 struct stat cst;
13804
13805 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13806 {
13807 cached = 0;
13808 }
13809
13810 /**
13811 * kernel compile or load
13812 */
13813
13814 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13815
13816 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13817
13818 if (force_jit_compilation == -1)
13819 {
13820 if (cached == 0)
13821 {
13822 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13823
13824 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13825
13826 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13827
13828 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13829
13830 #ifdef DEBUG
13831 size_t build_log_size = 0;
13832
13833 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
13834
13835 if (build_log_size > 1)
13836 {
13837 char *build_log = (char *) malloc (build_log_size + 1);
13838
13839 memset (build_log, 0, build_log_size + 1);
13840
13841 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
13842
13843 puts (build_log);
13844
13845 free (build_log);
13846 }
13847 #endif
13848
13849 if (rc != 0)
13850 {
13851 device_param->skipped = true;
13852 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13853 continue;
13854 }
13855
13856 size_t binary_size;
13857
13858 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13859
13860 u8 *binary = (u8 *) mymalloc (binary_size);
13861
13862 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13863
13864 writeProgramBin (cached_file, binary, binary_size);
13865
13866 local_free (binary);
13867 }
13868 else
13869 {
13870 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13871
13872 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13873
13874 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13875
13876 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
13877 }
13878 }
13879 else
13880 {
13881 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13882
13883 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13884
13885 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13886
13887 char build_opts_update[1024] = { 0 };
13888
13889 if (force_jit_compilation == 1500)
13890 {
13891 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13892 }
13893 else if (force_jit_compilation == 8900)
13894 {
13895 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);
13896 }
13897 else
13898 {
13899 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
13900 }
13901
13902 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
13903
13904 #ifdef DEBUG
13905 size_t build_log_size = 0;
13906
13907 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
13908
13909 if (build_log_size > 1)
13910 {
13911 char *build_log = (char *) malloc (build_log_size + 1);
13912
13913 memset (build_log, 0, build_log_size + 1);
13914
13915 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
13916
13917 puts (build_log);
13918
13919 free (build_log);
13920 }
13921 #endif
13922
13923 if (rc != 0)
13924 {
13925 device_param->skipped = true;
13926
13927 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13928 }
13929 }
13930
13931 local_free (kernel_lengths);
13932 local_free (kernel_sources[0]);
13933 local_free (kernel_sources);
13934 }
13935
13936 /**
13937 * word generator kernel
13938 */
13939
13940 if (attack_mode != ATTACK_MODE_STRAIGHT)
13941 {
13942 /**
13943 * kernel mp source filename
13944 */
13945
13946 char source_file[256] = { 0 };
13947
13948 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13949
13950 struct stat sst;
13951
13952 if (stat (source_file, &sst) == -1)
13953 {
13954 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13955
13956 return -1;
13957 }
13958
13959 /**
13960 * kernel mp cached filename
13961 */
13962
13963 char cached_file[256] = { 0 };
13964
13965 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13966
13967 int cached = 1;
13968
13969 struct stat cst;
13970
13971 if (stat (cached_file, &cst) == -1)
13972 {
13973 cached = 0;
13974 }
13975
13976 /**
13977 * kernel compile or load
13978 */
13979
13980 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13981
13982 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13983
13984 if (cached == 0)
13985 {
13986 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13987
13988 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13989
13990 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13991
13992 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
13993
13994 if (rc != 0)
13995 {
13996 device_param->skipped = true;
13997 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13998 continue;
13999 }
14000
14001 size_t binary_size;
14002
14003 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14004
14005 u8 *binary = (u8 *) mymalloc (binary_size);
14006
14007 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14008
14009 writeProgramBin (cached_file, binary, binary_size);
14010
14011 local_free (binary);
14012 }
14013 else
14014 {
14015 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14016
14017 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14018
14019 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14020
14021 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14022 }
14023
14024 local_free (kernel_lengths);
14025 local_free (kernel_sources[0]);
14026 local_free (kernel_sources);
14027 }
14028
14029 /**
14030 * amplifier kernel
14031 */
14032
14033 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14034 {
14035
14036 }
14037 else
14038 {
14039 /**
14040 * kernel amp source filename
14041 */
14042
14043 char source_file[256] = { 0 };
14044
14045 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14046
14047 struct stat sst;
14048
14049 if (stat (source_file, &sst) == -1)
14050 {
14051 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14052
14053 return -1;
14054 }
14055
14056 /**
14057 * kernel amp cached filename
14058 */
14059
14060 char cached_file[256] = { 0 };
14061
14062 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14063
14064 int cached = 1;
14065
14066 struct stat cst;
14067
14068 if (stat (cached_file, &cst) == -1)
14069 {
14070 cached = 0;
14071 }
14072
14073 /**
14074 * kernel compile or load
14075 */
14076
14077 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14078
14079 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14080
14081 if (cached == 0)
14082 {
14083 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14084
14085 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14086
14087 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14088
14089 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14090
14091 if (rc != 0)
14092 {
14093 device_param->skipped = true;
14094 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14095 continue;
14096 }
14097
14098 size_t binary_size;
14099
14100 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14101
14102 u8 *binary = (u8 *) mymalloc (binary_size);
14103
14104 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14105
14106 writeProgramBin (cached_file, binary, binary_size);
14107
14108 local_free (binary);
14109 }
14110 else
14111 {
14112 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14113
14114 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14115
14116 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14117
14118 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14119 }
14120
14121 local_free (kernel_lengths);
14122 local_free (kernel_sources[0]);
14123 local_free (kernel_sources);
14124 }
14125
14126 // some algorithm collide too fast, make that impossible
14127
14128 if (benchmark == 1)
14129 {
14130 ((uint *) digests_buf)[0] = -1;
14131 ((uint *) digests_buf)[1] = -1;
14132 ((uint *) digests_buf)[2] = -1;
14133 ((uint *) digests_buf)[3] = -1;
14134 }
14135
14136 /**
14137 * global buffers
14138 */
14139
14140 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14141 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14142 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14143 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14144 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14145 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14146 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14147 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14148 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14149 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14150 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14151 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14152 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14153 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14154 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14155 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14156 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14157 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14158
14159 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);
14160 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);
14161 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);
14162 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);
14163 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);
14164 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);
14165 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);
14166 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);
14167 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14168 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14169 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14170
14171 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14172 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14173 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14174 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14175 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14176 run_kernel_bzero (device_param, device_param->d_result, size_results);
14177
14178 /**
14179 * special buffers
14180 */
14181
14182 if (attack_kern == ATTACK_KERN_STRAIGHT)
14183 {
14184 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14185 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14186
14187 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14188
14189 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14190 }
14191 else if (attack_kern == ATTACK_KERN_COMBI)
14192 {
14193 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14194 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14195 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14196 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14197
14198 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14199 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14200 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14201 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14202 }
14203 else if (attack_kern == ATTACK_KERN_BF)
14204 {
14205 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14206 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14207 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14208 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14209 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14210
14211 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14212 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14213 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14214 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14215 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14216 }
14217
14218 if (size_esalts)
14219 {
14220 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14221
14222 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14223 }
14224
14225 /**
14226 * main host data
14227 */
14228
14229 uint *result = (uint *) mymalloc (size_results);
14230
14231 device_param->result = result;
14232
14233 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14234
14235 device_param->pws_buf = pws_buf;
14236
14237 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14238
14239 device_param->combs_buf = combs_buf;
14240
14241 void *hooks_buf = mymalloc (size_hooks);
14242
14243 device_param->hooks_buf = hooks_buf;
14244
14245 /**
14246 * kernel args
14247 */
14248
14249 device_param->kernel_params_buf32[21] = bitmap_mask;
14250 device_param->kernel_params_buf32[22] = bitmap_shift1;
14251 device_param->kernel_params_buf32[23] = bitmap_shift2;
14252 device_param->kernel_params_buf32[24] = 0; // salt_pos
14253 device_param->kernel_params_buf32[25] = 0; // loop_pos
14254 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14255 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14256 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14257 device_param->kernel_params_buf32[29] = 0; // digests_offset
14258 device_param->kernel_params_buf32[30] = 0; // combs_mode
14259 device_param->kernel_params_buf32[31] = 0; // gid_max
14260
14261 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14262 ? &device_param->d_pws_buf
14263 : &device_param->d_pws_amp_buf;
14264 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14265 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14266 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14267 device_param->kernel_params[ 4] = &device_param->d_tmps;
14268 device_param->kernel_params[ 5] = &device_param->d_hooks;
14269 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14270 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14271 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14272 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14273 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14274 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14275 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14276 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14277 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14278 device_param->kernel_params[15] = &device_param->d_digests_buf;
14279 device_param->kernel_params[16] = &device_param->d_digests_shown;
14280 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14281 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14282 device_param->kernel_params[19] = &device_param->d_result;
14283 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14284 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14285 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14286 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14287 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14288 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14289 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14290 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14291 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14292 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14293 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14294 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14295
14296 device_param->kernel_params_mp_buf64[3] = 0;
14297 device_param->kernel_params_mp_buf32[4] = 0;
14298 device_param->kernel_params_mp_buf32[5] = 0;
14299 device_param->kernel_params_mp_buf32[6] = 0;
14300 device_param->kernel_params_mp_buf32[7] = 0;
14301 device_param->kernel_params_mp_buf32[8] = 0;
14302
14303 device_param->kernel_params_mp[0] = NULL;
14304 device_param->kernel_params_mp[1] = NULL;
14305 device_param->kernel_params_mp[2] = NULL;
14306 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14307 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14308 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14309 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14310 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14311 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14312
14313 device_param->kernel_params_mp_l_buf64[3] = 0;
14314 device_param->kernel_params_mp_l_buf32[4] = 0;
14315 device_param->kernel_params_mp_l_buf32[5] = 0;
14316 device_param->kernel_params_mp_l_buf32[6] = 0;
14317 device_param->kernel_params_mp_l_buf32[7] = 0;
14318 device_param->kernel_params_mp_l_buf32[8] = 0;
14319 device_param->kernel_params_mp_l_buf32[9] = 0;
14320
14321 device_param->kernel_params_mp_l[0] = NULL;
14322 device_param->kernel_params_mp_l[1] = NULL;
14323 device_param->kernel_params_mp_l[2] = NULL;
14324 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14325 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14326 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14327 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14328 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14329 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14330 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14331
14332 device_param->kernel_params_mp_r_buf64[3] = 0;
14333 device_param->kernel_params_mp_r_buf32[4] = 0;
14334 device_param->kernel_params_mp_r_buf32[5] = 0;
14335 device_param->kernel_params_mp_r_buf32[6] = 0;
14336 device_param->kernel_params_mp_r_buf32[7] = 0;
14337 device_param->kernel_params_mp_r_buf32[8] = 0;
14338
14339 device_param->kernel_params_mp_r[0] = NULL;
14340 device_param->kernel_params_mp_r[1] = NULL;
14341 device_param->kernel_params_mp_r[2] = NULL;
14342 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14343 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14344 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14345 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14346 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14347 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14348
14349 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14350 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14351
14352 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14353 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14354 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14355 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14356 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14357 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14358 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14359
14360 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14361 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14362
14363 /**
14364 * kernel name
14365 */
14366
14367 char kernel_name[64] = { 0 };
14368
14369 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14370 {
14371 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14372 {
14373 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14374
14375 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14376
14377 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14378
14379 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14380
14381 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14382
14383 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14384 }
14385 else
14386 {
14387 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14388
14389 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14390
14391 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14392
14393 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14394
14395 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14396
14397 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14398 }
14399
14400 if (data.attack_mode == ATTACK_MODE_BF)
14401 {
14402 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14403 {
14404 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14405
14406 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14407 }
14408 }
14409 }
14410 else
14411 {
14412 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14413
14414 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14415
14416 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14417
14418 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14419
14420 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14421
14422 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14423
14424 if (opts_type & OPTS_TYPE_HOOK12)
14425 {
14426 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14427
14428 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14429 }
14430
14431 if (opts_type & OPTS_TYPE_HOOK23)
14432 {
14433 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14434
14435 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14436 }
14437 }
14438
14439 for (uint i = 0; i <= 20; i++)
14440 {
14441 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14442 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14443 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14444
14445 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14446 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14447 }
14448
14449 for (uint i = 21; i <= 31; i++)
14450 {
14451 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14452 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14453 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14454
14455 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14456 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14457 }
14458
14459 if (attack_mode == ATTACK_MODE_BF)
14460 {
14461 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14462 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14463
14464 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14465 {
14466 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14467 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14468 }
14469 }
14470 else if (attack_mode == ATTACK_MODE_HYBRID1)
14471 {
14472 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14473 }
14474 else if (attack_mode == ATTACK_MODE_HYBRID2)
14475 {
14476 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14477 }
14478
14479 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14480 {
14481 // nothing to do
14482 }
14483 else
14484 {
14485 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14486 }
14487
14488 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14489 {
14490 // nothing to do
14491 }
14492 else
14493 {
14494 for (uint i = 0; i < 5; i++)
14495 {
14496 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14497 }
14498
14499 for (uint i = 5; i < 7; i++)
14500 {
14501 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14502 }
14503 }
14504
14505 /**
14506 * Store initial fanspeed if gpu_temp_retain is enabled
14507 */
14508
14509 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14510 int gpu_temp_retain_set = 0;
14511
14512 if (gpu_temp_disable == 0)
14513 {
14514 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14515 {
14516 hc_thread_mutex_lock (mux_adl);
14517
14518 if (data.hm_device[device_id].fan_supported == 1)
14519 {
14520 if (gpu_temp_retain_chgd == 0)
14521 {
14522 uint cur_temp = 0;
14523 uint default_temp = 0;
14524
14525 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);
14526
14527 if (ADL_rc == ADL_OK)
14528 {
14529 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14530
14531 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14532
14533 // special case with multi gpu setups: always use minimum retain
14534
14535 if (gpu_temp_retain_set == 0)
14536 {
14537 gpu_temp_retain = gpu_temp_retain_target;
14538 gpu_temp_retain_set = 1;
14539 }
14540 else
14541 {
14542 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14543 }
14544
14545 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14546 }
14547 }
14548
14549 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14550
14551 temp_retain_fanspeed_value[device_id] = fan_speed;
14552
14553 if (fan_speed == -1)
14554 {
14555 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14556
14557 temp_retain_fanspeed_value[device_id] = 0;
14558 }
14559 }
14560
14561 hc_thread_mutex_unlock (mux_adl);
14562 }
14563 }
14564
14565 /**
14566 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14567 */
14568
14569 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14570 {
14571 hc_thread_mutex_lock (mux_adl);
14572
14573 if (data.hm_device[device_id].od_version == 6)
14574 {
14575 int ADL_rc;
14576
14577 // check powertune capabilities first, if not available then skip device
14578
14579 int powertune_supported = 0;
14580
14581 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14582 {
14583 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14584
14585 return (-1);
14586 }
14587
14588 if (powertune_supported != 0)
14589 {
14590 // powercontrol settings
14591
14592 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14593
14594 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14595 {
14596 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14597 }
14598
14599 if (ADL_rc != ADL_OK)
14600 {
14601 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14602
14603 return (-1);
14604 }
14605
14606 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14607 {
14608 log_error ("ERROR: Failed to set new ADL PowerControl values");
14609
14610 return (-1);
14611 }
14612
14613 // clocks
14614
14615 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14616
14617 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14618
14619 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)
14620 {
14621 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14622
14623 return (-1);
14624 }
14625
14626 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14627
14628 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14629
14630 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14631 {
14632 log_error ("ERROR: Failed to get ADL device capabilities");
14633
14634 return (-1);
14635 }
14636
14637 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14638 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14639
14640 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14641 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14642
14643 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14644 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14645
14646 // warning if profile has too low max values
14647
14648 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14649 {
14650 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14651 }
14652
14653 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14654 {
14655 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14656 }
14657
14658 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14659
14660 performance_state->iNumberOfPerformanceLevels = 2;
14661
14662 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14663 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14664 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14665 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14666
14667 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)
14668 {
14669 log_info ("ERROR: Failed to set ADL performance state");
14670
14671 return (-1);
14672 }
14673
14674 local_free (performance_state);
14675 }
14676 }
14677
14678 hc_thread_mutex_unlock (mux_adl);
14679 }
14680 #endif // HAVE_HWMON && HAVE_ADL
14681 }
14682
14683 data.kernel_power_all = kernel_power_all;
14684
14685 if (data.quiet == 0) log_info ("");
14686
14687 /**
14688 * Inform user which algorithm is checked and at which workload setting
14689 */
14690
14691 if (benchmark == 1)
14692 {
14693 quiet = 0;
14694
14695 data.quiet = quiet;
14696
14697 char *hash_type = strhashtype (data.hash_mode); // not a bug
14698
14699 log_info ("Hashtype: %s", hash_type);
14700 log_info ("");
14701 }
14702
14703 /**
14704 * keep track of the progress
14705 */
14706
14707 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14708 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14709 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14710
14711 /**
14712 * open filehandles
14713 */
14714
14715 #if _WIN
14716 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14717 {
14718 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14719
14720 return (-1);
14721 }
14722
14723 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14724 {
14725 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14726
14727 return (-1);
14728 }
14729
14730 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14731 {
14732 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14733
14734 return (-1);
14735 }
14736 #endif
14737
14738 /**
14739 * dictionary pad
14740 */
14741
14742 segment_size *= (1024 * 1024);
14743
14744 data.segment_size = segment_size;
14745
14746 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14747
14748 wl_data->buf = (char *) mymalloc (segment_size);
14749 wl_data->avail = segment_size;
14750 wl_data->incr = segment_size;
14751 wl_data->cnt = 0;
14752 wl_data->pos = 0;
14753
14754 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14755
14756 data.wordlist_mode = wordlist_mode;
14757
14758 cs_t *css_buf = NULL;
14759 uint css_cnt = 0;
14760 uint dictcnt = 0;
14761 uint maskcnt = 1;
14762 char **masks = NULL;
14763 char **dictfiles = NULL;
14764
14765 uint mask_from_file = 0;
14766
14767 if (attack_mode == ATTACK_MODE_STRAIGHT)
14768 {
14769 if (wordlist_mode == WL_MODE_FILE)
14770 {
14771 int wls_left = myargc - (optind + 1);
14772
14773 for (int i = 0; i < wls_left; i++)
14774 {
14775 char *l0_filename = myargv[optind + 1 + i];
14776
14777 struct stat l0_stat;
14778
14779 if (stat (l0_filename, &l0_stat) == -1)
14780 {
14781 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14782
14783 return (-1);
14784 }
14785
14786 uint is_dir = S_ISDIR (l0_stat.st_mode);
14787
14788 if (is_dir == 0)
14789 {
14790 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14791
14792 dictcnt++;
14793
14794 dictfiles[dictcnt - 1] = l0_filename;
14795 }
14796 else
14797 {
14798 // do not allow --keyspace w/ a directory
14799
14800 if (keyspace == 1)
14801 {
14802 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14803
14804 return (-1);
14805 }
14806
14807 char **dictionary_files = NULL;
14808
14809 dictionary_files = scan_directory (l0_filename);
14810
14811 if (dictionary_files != NULL)
14812 {
14813 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14814
14815 for (int d = 0; dictionary_files[d] != NULL; d++)
14816 {
14817 char *l1_filename = dictionary_files[d];
14818
14819 struct stat l1_stat;
14820
14821 if (stat (l1_filename, &l1_stat) == -1)
14822 {
14823 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14824
14825 return (-1);
14826 }
14827
14828 if (S_ISREG (l1_stat.st_mode))
14829 {
14830 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14831
14832 dictcnt++;
14833
14834 dictfiles[dictcnt - 1] = strdup (l1_filename);
14835 }
14836 }
14837 }
14838
14839 local_free (dictionary_files);
14840 }
14841 }
14842
14843 if (dictcnt < 1)
14844 {
14845 log_error ("ERROR: No usable dictionary file found.");
14846
14847 return (-1);
14848 }
14849 }
14850 else if (wordlist_mode == WL_MODE_STDIN)
14851 {
14852 dictcnt = 1;
14853 }
14854 }
14855 else if (attack_mode == ATTACK_MODE_COMBI)
14856 {
14857 // display
14858
14859 char *dictfile1 = myargv[optind + 1 + 0];
14860 char *dictfile2 = myargv[optind + 1 + 1];
14861
14862 // find the bigger dictionary and use as base
14863
14864 FILE *fp1 = NULL;
14865 FILE *fp2 = NULL;
14866
14867 struct stat tmp_stat;
14868
14869 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14870 {
14871 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14872
14873 return (-1);
14874 }
14875
14876 if (stat (dictfile1, &tmp_stat) == -1)
14877 {
14878 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14879
14880 fclose (fp1);
14881
14882 return (-1);
14883 }
14884
14885 if (S_ISDIR (tmp_stat.st_mode))
14886 {
14887 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14888
14889 fclose (fp1);
14890
14891 return (-1);
14892 }
14893
14894 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14895 {
14896 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14897
14898 fclose (fp1);
14899
14900 return (-1);
14901 }
14902
14903 if (stat (dictfile2, &tmp_stat) == -1)
14904 {
14905 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14906
14907 fclose (fp1);
14908 fclose (fp2);
14909
14910 return (-1);
14911 }
14912
14913 if (S_ISDIR (tmp_stat.st_mode))
14914 {
14915 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14916
14917 fclose (fp1);
14918 fclose (fp2);
14919
14920 return (-1);
14921 }
14922
14923 data.combs_cnt = 1;
14924
14925 data.quiet = 1;
14926
14927 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14928
14929 data.quiet = quiet;
14930
14931 if (words1_cnt == 0)
14932 {
14933 log_error ("ERROR: %s: empty file", dictfile1);
14934
14935 fclose (fp1);
14936 fclose (fp2);
14937
14938 return (-1);
14939 }
14940
14941 data.combs_cnt = 1;
14942
14943 data.quiet = 1;
14944
14945 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14946
14947 data.quiet = quiet;
14948
14949 if (words2_cnt == 0)
14950 {
14951 log_error ("ERROR: %s: empty file", dictfile2);
14952
14953 fclose (fp1);
14954 fclose (fp2);
14955
14956 return (-1);
14957 }
14958
14959 fclose (fp1);
14960 fclose (fp2);
14961
14962 data.dictfile = dictfile1;
14963 data.dictfile2 = dictfile2;
14964
14965 if (words1_cnt >= words2_cnt)
14966 {
14967 data.combs_cnt = words2_cnt;
14968 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14969
14970 dictfiles = &data.dictfile;
14971
14972 dictcnt = 1;
14973 }
14974 else
14975 {
14976 data.combs_cnt = words1_cnt;
14977 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14978
14979 dictfiles = &data.dictfile2;
14980
14981 dictcnt = 1;
14982
14983 // we also have to switch wordlist related rules!
14984
14985 char *tmpc = data.rule_buf_l;
14986
14987 data.rule_buf_l = data.rule_buf_r;
14988 data.rule_buf_r = tmpc;
14989
14990 int tmpi = data.rule_len_l;
14991
14992 data.rule_len_l = data.rule_len_r;
14993 data.rule_len_r = tmpi;
14994 }
14995 }
14996 else if (attack_mode == ATTACK_MODE_BF)
14997 {
14998 char *mask = NULL;
14999
15000 maskcnt = 0;
15001
15002 if (benchmark == 0)
15003 {
15004 mask = myargv[optind + 1];
15005
15006 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15007
15008 if ((optind + 2) <= myargc)
15009 {
15010 struct stat file_stat;
15011
15012 if (stat (mask, &file_stat) == -1)
15013 {
15014 maskcnt = 1;
15015
15016 masks[maskcnt - 1] = mystrdup (mask);
15017 }
15018 else
15019 {
15020 int wls_left = myargc - (optind + 1);
15021
15022 uint masks_avail = INCR_MASKS;
15023
15024 for (int i = 0; i < wls_left; i++)
15025 {
15026 if (i != 0)
15027 {
15028 mask = myargv[optind + 1 + i];
15029
15030 if (stat (mask, &file_stat) == -1)
15031 {
15032 log_error ("ERROR: %s: %s", mask, strerror (errno));
15033
15034 return (-1);
15035 }
15036 }
15037
15038 uint is_file = S_ISREG (file_stat.st_mode);
15039
15040 if (is_file == 1)
15041 {
15042 FILE *mask_fp;
15043
15044 if ((mask_fp = fopen (mask, "r")) == NULL)
15045 {
15046 log_error ("ERROR: %s: %s", mask, strerror (errno));
15047
15048 return (-1);
15049 }
15050
15051 char line_buf[BUFSIZ] = { 0 };
15052
15053 while (!feof (mask_fp))
15054 {
15055 memset (line_buf, 0, BUFSIZ);
15056
15057 int line_len = fgetl (mask_fp, line_buf);
15058
15059 if (line_len == 0) continue;
15060
15061 if (line_buf[0] == '#') continue;
15062
15063 if (masks_avail == maskcnt)
15064 {
15065 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15066
15067 masks_avail += INCR_MASKS;
15068 }
15069
15070 masks[maskcnt] = mystrdup (line_buf);
15071
15072 maskcnt++;
15073 }
15074
15075 fclose (mask_fp);
15076 }
15077 else
15078 {
15079 log_error ("ERROR: %s: unsupported file-type", mask);
15080
15081 return (-1);
15082 }
15083 }
15084
15085 mask_from_file = 1;
15086 }
15087 }
15088 else
15089 {
15090 custom_charset_1 = (char *) "?l?d?u";
15091 custom_charset_2 = (char *) "?l?d";
15092 custom_charset_3 = (char *) "?l?d*!$@_";
15093
15094 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15095 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15096 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15097
15098 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15099
15100 wordlist_mode = WL_MODE_MASK;
15101
15102 data.wordlist_mode = wordlist_mode;
15103
15104 increment = 1;
15105
15106 maskcnt = 1;
15107 }
15108 }
15109 else
15110 {
15111 /**
15112 * generate full masks and charsets
15113 */
15114
15115 masks = (char **) mymalloc (sizeof (char *));
15116
15117 switch (hash_mode)
15118 {
15119 case 1731: pw_min = 5;
15120 pw_max = 5;
15121 mask = mystrdup ("?b?b?b?b?b");
15122 break;
15123 case 12500: pw_min = 5;
15124 pw_max = 5;
15125 mask = mystrdup ("?b?b?b?b?b");
15126 break;
15127 default: pw_min = 7;
15128 pw_max = 7;
15129 mask = mystrdup ("?b?b?b?b?b?b?b");
15130 break;
15131 }
15132
15133 maskcnt = 1;
15134
15135 masks[maskcnt - 1] = mystrdup (mask);
15136
15137 wordlist_mode = WL_MODE_MASK;
15138
15139 data.wordlist_mode = wordlist_mode;
15140
15141 increment = 1;
15142 }
15143
15144 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15145
15146 if (increment)
15147 {
15148 if (increment_min > pw_min) pw_min = increment_min;
15149
15150 if (increment_max < pw_max) pw_max = increment_max;
15151 }
15152 }
15153 else if (attack_mode == ATTACK_MODE_HYBRID1)
15154 {
15155 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15156
15157 // display
15158
15159 char *mask = myargv[myargc - 1];
15160
15161 maskcnt = 0;
15162
15163 masks = (char **) mymalloc (1 * sizeof (char *));
15164
15165 // mod
15166
15167 struct stat file_stat;
15168
15169 if (stat (mask, &file_stat) == -1)
15170 {
15171 maskcnt = 1;
15172
15173 masks[maskcnt - 1] = mystrdup (mask);
15174 }
15175 else
15176 {
15177 uint is_file = S_ISREG (file_stat.st_mode);
15178
15179 if (is_file == 1)
15180 {
15181 FILE *mask_fp;
15182
15183 if ((mask_fp = fopen (mask, "r")) == NULL)
15184 {
15185 log_error ("ERROR: %s: %s", mask, strerror (errno));
15186
15187 return (-1);
15188 }
15189
15190 char line_buf[BUFSIZ] = { 0 };
15191
15192 uint masks_avail = 1;
15193
15194 while (!feof (mask_fp))
15195 {
15196 memset (line_buf, 0, BUFSIZ);
15197
15198 int line_len = fgetl (mask_fp, line_buf);
15199
15200 if (line_len == 0) continue;
15201
15202 if (line_buf[0] == '#') continue;
15203
15204 if (masks_avail == maskcnt)
15205 {
15206 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15207
15208 masks_avail += INCR_MASKS;
15209 }
15210
15211 masks[maskcnt] = mystrdup (line_buf);
15212
15213 maskcnt++;
15214 }
15215
15216 fclose (mask_fp);
15217
15218 mask_from_file = 1;
15219 }
15220 else
15221 {
15222 maskcnt = 1;
15223
15224 masks[maskcnt - 1] = mystrdup (mask);
15225 }
15226 }
15227
15228 // base
15229
15230 int wls_left = myargc - (optind + 2);
15231
15232 for (int i = 0; i < wls_left; i++)
15233 {
15234 char *filename = myargv[optind + 1 + i];
15235
15236 struct stat file_stat;
15237
15238 if (stat (filename, &file_stat) == -1)
15239 {
15240 log_error ("ERROR: %s: %s", filename, strerror (errno));
15241
15242 return (-1);
15243 }
15244
15245 uint is_dir = S_ISDIR (file_stat.st_mode);
15246
15247 if (is_dir == 0)
15248 {
15249 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15250
15251 dictcnt++;
15252
15253 dictfiles[dictcnt - 1] = filename;
15254 }
15255 else
15256 {
15257 // do not allow --keyspace w/ a directory
15258
15259 if (keyspace == 1)
15260 {
15261 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15262
15263 return (-1);
15264 }
15265
15266 char **dictionary_files = NULL;
15267
15268 dictionary_files = scan_directory (filename);
15269
15270 if (dictionary_files != NULL)
15271 {
15272 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15273
15274 for (int d = 0; dictionary_files[d] != NULL; d++)
15275 {
15276 char *l1_filename = dictionary_files[d];
15277
15278 struct stat l1_stat;
15279
15280 if (stat (l1_filename, &l1_stat) == -1)
15281 {
15282 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15283
15284 return (-1);
15285 }
15286
15287 if (S_ISREG (l1_stat.st_mode))
15288 {
15289 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15290
15291 dictcnt++;
15292
15293 dictfiles[dictcnt - 1] = strdup (l1_filename);
15294 }
15295 }
15296 }
15297
15298 local_free (dictionary_files);
15299 }
15300 }
15301
15302 if (dictcnt < 1)
15303 {
15304 log_error ("ERROR: No usable dictionary file found.");
15305
15306 return (-1);
15307 }
15308
15309 if (increment)
15310 {
15311 maskcnt = 0;
15312
15313 uint mask_min = increment_min; // we can't reject smaller masks here
15314 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15315
15316 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15317 {
15318 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15319
15320 if (cur_mask == NULL) break;
15321
15322 masks[maskcnt] = cur_mask;
15323
15324 maskcnt++;
15325
15326 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15327 }
15328 }
15329 }
15330 else if (attack_mode == ATTACK_MODE_HYBRID2)
15331 {
15332 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15333
15334 // display
15335
15336 char *mask = myargv[optind + 1 + 0];
15337
15338 maskcnt = 0;
15339
15340 masks = (char **) mymalloc (1 * sizeof (char *));
15341
15342 // mod
15343
15344 struct stat file_stat;
15345
15346 if (stat (mask, &file_stat) == -1)
15347 {
15348 maskcnt = 1;
15349
15350 masks[maskcnt - 1] = mystrdup (mask);
15351 }
15352 else
15353 {
15354 uint is_file = S_ISREG (file_stat.st_mode);
15355
15356 if (is_file == 1)
15357 {
15358 FILE *mask_fp;
15359
15360 if ((mask_fp = fopen (mask, "r")) == NULL)
15361 {
15362 log_error ("ERROR: %s: %s", mask, strerror (errno));
15363
15364 return (-1);
15365 }
15366
15367 char line_buf[BUFSIZ] = { 0 };
15368
15369 uint masks_avail = 1;
15370
15371 while (!feof (mask_fp))
15372 {
15373 memset (line_buf, 0, BUFSIZ);
15374
15375 int line_len = fgetl (mask_fp, line_buf);
15376
15377 if (line_len == 0) continue;
15378
15379 if (line_buf[0] == '#') continue;
15380
15381 if (masks_avail == maskcnt)
15382 {
15383 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15384
15385 masks_avail += INCR_MASKS;
15386 }
15387
15388 masks[maskcnt] = mystrdup (line_buf);
15389
15390 maskcnt++;
15391 }
15392
15393 fclose (mask_fp);
15394
15395 mask_from_file = 1;
15396 }
15397 else
15398 {
15399 maskcnt = 1;
15400
15401 masks[maskcnt - 1] = mystrdup (mask);
15402 }
15403 }
15404
15405 // base
15406
15407 int wls_left = myargc - (optind + 2);
15408
15409 for (int i = 0; i < wls_left; i++)
15410 {
15411 char *filename = myargv[optind + 2 + i];
15412
15413 struct stat file_stat;
15414
15415 if (stat (filename, &file_stat) == -1)
15416 {
15417 log_error ("ERROR: %s: %s", filename, strerror (errno));
15418
15419 return (-1);
15420 }
15421
15422 uint is_dir = S_ISDIR (file_stat.st_mode);
15423
15424 if (is_dir == 0)
15425 {
15426 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15427
15428 dictcnt++;
15429
15430 dictfiles[dictcnt - 1] = filename;
15431 }
15432 else
15433 {
15434 // do not allow --keyspace w/ a directory
15435
15436 if (keyspace == 1)
15437 {
15438 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15439
15440 return (-1);
15441 }
15442
15443 char **dictionary_files = NULL;
15444
15445 dictionary_files = scan_directory (filename);
15446
15447 if (dictionary_files != NULL)
15448 {
15449 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15450
15451 for (int d = 0; dictionary_files[d] != NULL; d++)
15452 {
15453 char *l1_filename = dictionary_files[d];
15454
15455 struct stat l1_stat;
15456
15457 if (stat (l1_filename, &l1_stat) == -1)
15458 {
15459 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15460
15461 return (-1);
15462 }
15463
15464 if (S_ISREG (l1_stat.st_mode))
15465 {
15466 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15467
15468 dictcnt++;
15469
15470 dictfiles[dictcnt - 1] = strdup (l1_filename);
15471 }
15472 }
15473 }
15474
15475 local_free (dictionary_files);
15476 }
15477 }
15478
15479 if (dictcnt < 1)
15480 {
15481 log_error ("ERROR: No usable dictionary file found.");
15482
15483 return (-1);
15484 }
15485
15486 if (increment)
15487 {
15488 maskcnt = 0;
15489
15490 uint mask_min = increment_min; // we can't reject smaller masks here
15491 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15492
15493 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15494 {
15495 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15496
15497 if (cur_mask == NULL) break;
15498
15499 masks[maskcnt] = cur_mask;
15500
15501 maskcnt++;
15502
15503 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15504 }
15505 }
15506 }
15507
15508 data.pw_min = pw_min;
15509 data.pw_max = pw_max;
15510
15511 /**
15512 * weak hash check
15513 */
15514
15515 if (weak_hash_threshold >= salts_cnt)
15516 {
15517 hc_device_param_t *device_param = NULL;
15518
15519 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15520 {
15521 device_param = &data.devices_param[device_id];
15522
15523 if (device_param->skipped) continue;
15524
15525 break;
15526 }
15527
15528 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15529
15530 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15531 {
15532 weak_hash_check (device_param, salt_pos);
15533 }
15534 }
15535
15536 // Display hack, guarantee that there is at least one \r before real start
15537
15538 if (data.quiet == 0) log_info_nn ("");
15539
15540 /**
15541 * status and monitor threads
15542 */
15543
15544 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15545
15546 hc_thread_t i_thread = 0;
15547
15548 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15549 {
15550 hc_thread_create (i_thread, thread_keypress, &benchmark);
15551 }
15552
15553 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15554
15555 uint ni_threads_cnt = 0;
15556
15557 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15558
15559 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15560
15561 ni_threads_cnt++;
15562
15563 /**
15564 * Outfile remove
15565 */
15566
15567 if (keyspace == 0)
15568 {
15569 if (outfile_check_timer != 0)
15570 {
15571 if (data.outfile_check_directory != NULL)
15572 {
15573 if ((hash_mode != 5200) &&
15574 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15575 (hash_mode != 9000))
15576 {
15577 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15578
15579 ni_threads_cnt++;
15580 }
15581 else
15582 {
15583 outfile_check_timer = 0;
15584 }
15585 }
15586 else
15587 {
15588 outfile_check_timer = 0;
15589 }
15590 }
15591 }
15592
15593 /**
15594 * Inform the user if we got some hashes remove because of the pot file remove feature
15595 */
15596
15597 if (data.quiet == 0)
15598 {
15599 if (potfile_remove_cracks > 0)
15600 {
15601 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15602 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15603 }
15604 }
15605
15606 data.outfile_check_timer = outfile_check_timer;
15607
15608 /**
15609 * main loop
15610 */
15611
15612 char **induction_dictionaries = NULL;
15613
15614 int induction_dictionaries_cnt = 0;
15615
15616 hcstat_table_t *root_table_buf = NULL;
15617 hcstat_table_t *markov_table_buf = NULL;
15618
15619 uint initial_restore_done = 0;
15620
15621 data.maskcnt = maskcnt;
15622
15623 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15624 {
15625 if (data.devices_status == STATUS_CRACKED) break;
15626
15627 data.devices_status = STATUS_INIT;
15628
15629 if (maskpos > rd->maskpos)
15630 {
15631 rd->dictpos = 0;
15632 }
15633
15634 rd->maskpos = maskpos;
15635 data.maskpos = maskpos;
15636
15637 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15638 {
15639 char *mask = masks[maskpos];
15640
15641 if (mask_from_file == 1)
15642 {
15643 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15644
15645 char *str_ptr;
15646 uint str_pos;
15647
15648 uint mask_offset = 0;
15649
15650 uint separator_cnt;
15651
15652 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15653 {
15654 str_ptr = strstr (mask + mask_offset, ",");
15655
15656 if (str_ptr == NULL) break;
15657
15658 str_pos = str_ptr - mask;
15659
15660 // escaped separator, i.e. "\,"
15661
15662 if (str_pos > 0)
15663 {
15664 if (mask[str_pos - 1] == '\\')
15665 {
15666 separator_cnt --;
15667
15668 mask_offset = str_pos + 1;
15669
15670 continue;
15671 }
15672 }
15673
15674 // reset the offset
15675
15676 mask_offset = 0;
15677
15678 mask[str_pos] = '\0';
15679
15680 switch (separator_cnt)
15681 {
15682 case 0:
15683 mp_reset_usr (mp_usr, 0);
15684
15685 custom_charset_1 = mask;
15686 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15687 break;
15688
15689 case 1:
15690 mp_reset_usr (mp_usr, 1);
15691
15692 custom_charset_2 = mask;
15693 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15694 break;
15695
15696 case 2:
15697 mp_reset_usr (mp_usr, 2);
15698
15699 custom_charset_3 = mask;
15700 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15701 break;
15702
15703 case 3:
15704 mp_reset_usr (mp_usr, 3);
15705
15706 custom_charset_4 = mask;
15707 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15708 break;
15709 }
15710
15711 mask = mask + str_pos + 1;
15712 }
15713 }
15714
15715 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15716 {
15717 if (maskpos > 0)
15718 {
15719 local_free (css_buf);
15720 local_free (data.root_css_buf);
15721 local_free (data.markov_css_buf);
15722
15723 local_free (masks[maskpos - 1]);
15724 }
15725
15726 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15727
15728 data.mask = mask;
15729 data.css_cnt = css_cnt;
15730 data.css_buf = css_buf;
15731
15732 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15733
15734 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15735
15736 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15737 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15738
15739 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15740
15741 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15742
15743 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15744 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15745
15746 data.root_css_buf = root_css_buf;
15747 data.markov_css_buf = markov_css_buf;
15748
15749 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15750
15751 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15752
15753 local_free (root_table_buf);
15754 local_free (markov_table_buf);
15755
15756 // args
15757
15758 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15759 {
15760 hc_device_param_t *device_param = &data.devices_param[device_id];
15761
15762 if (device_param->skipped) continue;
15763
15764 device_param->kernel_params_mp[0] = &device_param->d_combs;
15765 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15766 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15767
15768 device_param->kernel_params_mp_buf64[3] = 0;
15769 device_param->kernel_params_mp_buf32[4] = css_cnt;
15770 device_param->kernel_params_mp_buf32[5] = 0;
15771 device_param->kernel_params_mp_buf32[6] = 0;
15772 device_param->kernel_params_mp_buf32[7] = 0;
15773
15774 if (attack_mode == ATTACK_MODE_HYBRID1)
15775 {
15776 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15777 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15778 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15779 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15780 }
15781 else if (attack_mode == ATTACK_MODE_HYBRID2)
15782 {
15783 device_param->kernel_params_mp_buf32[5] = 0;
15784 device_param->kernel_params_mp_buf32[6] = 0;
15785 device_param->kernel_params_mp_buf32[7] = 0;
15786 }
15787
15788 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]);
15789 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]);
15790 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]);
15791
15792 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);
15793 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);
15794 }
15795 }
15796 else if (attack_mode == ATTACK_MODE_BF)
15797 {
15798 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15799
15800 if (increment)
15801 {
15802 for (uint i = 0; i < dictcnt; i++)
15803 {
15804 local_free (dictfiles[i]);
15805 }
15806
15807 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15808 {
15809 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15810
15811 if (l1_filename == NULL) break;
15812
15813 dictcnt++;
15814
15815 dictfiles[dictcnt - 1] = l1_filename;
15816 }
15817 }
15818 else
15819 {
15820 dictcnt++;
15821
15822 dictfiles[dictcnt - 1] = mask;
15823 }
15824
15825 if (dictcnt == 0)
15826 {
15827 log_error ("ERROR: Mask is too small");
15828
15829 return (-1);
15830 }
15831 }
15832 }
15833
15834 free (induction_dictionaries);
15835
15836 // induction_dictionaries_cnt = 0; // implied
15837
15838 if (attack_mode != ATTACK_MODE_BF)
15839 {
15840 if (keyspace == 0)
15841 {
15842 induction_dictionaries = scan_directory (induction_directory);
15843
15844 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15845 }
15846 }
15847
15848 if (induction_dictionaries_cnt)
15849 {
15850 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15851 }
15852
15853 /**
15854 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15855 */
15856 if (keyspace == 1)
15857 {
15858 if ((maskcnt > 1) || (dictcnt > 1))
15859 {
15860 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15861
15862 return (-1);
15863 }
15864 }
15865
15866 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15867 {
15868 char *subid = logfile_generate_subid ();
15869
15870 data.subid = subid;
15871
15872 logfile_sub_msg ("START");
15873
15874 data.devices_status = STATUS_INIT;
15875
15876 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15877 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15878 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15879
15880 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15881
15882 data.cpt_pos = 0;
15883
15884 data.cpt_start = time (NULL);
15885
15886 data.cpt_total = 0;
15887
15888 if (data.restore == 0)
15889 {
15890 rd->words_cur = skip;
15891
15892 skip = 0;
15893
15894 data.skip = 0;
15895 }
15896
15897 data.ms_paused = 0;
15898
15899 data.words_cur = rd->words_cur;
15900
15901 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15902 {
15903 hc_device_param_t *device_param = &data.devices_param[device_id];
15904
15905 if (device_param->skipped) continue;
15906
15907 device_param->speed_pos = 0;
15908
15909 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15910 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15911 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15912
15913 device_param->exec_pos = 0;
15914
15915 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
15916
15917 device_param->kernel_power = device_param->kernel_power_user;
15918
15919 device_param->outerloop_pos = 0;
15920 device_param->outerloop_left = 0;
15921 device_param->innerloop_pos = 0;
15922 device_param->innerloop_left = 0;
15923
15924 // some more resets:
15925
15926 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
15927
15928 device_param->pws_cnt = 0;
15929
15930 device_param->words_off = 0;
15931 device_param->words_done = 0;
15932 }
15933
15934 data.kernel_power_div = 0;
15935
15936 // figure out some workload
15937
15938 if (attack_mode == ATTACK_MODE_STRAIGHT)
15939 {
15940 if (data.wordlist_mode == WL_MODE_FILE)
15941 {
15942 char *dictfile = NULL;
15943
15944 if (induction_dictionaries_cnt)
15945 {
15946 dictfile = induction_dictionaries[0];
15947 }
15948 else
15949 {
15950 dictfile = dictfiles[dictpos];
15951 }
15952
15953 data.dictfile = dictfile;
15954
15955 logfile_sub_string (dictfile);
15956
15957 for (uint i = 0; i < rp_files_cnt; i++)
15958 {
15959 logfile_sub_var_string ("rulefile", rp_files[i]);
15960 }
15961
15962 FILE *fd2 = fopen (dictfile, "rb");
15963
15964 if (fd2 == NULL)
15965 {
15966 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15967
15968 return (-1);
15969 }
15970
15971 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15972
15973 fclose (fd2);
15974
15975 if (data.words_cnt == 0)
15976 {
15977 if (data.devices_status == STATUS_CRACKED) break;
15978 if (data.devices_status == STATUS_ABORTED) break;
15979
15980 dictpos++;
15981
15982 continue;
15983 }
15984 }
15985 }
15986 else if (attack_mode == ATTACK_MODE_COMBI)
15987 {
15988 char *dictfile = data.dictfile;
15989 char *dictfile2 = data.dictfile2;
15990
15991 logfile_sub_string (dictfile);
15992 logfile_sub_string (dictfile2);
15993
15994 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15995 {
15996 FILE *fd2 = fopen (dictfile, "rb");
15997
15998 if (fd2 == NULL)
15999 {
16000 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16001
16002 return (-1);
16003 }
16004
16005 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16006
16007 fclose (fd2);
16008 }
16009 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16010 {
16011 FILE *fd2 = fopen (dictfile2, "rb");
16012
16013 if (fd2 == NULL)
16014 {
16015 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16016
16017 return (-1);
16018 }
16019
16020 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16021
16022 fclose (fd2);
16023 }
16024
16025 if (data.words_cnt == 0)
16026 {
16027 if (data.devices_status == STATUS_CRACKED) break;
16028 if (data.devices_status == STATUS_ABORTED) break;
16029
16030 dictpos++;
16031
16032 continue;
16033 }
16034 }
16035 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16036 {
16037 char *dictfile = NULL;
16038
16039 if (induction_dictionaries_cnt)
16040 {
16041 dictfile = induction_dictionaries[0];
16042 }
16043 else
16044 {
16045 dictfile = dictfiles[dictpos];
16046 }
16047
16048 data.dictfile = dictfile;
16049
16050 char *mask = data.mask;
16051
16052 logfile_sub_string (dictfile);
16053 logfile_sub_string (mask);
16054
16055 FILE *fd2 = fopen (dictfile, "rb");
16056
16057 if (fd2 == NULL)
16058 {
16059 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16060
16061 return (-1);
16062 }
16063
16064 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16065
16066 fclose (fd2);
16067
16068 if (data.words_cnt == 0)
16069 {
16070 if (data.devices_status == STATUS_CRACKED) break;
16071 if (data.devices_status == STATUS_ABORTED) break;
16072
16073 dictpos++;
16074
16075 continue;
16076 }
16077 }
16078 else if (attack_mode == ATTACK_MODE_BF)
16079 {
16080 local_free (css_buf);
16081 local_free (data.root_css_buf);
16082 local_free (data.markov_css_buf);
16083
16084 char *mask = dictfiles[dictpos];
16085
16086 logfile_sub_string (mask);
16087
16088 // base
16089
16090 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16091
16092 if (opts_type & OPTS_TYPE_PT_UNICODE)
16093 {
16094 uint css_cnt_unicode = css_cnt * 2;
16095
16096 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16097
16098 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16099 {
16100 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16101
16102 css_buf_unicode[j + 1].cs_buf[0] = 0;
16103 css_buf_unicode[j + 1].cs_len = 1;
16104 }
16105
16106 free (css_buf);
16107
16108 css_buf = css_buf_unicode;
16109 css_cnt = css_cnt_unicode;
16110 }
16111
16112 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16113
16114 uint mask_min = pw_min;
16115 uint mask_max = pw_max;
16116
16117 if (opts_type & OPTS_TYPE_PT_UNICODE)
16118 {
16119 mask_min *= 2;
16120 mask_max *= 2;
16121 }
16122
16123 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16124 {
16125 if (css_cnt < mask_min)
16126 {
16127 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16128 }
16129
16130 if (css_cnt > mask_max)
16131 {
16132 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16133 }
16134
16135 // skip to next mask
16136
16137 dictpos++;
16138
16139 rd->dictpos = dictpos;
16140
16141 logfile_sub_msg ("STOP");
16142
16143 continue;
16144 }
16145
16146 uint save_css_cnt = css_cnt;
16147
16148 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16149 {
16150 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16151 {
16152 uint salt_len = (uint) data.salts_buf[0].salt_len;
16153 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16154
16155 uint css_cnt_salt = css_cnt + salt_len;
16156
16157 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16158
16159 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16160
16161 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16162 {
16163 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16164 css_buf_salt[j].cs_len = 1;
16165 }
16166
16167 free (css_buf);
16168
16169 css_buf = css_buf_salt;
16170 css_cnt = css_cnt_salt;
16171 }
16172 }
16173
16174 data.mask = mask;
16175 data.css_cnt = css_cnt;
16176 data.css_buf = css_buf;
16177
16178 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16179
16180 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16181
16182 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16183
16184 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16185 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16186
16187 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16188
16189 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16190
16191 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16192 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16193
16194 data.root_css_buf = root_css_buf;
16195 data.markov_css_buf = markov_css_buf;
16196
16197 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16198
16199 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16200
16201 local_free (root_table_buf);
16202 local_free (markov_table_buf);
16203
16204 // copy + args
16205
16206 uint css_cnt_l = css_cnt;
16207 uint css_cnt_r;
16208
16209 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16210 {
16211 if (save_css_cnt < 6)
16212 {
16213 css_cnt_r = 1;
16214 }
16215 else if (save_css_cnt == 6)
16216 {
16217 css_cnt_r = 2;
16218 }
16219 else
16220 {
16221 if (opts_type & OPTS_TYPE_PT_UNICODE)
16222 {
16223 if (save_css_cnt == 8 || save_css_cnt == 10)
16224 {
16225 css_cnt_r = 2;
16226 }
16227 else
16228 {
16229 css_cnt_r = 4;
16230 }
16231 }
16232 else
16233 {
16234 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16235 {
16236 css_cnt_r = 3;
16237 }
16238 else
16239 {
16240 css_cnt_r = 4;
16241 }
16242 }
16243 }
16244 }
16245 else
16246 {
16247 css_cnt_r = 1;
16248
16249 /* unfinished code?
16250 int sum = css_buf[css_cnt_r - 1].cs_len;
16251
16252 for (uint i = 1; i < 4 && i < css_cnt; i++)
16253 {
16254 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16255
16256 css_cnt_r++;
16257
16258 sum *= css_buf[css_cnt_r - 1].cs_len;
16259 }
16260 */
16261 }
16262
16263 css_cnt_l -= css_cnt_r;
16264
16265 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16266
16267 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16268 {
16269 hc_device_param_t *device_param = &data.devices_param[device_id];
16270
16271 if (device_param->skipped) continue;
16272
16273 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16274 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16275 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16276
16277 device_param->kernel_params_mp_l_buf64[3] = 0;
16278 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16279 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16280 device_param->kernel_params_mp_l_buf32[6] = 0;
16281 device_param->kernel_params_mp_l_buf32[7] = 0;
16282 device_param->kernel_params_mp_l_buf32[8] = 0;
16283
16284 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16285 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16286 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16287 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16288
16289 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16290 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16291 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16292
16293 device_param->kernel_params_mp_r_buf64[3] = 0;
16294 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16295 device_param->kernel_params_mp_r_buf32[5] = 0;
16296 device_param->kernel_params_mp_r_buf32[6] = 0;
16297 device_param->kernel_params_mp_r_buf32[7] = 0;
16298
16299 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]);
16300 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]);
16301 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]);
16302
16303 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]);
16304 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]);
16305 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]);
16306
16307 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);
16308 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);
16309 }
16310 }
16311
16312 u64 words_base = data.words_cnt;
16313
16314 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16315 {
16316 if (data.kernel_rules_cnt)
16317 {
16318 words_base /= data.kernel_rules_cnt;
16319 }
16320 }
16321 else if (data.attack_kern == ATTACK_KERN_COMBI)
16322 {
16323 if (data.combs_cnt)
16324 {
16325 words_base /= data.combs_cnt;
16326 }
16327 }
16328 else if (data.attack_kern == ATTACK_KERN_BF)
16329 {
16330 if (data.bfs_cnt)
16331 {
16332 words_base /= data.bfs_cnt;
16333 }
16334 }
16335
16336 data.words_base = words_base;
16337
16338 if (keyspace == 1)
16339 {
16340 log_info ("%llu", (unsigned long long int) words_base);
16341
16342 return (0);
16343 }
16344
16345 if (data.words_cur > data.words_base)
16346 {
16347 log_error ("ERROR: restore value greater keyspace");
16348
16349 return (-1);
16350 }
16351
16352 if (data.words_cur)
16353 {
16354 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16355 {
16356 for (uint i = 0; i < data.salts_cnt; i++)
16357 {
16358 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16359 }
16360 }
16361 else if (data.attack_kern == ATTACK_KERN_COMBI)
16362 {
16363 for (uint i = 0; i < data.salts_cnt; i++)
16364 {
16365 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16366 }
16367 }
16368 else if (data.attack_kern == ATTACK_KERN_BF)
16369 {
16370 for (uint i = 0; i < data.salts_cnt; i++)
16371 {
16372 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16373 }
16374 }
16375 }
16376
16377 /*
16378 * Inform user about possible slow speeds
16379 */
16380
16381 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16382 {
16383 if (data.words_base < kernel_power_all)
16384 {
16385 if (quiet == 0)
16386 {
16387 log_info ("");
16388 log_info ("ATTENTION!");
16389 log_info (" The wordlist or mask you are using is too small.");
16390 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16391 log_info (" The cracking speed will drop.");
16392 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16393 log_info ("");
16394 }
16395 }
16396 }
16397
16398 /*
16399 * Update loopback file
16400 */
16401
16402 if (loopback == 1)
16403 {
16404 time_t now;
16405
16406 time (&now);
16407
16408 uint random_num = get_random_num (0, 9999);
16409
16410 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16411
16412 data.loopback_file = loopback_file;
16413 }
16414
16415 /*
16416 * Update dictionary statistic
16417 */
16418
16419 if (keyspace == 0)
16420 {
16421 dictstat_fp = fopen (dictstat, "wb");
16422
16423 if (dictstat_fp)
16424 {
16425 lock_file (dictstat_fp);
16426
16427 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16428
16429 fclose (dictstat_fp);
16430 }
16431 }
16432
16433 data.devices_status = STATUS_RUNNING;
16434
16435 if (initial_restore_done == 0)
16436 {
16437 if (data.restore_disable == 0) cycle_restore ();
16438
16439 initial_restore_done = 1;
16440 }
16441
16442 hc_timer_set (&data.timer_running);
16443
16444 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16445 {
16446 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16447 {
16448 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16449 if (quiet == 0) fflush (stdout);
16450 }
16451 }
16452 else if (wordlist_mode == WL_MODE_STDIN)
16453 {
16454 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16455 if (data.quiet == 0) log_info ("");
16456 }
16457
16458 time_t runtime_start;
16459
16460 time (&runtime_start);
16461
16462 data.runtime_start = runtime_start;
16463
16464 /**
16465 * create cracker threads
16466 */
16467
16468 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16469
16470 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16471 {
16472 hc_device_param_t *device_param = &devices_param[device_id];
16473
16474 if (wordlist_mode == WL_MODE_STDIN)
16475 {
16476 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16477 }
16478 else
16479 {
16480 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16481 }
16482 }
16483
16484 // wait for crack threads to exit
16485
16486 hc_thread_wait (data.devices_cnt, c_threads);
16487
16488 local_free (c_threads);
16489
16490 data.restore = 0;
16491
16492 // finalize task
16493
16494 logfile_sub_var_uint ("status-after-work", data.devices_status);
16495
16496 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16497
16498 if (data.devices_status == STATUS_CRACKED) break;
16499 if (data.devices_status == STATUS_ABORTED) break;
16500
16501 if (data.devices_status == STATUS_BYPASS)
16502 {
16503 data.devices_status = STATUS_RUNNING;
16504 }
16505
16506 if (induction_dictionaries_cnt)
16507 {
16508 unlink (induction_dictionaries[0]);
16509 }
16510
16511 free (induction_dictionaries);
16512
16513 if (attack_mode != ATTACK_MODE_BF)
16514 {
16515 induction_dictionaries = scan_directory (induction_directory);
16516
16517 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16518 }
16519
16520 if (benchmark == 0)
16521 {
16522 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16523 {
16524 if (quiet == 0) clear_prompt ();
16525
16526 if (quiet == 0) log_info ("");
16527
16528 if (status == 1)
16529 {
16530 status_display ();
16531 }
16532 else
16533 {
16534 if (quiet == 0) status_display ();
16535 }
16536
16537 if (quiet == 0) log_info ("");
16538 }
16539 }
16540
16541 if (attack_mode == ATTACK_MODE_BF)
16542 {
16543 dictpos++;
16544
16545 rd->dictpos = dictpos;
16546 }
16547 else
16548 {
16549 if (induction_dictionaries_cnt)
16550 {
16551 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16552 }
16553 else
16554 {
16555 dictpos++;
16556
16557 rd->dictpos = dictpos;
16558 }
16559 }
16560
16561 time_t runtime_stop;
16562
16563 time (&runtime_stop);
16564
16565 data.runtime_stop = runtime_stop;
16566
16567 logfile_sub_uint (runtime_start);
16568 logfile_sub_uint (runtime_stop);
16569
16570 logfile_sub_msg ("STOP");
16571
16572 global_free (subid);
16573 }
16574
16575 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16576
16577 if (data.devices_status == STATUS_CRACKED) break;
16578 if (data.devices_status == STATUS_ABORTED) break;
16579 if (data.devices_status == STATUS_QUIT) break;
16580
16581 if (data.devices_status == STATUS_BYPASS)
16582 {
16583 data.devices_status = STATUS_RUNNING;
16584 }
16585 }
16586
16587 // 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
16588
16589 if (attack_mode == ATTACK_MODE_STRAIGHT)
16590 {
16591 if (data.wordlist_mode == WL_MODE_FILE)
16592 {
16593 if (data.dictfile == NULL)
16594 {
16595 if (dictfiles != NULL)
16596 {
16597 data.dictfile = dictfiles[0];
16598
16599 hc_timer_set (&data.timer_running);
16600 }
16601 }
16602 }
16603 }
16604 // NOTE: combi is okay because it is already set beforehand
16605 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16606 {
16607 if (data.dictfile == NULL)
16608 {
16609 if (dictfiles != NULL)
16610 {
16611 hc_timer_set (&data.timer_running);
16612
16613 data.dictfile = dictfiles[0];
16614 }
16615 }
16616 }
16617 else if (attack_mode == ATTACK_MODE_BF)
16618 {
16619 if (data.mask == NULL)
16620 {
16621 hc_timer_set (&data.timer_running);
16622
16623 data.mask = masks[0];
16624 }
16625 }
16626
16627 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16628 {
16629 data.devices_status = STATUS_EXHAUSTED;
16630 }
16631
16632 // if cracked / aborted remove last induction dictionary
16633
16634 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16635 {
16636 struct stat induct_stat;
16637
16638 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16639 {
16640 unlink (induction_dictionaries[file_pos]);
16641 }
16642 }
16643
16644 // wait for non-interactive threads
16645
16646 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16647 {
16648 hc_thread_wait (1, &ni_threads[thread_idx]);
16649 }
16650
16651 local_free (ni_threads);
16652
16653 // wait for interactive threads
16654
16655 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16656 {
16657 hc_thread_wait (1, &i_thread);
16658 }
16659
16660 // we dont need restore file anymore
16661 if (data.restore_disable == 0)
16662 {
16663 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16664 {
16665 unlink (eff_restore_file);
16666 unlink (new_restore_file);
16667 }
16668 else
16669 {
16670 cycle_restore ();
16671 }
16672 }
16673
16674 // finally save left hashes
16675
16676 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16677 {
16678 save_hash ();
16679 }
16680
16681 /**
16682 * Clean up
16683 */
16684
16685 if (benchmark == 1)
16686 {
16687 status_benchmark ();
16688
16689 log_info ("");
16690 }
16691 else
16692 {
16693 if (quiet == 0) clear_prompt ();
16694
16695 if (quiet == 0) log_info ("");
16696
16697 if (status == 1)
16698 {
16699 status_display ();
16700 }
16701 else
16702 {
16703 if (quiet == 0) status_display ();
16704 }
16705
16706 if (quiet == 0) log_info ("");
16707 }
16708
16709 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16710 {
16711 hc_device_param_t *device_param = &data.devices_param[device_id];
16712
16713 if (device_param->skipped) continue;
16714
16715 local_free (device_param->result);
16716
16717 local_free (device_param->combs_buf);
16718
16719 local_free (device_param->hooks_buf);
16720
16721 local_free (device_param->device_name);
16722
16723 local_free (device_param->device_name_chksum);
16724
16725 local_free (device_param->device_version);
16726
16727 local_free (device_param->driver_version);
16728
16729 if (device_param->pws_buf) myfree (device_param->pws_buf);
16730 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16731 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16732 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16733 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16734 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16735 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16736 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16737 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16738 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16739 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16740 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16741 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16742 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16743 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16744 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16745 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16746 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16747 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16748 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16749 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16750 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16751 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16752 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16753 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16754 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16755 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16756 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16757 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16758
16759 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16760 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16761 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16762 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16763 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16764 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16765 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16766 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16767 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16768 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16769
16770 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16771 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16772 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16773
16774 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16775 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16776 }
16777
16778 // reset default fan speed
16779
16780 #ifdef HAVE_HWMON
16781 if (gpu_temp_disable == 0)
16782 {
16783 #ifdef HAVE_ADL
16784 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16785 {
16786 hc_thread_mutex_lock (mux_adl);
16787
16788 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16789 {
16790 hc_device_param_t *device_param = &data.devices_param[device_id];
16791
16792 if (device_param->skipped) continue;
16793
16794 if (data.hm_device[device_id].fan_supported == 1)
16795 {
16796 int fanspeed = temp_retain_fanspeed_value[device_id];
16797
16798 if (fanspeed == -1) continue;
16799
16800 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16801
16802 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16803 }
16804 }
16805
16806 hc_thread_mutex_unlock (mux_adl);
16807 }
16808 #endif // HAVE_ADL
16809 }
16810
16811 #ifdef HAVE_ADL
16812 // reset power tuning
16813
16814 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16815 {
16816 hc_thread_mutex_lock (mux_adl);
16817
16818 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16819 {
16820 hc_device_param_t *device_param = &data.devices_param[device_id];
16821
16822 if (device_param->skipped) continue;
16823
16824 if (data.hm_device[device_id].od_version == 6)
16825 {
16826 // check powertune capabilities first, if not available then skip device
16827
16828 int powertune_supported = 0;
16829
16830 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16831 {
16832 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16833
16834 return (-1);
16835 }
16836
16837 if (powertune_supported != 0)
16838 {
16839 // powercontrol settings
16840
16841 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)
16842 {
16843 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16844
16845 return (-1);
16846 }
16847
16848 // clocks
16849
16850 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16851
16852 performance_state->iNumberOfPerformanceLevels = 2;
16853
16854 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16855 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16856 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16857 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16858
16859 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)
16860 {
16861 log_info ("ERROR: Failed to restore ADL performance state");
16862
16863 return (-1);
16864 }
16865
16866 local_free (performance_state);
16867 }
16868 }
16869 }
16870
16871 hc_thread_mutex_unlock (mux_adl);
16872 }
16873 #endif // HAVE_ADL
16874
16875 if (gpu_temp_disable == 0)
16876 {
16877 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
16878 if (data.hm_nv)
16879 {
16880 #if defined(LINUX) && defined(HAVE_NVML)
16881
16882 hm_NVML_nvmlShutdown (data.hm_nv);
16883
16884 nvml_close (data.hm_nv);
16885
16886 #elif defined(WIN) && (HAVE_NVAPI)
16887
16888 hm_NvAPI_Unload (data.hm_nv);
16889
16890 nvapi_close (data.hm_nv);
16891
16892 #endif
16893
16894 data.hm_nv = NULL;
16895 }
16896 #endif
16897
16898 #ifdef HAVE_ADL
16899 if (data.hm_amd)
16900 {
16901 hm_ADL_Main_Control_Destroy (data.hm_amd);
16902
16903 adl_close (data.hm_amd);
16904 data.hm_amd = NULL;
16905 }
16906 #endif
16907 }
16908 #endif // HAVE_HWMON
16909
16910 // free memory
16911
16912 local_free (masks);
16913
16914 local_free (dictstat_base);
16915
16916 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16917 {
16918 pot_t *pot_ptr = &pot[pot_pos];
16919
16920 hash_t *hash = &pot_ptr->hash;
16921
16922 local_free (hash->digest);
16923
16924 if (isSalted)
16925 {
16926 local_free (hash->salt);
16927 }
16928 }
16929
16930 local_free (pot);
16931
16932 local_free (all_kernel_rules_cnt);
16933 local_free (all_kernel_rules_buf);
16934
16935 local_free (wl_data->buf);
16936 local_free (wl_data);
16937
16938 local_free (bitmap_s1_a);
16939 local_free (bitmap_s1_b);
16940 local_free (bitmap_s1_c);
16941 local_free (bitmap_s1_d);
16942 local_free (bitmap_s2_a);
16943 local_free (bitmap_s2_b);
16944 local_free (bitmap_s2_c);
16945 local_free (bitmap_s2_d);
16946
16947 #ifdef HAVE_HWMON
16948 local_free (temp_retain_fanspeed_value);
16949 #ifdef HAVE_ADL
16950 local_free (od_clock_mem_status);
16951 local_free (od_power_control_status);
16952 #endif // ADL
16953 #endif
16954
16955 global_free (devices_param);
16956
16957 global_free (kernel_rules_buf);
16958
16959 global_free (root_css_buf);
16960 global_free (markov_css_buf);
16961
16962 global_free (digests_buf);
16963 global_free (digests_shown);
16964 global_free (digests_shown_tmp);
16965
16966 global_free (salts_buf);
16967 global_free (salts_shown);
16968
16969 global_free (esalts_buf);
16970
16971 global_free (words_progress_done);
16972 global_free (words_progress_rejected);
16973 global_free (words_progress_restored);
16974
16975 if (pot_fp) fclose (pot_fp);
16976
16977 if (data.devices_status == STATUS_QUIT) break;
16978 }
16979
16980 // destroy others mutex
16981
16982 hc_thread_mutex_delete (mux_dispatcher);
16983 hc_thread_mutex_delete (mux_counter);
16984 hc_thread_mutex_delete (mux_display);
16985 hc_thread_mutex_delete (mux_adl);
16986
16987 // free memory
16988
16989 local_free (eff_restore_file);
16990 local_free (new_restore_file);
16991
16992 local_free (rd);
16993
16994 // tuning db
16995
16996 tuning_db_destroy (tuning_db);
16997
16998 // loopback
16999
17000 local_free (loopback_file);
17001
17002 if (loopback == 1) unlink (loopback_file);
17003
17004 // induction directory
17005
17006 if (induction_dir == NULL)
17007 {
17008 if (attack_mode != ATTACK_MODE_BF)
17009 {
17010 if (rmdir (induction_directory) == -1)
17011 {
17012 if (errno == ENOENT)
17013 {
17014 // good, we can ignore
17015 }
17016 else if (errno == ENOTEMPTY)
17017 {
17018 // good, we can ignore
17019 }
17020 else
17021 {
17022 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17023
17024 return (-1);
17025 }
17026 }
17027
17028 local_free (induction_directory);
17029 }
17030 }
17031
17032 // outfile-check directory
17033
17034 if (outfile_check_dir == NULL)
17035 {
17036 if (rmdir (outfile_check_directory) == -1)
17037 {
17038 if (errno == ENOENT)
17039 {
17040 // good, we can ignore
17041 }
17042 else if (errno == ENOTEMPTY)
17043 {
17044 // good, we can ignore
17045 }
17046 else
17047 {
17048 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17049
17050 return (-1);
17051 }
17052 }
17053
17054 local_free (outfile_check_directory);
17055 }
17056
17057 time_t proc_stop;
17058
17059 time (&proc_stop);
17060
17061 logfile_top_uint (proc_start);
17062 logfile_top_uint (proc_stop);
17063
17064 logfile_top_msg ("STOP");
17065
17066 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17067 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17068
17069 if (data.ocl) ocl_close (data.ocl);
17070
17071 if (data.devices_status == STATUS_ABORTED) return 2;
17072 if (data.devices_status == STATUS_QUIT) return 2;
17073 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17074 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17075 if (data.devices_status == STATUS_CRACKED) return 0;
17076
17077 return -1;
17078 }
Hashcat additions to support pwdhash