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