projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Do not use values that can actually crack a hash in autotune
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "oclHashcat";
19 const uint VERSION_BIN = 210;
20 const uint RESTORE_MIN = 210;
21
22 double TARGET_MS_PROFILE[3] = { 8, 16, 96 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define BENCHMARK_REPEATS 2
37 #define RESTORE 0
38 #define RESTORE_TIMER 60
39 #define RESTORE_DISABLE 0
40 #define STATUS 0
41 #define STATUS_TIMER 10
42 #define STATUS_AUTOMAT 0
43 #define LOOPBACK 0
44 #define WEAK_HASH_THRESHOLD 100
45 #define SHOW 0
46 #define LEFT 0
47 #define USERNAME 0
48 #define REMOVE 0
49 #define REMOVE_TIMER 60
50 #define SKIP 0
51 #define LIMIT 0
52 #define KEYSPACE 0
53 #define POTFILE_DISABLE 0
54 #define DEBUG_MODE 0
55 #define RP_GEN 0
56 #define RP_GEN_FUNC_MIN 1
57 #define RP_GEN_FUNC_MAX 4
58 #define RP_GEN_SEED 0
59 #define RULE_BUF_L ":"
60 #define RULE_BUF_R ":"
61 #define FORCE 0
62 #define RUNTIME 0
63 #define HEX_CHARSET 0
64 #define HEX_SALT 0
65 #define HEX_WORDLIST 0
66 #define OUTFILE_FORMAT 3
67 #define OUTFILE_AUTOHEX 1
68 #define OUTFILE_CHECK_TIMER 5
69 #define ATTACK_MODE 0
70 #define HASH_MODE 0
71 #define SEGMENT_SIZE 32
72 #define INCREMENT 0
73 #define INCREMENT_MIN 1
74 #define INCREMENT_MAX PW_MAX
75 #define SEPARATOR ':'
76 #define BITMAP_MIN 16
77 #define BITMAP_MAX 24
78 #define GPU_TEMP_DISABLE 0
79 #define GPU_TEMP_ABORT 90
80 #define GPU_TEMP_RETAIN 80
81 #define WORKLOAD_PROFILE 2
82 #define KERNEL_ACCEL 0
83 #define KERNEL_LOOPS 0
84 #define KERNEL_RULES 1024
85 #define KERNEL_COMBS 1024
86 #define KERNEL_BFS 1024
87 #define KERNEL_THREADS 64
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMT_HASHCAT 0
101 #define HLFMT_PWDUMP 1
102 #define HLFMT_PASSWD 2
103 #define HLFMT_SHADOW 3
104 #define HLFMT_DCC 4
105 #define HLFMT_DCC2 5
106 #define HLFMT_NETNTLM1 7
107 #define HLFMT_NETNTLM2 8
108 #define HLFMT_NSLDAP 9
109 #define HLFMT_NSLDAPS 10
110 #define HLFMTS_CNT 11
111
112 #define ATTACK_MODE_STRAIGHT 0
113 #define ATTACK_MODE_COMBI 1
114 #define ATTACK_MODE_TOGGLE 2
115 #define ATTACK_MODE_BF 3
116 #define ATTACK_MODE_PERM 4
117 #define ATTACK_MODE_TABLE 5
118 #define ATTACK_MODE_HYBRID1 6
119 #define ATTACK_MODE_HYBRID2 7
120 #define ATTACK_MODE_NONE 100
121
122 #define ATTACK_KERN_STRAIGHT 0
123 #define ATTACK_KERN_COMBI 1
124 #define ATTACK_KERN_BF 3
125 #define ATTACK_KERN_NONE 100
126
127 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
128 #define ATTACK_EXEC_INSIDE_KERNEL 11
129
130 #define COMBINATOR_MODE_BASE_LEFT 10001
131 #define COMBINATOR_MODE_BASE_RIGHT 10002
132
133 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
134 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
135
136 #define MAX_CUT_TRIES 4
137
138 #define MAX_DICTSTAT 10000
139
140 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 131
141
142 #define global_free(attr) \
143 { \
144 myfree ((void *) data.attr); \
145 \
146 data.attr = NULL; \
147 }
148
149 #define local_free(attr) \
150 { \
151 myfree ((void *) attr); \
152 \
153 attr = NULL; \
154 }
155
156 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
157 {
158 900,
159 0,
160 5100,
161 100,
162 1400,
163 10800,
164 1700,
165 5000,
166 10100,
167 6000,
168 6100,
169 6900,
170 11700,
171 11800,
172 400,
173 8900,
174 11900,
175 12000,
176 10900,
177 12100,
178 23,
179 2500,
180 5300,
181 5400,
182 5500,
183 5600,
184 7300,
185 7500,
186 13100,
187 8300,
188 11100,
189 11200,
190 11400,
191 121,
192 2611,
193 2711,
194 2811,
195 8400,
196 11,
197 2612,
198 7900,
199 21,
200 11000,
201 124,
202 10000,
203 3711,
204 7600,
205 12,
206 131,
207 132,
208 1731,
209 200,
210 300,
211 3100,
212 112,
213 12300,
214 8000,
215 141,
216 1441,
217 1600,
218 12600,
219 1421,
220 101,
221 111,
222 1711,
223 3000,
224 1000,
225 1100,
226 2100,
227 12800,
228 1500,
229 12400,
230 500,
231 3200,
232 7400,
233 1800,
234 122,
235 1722,
236 7100,
237 6300,
238 6700,
239 6400,
240 6500,
241 2400,
242 2410,
243 5700,
244 9200,
245 9300,
246 22,
247 501,
248 5800,
249 8100,
250 8500,
251 7200,
252 9900,
253 7700,
254 7800,
255 10300,
256 8600,
257 8700,
258 9100,
259 133,
260 11600,
261 12500,
262 13000,
263 6211,
264 6221,
265 6231,
266 6241,
267 8800,
268 12900,
269 12200,
270 9700,
271 9710,
272 9800,
273 9810,
274 9400,
275 9500,
276 9600,
277 10400,
278 10410,
279 10500,
280 10600,
281 10700,
282 9000,
283 5200,
284 6800,
285 6600,
286 8200,
287 11300,
288 12700
289 };
290
291 /**
292 * types
293 */
294
295 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
296
297 /**
298 * globals
299 */
300
301 static unsigned int full01 = 0x01010101;
302 static unsigned int full80 = 0x80808080;
303
304 int SUPPRESS_OUTPUT = 0;
305
306 hc_thread_mutex_t mux_adl;
307 hc_thread_mutex_t mux_counter;
308 hc_thread_mutex_t mux_dispatcher;
309 hc_thread_mutex_t mux_display;
310
311 hc_global_data_t data;
312
313 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
314
315 const char *USAGE_MINI[] =
316 {
317 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
318 "",
319 "Try --help for more help.",
320 NULL
321 };
322
323 const char *USAGE_BIG[] =
324 {
325 "%s, advanced password recovery",
326 "",
327 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
328 "",
329 "=======",
330 "Options",
331 "=======",
332 "",
333 "* General:",
334 "",
335 " -m, --hash-type=NUM Hash-type, see references below",
336 " -a, --attack-mode=NUM Attack-mode, see references below",
337 " -V, --version Print version",
338 " -h, --help Print help",
339 " --quiet Suppress output",
340 "",
341 "* Misc:",
342 "",
343 " --hex-charset Assume charset is given in hex",
344 " --hex-salt Assume salt is given in hex",
345 " --hex-wordlist Assume words in wordlist is given in hex",
346 " --force Ignore warnings",
347 " --status Enable automatic update of the status-screen",
348 " --status-timer=NUM Seconds between status-screen update",
349 " --status-automat Display the status view in a machine readable format",
350 " --loopback Add new plains to induct directory",
351 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
352 "",
353 "* Markov:",
354 "",
355 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
356 " --markov-disable Disables markov-chains, emulates classic brute-force",
357 " --markov-classic Enables classic markov-chains, no per-position enhancement",
358 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
359 "",
360 "* Session:",
361 "",
362 " --runtime=NUM Abort session after NUM seconds of runtime",
363 " --session=STR Define specific session name",
364 " --restore Restore session from --session",
365 " --restore-disable Do not write restore file",
366 "",
367 "* Files:",
368 "",
369 " -o, --outfile=FILE Define outfile for recovered hash",
370 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
371 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
372 " --outfile-check-timer=NUM Seconds between outfile checks",
373 " -p, --separator=CHAR Separator char for hashlists and outfile",
374 " --show Show cracked passwords only",
375 " --left Show un-cracked passwords only",
376 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
377 " --remove Enable remove of hash once it is cracked",
378 " --remove-timer=NUM Update input hash file each NUM seconds",
379 " --potfile-disable Do not write potfile",
380 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
381 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
382 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
383 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
384 " --logfile-disable Disable the logfile",
385 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
386 "",
387 "* Resources:",
388 "",
389 " -b, --benchmark Run benchmark",
390 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
391 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
392 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
393 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
394 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
395 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
396 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
397 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
398 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
399 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
400 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
401 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
402 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
403 #ifdef HAVE_HWMON
404 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
405 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
406 #ifdef HAVE_ADL
407 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
408 #endif
409 #endif
410 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
411 "",
412 "* Distributed:",
413 "",
414 " -s, --skip=NUM Skip number of words",
415 " -l, --limit=NUM Limit number of words",
416 " --keyspace Show keyspace base:mod values and quit",
417 "",
418 "* Rules:",
419 "",
420 " -j, --rule-left=RULE Single rule applied to each word from left dict",
421 " -k, --rule-right=RULE Single rule applied to each word from right dict",
422 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
423 " -g, --generate-rules=NUM Generate NUM random rules",
424 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
425 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
426 " --generate-rules-seed=NUM Force RNG seed to NUM",
427 "",
428 "* Custom charsets:",
429 "",
430 " -1, --custom-charset1=CS User-defined charsets",
431 " -2, --custom-charset2=CS Example:",
432 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
433 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
434 "",
435 "* Increment:",
436 "",
437 " -i, --increment Enable increment mode",
438 " --increment-min=NUM Start incrementing at NUM",
439 " --increment-max=NUM Stop incrementing at NUM",
440 "",
441 "==========",
442 "References",
443 "==========",
444 "",
445 "* Workload Profile:",
446 "",
447 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
448 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
449 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
450 "",
451 "* OpenCL device-types:",
452 "",
453 " 1 = CPU devices",
454 " 2 = GPU devices",
455 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
456 "",
457 "* Outfile Formats:",
458 "",
459 " 1 = hash[:salt]",
460 " 2 = plain",
461 " 3 = hash[:salt]:plain",
462 " 4 = hex_plain",
463 " 5 = hash[:salt]:hex_plain",
464 " 6 = plain:hex_plain",
465 " 7 = hash[:salt]:plain:hex_plain",
466 " 8 = crackpos",
467 " 9 = hash[:salt]:crackpos",
468 " 10 = plain:crackpos",
469 " 11 = hash[:salt]:plain:crackpos",
470 " 12 = hex_plain:crackpos",
471 " 13 = hash[:salt]:hex_plain:crackpos",
472 " 14 = plain:hex_plain:crackpos",
473 " 15 = hash[:salt]:plain:hex_plain:crackpos",
474 "",
475 "* Debug mode output formats (for hybrid mode only, by using rules):",
476 "",
477 " 1 = save finding rule",
478 " 2 = save original word",
479 " 3 = save original word and finding rule",
480 " 4 = save original word, finding rule and modified plain",
481 "",
482 "* Built-in charsets:",
483 "",
484 " ?l = abcdefghijklmnopqrstuvwxyz",
485 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
486 " ?d = 0123456789",
487 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
488 " ?a = ?l?u?d?s",
489 " ?b = 0x00 - 0xff",
490 "",
491 "* Attack modes:",
492 "",
493 " 0 = Straight",
494 " 1 = Combination",
495 " 3 = Brute-force",
496 " 6 = Hybrid dict + mask",
497 " 7 = Hybrid mask + dict",
498 "",
499 "* Hash types:",
500 "",
501 "[[ Roll-your-own: Raw Hashes ]]",
502 "",
503 " 900 = MD4",
504 " 0 = MD5",
505 " 5100 = Half MD5",
506 " 100 = SHA1",
507 " 10800 = SHA-384",
508 " 1400 = SHA-256",
509 " 1700 = SHA-512",
510 " 5000 = SHA-3(Keccak)",
511 " 10100 = SipHash",
512 " 6000 = RipeMD160",
513 " 6100 = Whirlpool",
514 " 6900 = GOST R 34.11-94",
515 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
516 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
517 "",
518 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
519 "",
520 " 10 = md5($pass.$salt)",
521 " 20 = md5($salt.$pass)",
522 " 30 = md5(unicode($pass).$salt)",
523 " 40 = md5($salt.unicode($pass))",
524 " 3800 = md5($salt.$pass.$salt)",
525 " 3710 = md5($salt.md5($pass))",
526 " 2600 = md5(md5($pass)",
527 " 4300 = md5(strtoupper(md5($pass)))",
528 " 4400 = md5(sha1($pass))",
529 " 110 = sha1($pass.$salt)",
530 " 120 = sha1($salt.$pass)",
531 " 130 = sha1(unicode($pass).$salt)",
532 " 140 = sha1($salt.unicode($pass))",
533 " 4500 = sha1(sha1($pass)",
534 " 4700 = sha1(md5($pass))",
535 " 4900 = sha1($salt.$pass.$salt)",
536 " 1410 = sha256($pass.$salt)",
537 " 1420 = sha256($salt.$pass)",
538 " 1430 = sha256(unicode($pass).$salt)",
539 " 1440 = sha256($salt.unicode($pass))",
540 " 1710 = sha512($pass.$salt)",
541 " 1720 = sha512($salt.$pass)",
542 " 1730 = sha512(unicode($pass).$salt)",
543 " 1740 = sha512($salt.unicode($pass))",
544 "",
545 "[[ Roll-your-own: Authenticated Hashes ]]",
546 "",
547 " 50 = HMAC-MD5 (key = $pass)",
548 " 60 = HMAC-MD5 (key = $salt)",
549 " 150 = HMAC-SHA1 (key = $pass)",
550 " 160 = HMAC-SHA1 (key = $salt)",
551 " 1450 = HMAC-SHA256 (key = $pass)",
552 " 1460 = HMAC-SHA256 (key = $salt)",
553 " 1750 = HMAC-SHA512 (key = $pass)",
554 " 1760 = HMAC-SHA512 (key = $salt)",
555 "",
556 "[[ Generic KDF ]]",
557 "",
558 " 400 = phpass",
559 " 8900 = scrypt",
560 " 11900 = PBKDF2-HMAC-MD5",
561 " 12000 = PBKDF2-HMAC-SHA1",
562 " 10900 = PBKDF2-HMAC-SHA256",
563 " 12100 = PBKDF2-HMAC-SHA512",
564 "",
565 "[[ Network protocols, Challenge-Response ]]",
566 "",
567 " 23 = Skype",
568 " 2500 = WPA/WPA2",
569 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
570 " 5300 = IKE-PSK MD5",
571 " 5400 = IKE-PSK SHA1",
572 " 5500 = NetNTLMv1",
573 " 5500 = NetNTLMv1 + ESS",
574 " 5600 = NetNTLMv2",
575 " 7300 = IPMI2 RAKP HMAC-SHA1",
576 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
577 " 8300 = DNSSEC (NSEC3)",
578 " 10200 = Cram MD5",
579 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
580 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
581 " 11400 = SIP digest authentication (MD5)",
582 " 13100 = Kerberos 5 TGS-REP etype 23",
583 "",
584 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
585 "",
586 " 121 = SMF (Simple Machines Forum)",
587 " 400 = phpBB3",
588 " 2611 = vBulletin < v3.8.5",
589 " 2711 = vBulletin > v3.8.5",
590 " 2811 = MyBB",
591 " 2811 = IPB (Invison Power Board)",
592 " 8400 = WBB3 (Woltlab Burning Board)",
593 " 11 = Joomla < 2.5.18",
594 " 400 = Joomla > 2.5.18",
595 " 400 = Wordpress",
596 " 2612 = PHPS",
597 " 7900 = Drupal7",
598 " 21 = osCommerce",
599 " 21 = xt:Commerce",
600 " 11000 = PrestaShop",
601 " 124 = Django (SHA-1)",
602 " 10000 = Django (PBKDF2-SHA256)",
603 " 3711 = Mediawiki B type",
604 " 7600 = Redmine",
605 "",
606 "[[ Database Server ]]",
607 "",
608 " 12 = PostgreSQL",
609 " 131 = MSSQL(2000)",
610 " 132 = MSSQL(2005)",
611 " 1731 = MSSQL(2012)",
612 " 1731 = MSSQL(2014)",
613 " 200 = MySQL323",
614 " 300 = MySQL4.1/MySQL5",
615 " 3100 = Oracle H: Type (Oracle 7+)",
616 " 112 = Oracle S: Type (Oracle 11+)",
617 " 12300 = Oracle T: Type (Oracle 12+)",
618 " 8000 = Sybase ASE",
619 "",
620 "[[ HTTP, SMTP, LDAP Server ]]",
621 "",
622 " 141 = EPiServer 6.x < v4",
623 " 1441 = EPiServer 6.x > v4",
624 " 1600 = Apache $apr1$",
625 " 12600 = ColdFusion 10+",
626 " 1421 = hMailServer",
627 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
628 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
629 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
630 "",
631 "[[ Checksums ]]",
632 "",
633 " 11500 = CRC32",
634 "",
635 "[[ Operating-Systems ]]",
636 "",
637 " 3000 = LM",
638 " 1000 = NTLM",
639 " 1100 = Domain Cached Credentials (DCC), MS Cache",
640 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
641 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
642 " 1500 = descrypt, DES(Unix), Traditional DES",
643 " 12400 = BSDiCrypt, Extended DES",
644 " 500 = md5crypt $1$, MD5(Unix)",
645 " 3200 = bcrypt $2*$, Blowfish(Unix)",
646 " 7400 = sha256crypt $5$, SHA256(Unix)",
647 " 1800 = sha512crypt $6$, SHA512(Unix)",
648 " 122 = OSX v10.4",
649 " 122 = OSX v10.5",
650 " 122 = OSX v10.6",
651 " 1722 = OSX v10.7",
652 " 7100 = OSX v10.8",
653 " 7100 = OSX v10.9",
654 " 7100 = OSX v10.10",
655 " 6300 = AIX {smd5}",
656 " 6700 = AIX {ssha1}",
657 " 6400 = AIX {ssha256}",
658 " 6500 = AIX {ssha512}",
659 " 2400 = Cisco-PIX",
660 " 2410 = Cisco-ASA",
661 " 500 = Cisco-IOS $1$",
662 " 5700 = Cisco-IOS $4$",
663 " 9200 = Cisco-IOS $8$",
664 " 9300 = Cisco-IOS $9$",
665 " 22 = Juniper Netscreen/SSG (ScreenOS)",
666 " 501 = Juniper IVE",
667 " 5800 = Android PIN",
668 " 8100 = Citrix Netscaler",
669 " 8500 = RACF",
670 " 7200 = GRUB 2",
671 " 9900 = Radmin2",
672 "",
673 "[[ Enterprise Application Software (EAS) ]]",
674 "",
675 " 7700 = SAP CODVN B (BCODE)",
676 " 7800 = SAP CODVN F/G (PASSCODE)",
677 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
678 " 8600 = Lotus Notes/Domino 5",
679 " 8700 = Lotus Notes/Domino 6",
680 " 9100 = Lotus Notes/Domino 8",
681 " 133 = PeopleSoft",
682 "",
683 "[[ Archives ]]",
684 "",
685 " 11600 = 7-Zip",
686 " 12500 = RAR3-hp",
687 " 13000 = RAR5",
688 "",
689 "[[ Full-Disk encryptions (FDE) ]]",
690 "",
691 " 62XY = TrueCrypt 5.0+",
692 " X = 1 = PBKDF2-HMAC-RipeMD160",
693 " X = 2 = PBKDF2-HMAC-SHA512",
694 " X = 3 = PBKDF2-HMAC-Whirlpool",
695 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
696 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
697 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
698 " Y = 3 = XTS 1536 bit (Ciphers: All)",
699 " 8800 = Android FDE < v4.3",
700 " 12900 = Android FDE (Samsung DEK)",
701 " 12200 = eCryptfs",
702 "",
703 "[[ Documents ]]",
704 "",
705 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
706 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
707 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
708 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
709 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
710 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
711 " 9400 = MS Office 2007",
712 " 9500 = MS Office 2010",
713 " 9600 = MS Office 2013",
714 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
715 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
716 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
717 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
718 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
719 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
720 "",
721 "[[ Password Managers ]]",
722 "",
723 " 9000 = Password Safe v2",
724 " 5200 = Password Safe v3",
725 " 6800 = Lastpass",
726 " 6600 = 1Password, agilekeychain",
727 " 8200 = 1Password, cloudkeychain",
728 " 11300 = Bitcoin/Litecoin wallet.dat",
729 " 12700 = Blockchain, My Wallet",
730 "",
731 NULL
732 };
733
734 /**
735 * oclHashcat specific functions
736 */
737
738 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
739 {
740 int exec_pos = (int) device_param->exec_pos - last_num_entries;
741
742 if (exec_pos < 0) exec_pos += EXEC_CACHE;
743
744 double exec_ms_sum = 0;
745
746 int exec_ms_cnt = 0;
747
748 for (int i = 0; i < last_num_entries; i++)
749 {
750 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
751
752 if (exec_ms)
753 {
754 exec_ms_sum += exec_ms;
755
756 exec_ms_cnt++;
757 }
758 }
759
760 if (exec_ms_cnt == 0) return 0;
761
762 return exec_ms_sum / exec_ms_cnt;
763 }
764
765 void status_display_automat ()
766 {
767 FILE *out = stdout;
768
769 fprintf (out, "STATUS\t%u\t", data.devices_status);
770
771 /**
772 * speed new
773 */
774
775 fprintf (out, "SPEED\t");
776
777 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
778 {
779 hc_device_param_t *device_param = &data.devices_param[device_id];
780
781 if (device_param->skipped) continue;
782
783 u64 speed_cnt = 0;
784 float speed_ms = 0;
785
786 for (int i = 0; i < SPEED_CACHE; i++)
787 {
788 float rec_ms;
789
790 hc_timer_get (device_param->speed_rec[i], rec_ms);
791
792 if (rec_ms > SPEED_MAXAGE) continue;
793
794 speed_cnt += device_param->speed_cnt[i];
795 speed_ms += device_param->speed_ms[i];
796 }
797
798 speed_cnt /= SPEED_CACHE;
799 speed_ms /= SPEED_CACHE;
800
801 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
802 }
803
804 /**
805 * exec time
806 */
807
808 fprintf (out, "EXEC_RUNTIME\t");
809
810 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
811 {
812 hc_device_param_t *device_param = &data.devices_param[device_id];
813
814 if (device_param->skipped) continue;
815
816 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
817
818 fprintf (out, "%f\t", exec_ms_avg);
819 }
820
821 /**
822 * words_cur
823 */
824
825 u64 words_cur = get_lowest_words_done ();
826
827 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
828
829 /**
830 * counter
831 */
832
833 uint salts_left = data.salts_cnt - data.salts_done;
834
835 if (salts_left == 0) salts_left = 1;
836
837 u64 progress_total = data.words_cnt * salts_left;
838
839 u64 all_done = 0;
840 u64 all_rejected = 0;
841 u64 all_restored = 0;
842
843 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
844 {
845 if (salts_left > 1)
846 {
847 // otherwise the final cracked status shows 0/XXX progress
848
849 if (data.salts_shown[salt_pos] == 1) continue;
850 }
851
852 all_done += data.words_progress_done[salt_pos];
853 all_rejected += data.words_progress_rejected[salt_pos];
854 all_restored += data.words_progress_restored[salt_pos];
855 }
856
857 u64 progress_cur = all_restored + all_done + all_rejected;
858 u64 progress_end = progress_total;
859
860 u64 progress_skip = 0;
861
862 if (data.skip)
863 {
864 progress_skip = MIN (data.skip, data.words_base) * salts_left;
865
866 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
867 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
868 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
869 }
870
871 if (data.limit)
872 {
873 progress_end = MIN (data.limit, data.words_base) * salts_left;
874
875 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
876 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
877 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
878 }
879
880 u64 progress_cur_relative_skip = progress_cur - progress_skip;
881 u64 progress_end_relative_skip = progress_end - progress_skip;
882
883 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
884
885 /**
886 * cracks
887 */
888
889 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
890 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
891
892 /**
893 * temperature
894 */
895
896 #ifdef HAVE_HWMON
897 if (data.gpu_temp_disable == 0)
898 {
899 fprintf (out, "TEMP\t");
900
901 hc_thread_mutex_lock (mux_adl);
902
903 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
904 {
905 hc_device_param_t *device_param = &data.devices_param[device_id];
906
907 if (device_param->skipped) continue;
908
909 int temp = hm_get_temperature_with_device_id (device_id);
910
911 fprintf (out, "%d\t", temp);
912 }
913
914 hc_thread_mutex_unlock (mux_adl);
915 }
916 #endif // HAVE_HWMON
917
918 /**
919 * flush
920 */
921
922 #ifdef _WIN
923 fputc ('\r', out);
924 fputc ('\n', out);
925 #endif
926
927 #ifdef _POSIX
928 fputc ('\n', out);
929 #endif
930
931 fflush (out);
932 }
933
934 void status_display ()
935 {
936 if (data.devices_status == STATUS_INIT) return;
937 if (data.devices_status == STATUS_STARTING) return;
938 if (data.devices_status == STATUS_BYPASS) return;
939
940 if (data.status_automat == 1)
941 {
942 status_display_automat ();
943
944 return;
945 }
946
947 char tmp_buf[1000] = { 0 };
948
949 uint tmp_len = 0;
950
951 log_info ("Session.Name...: %s", data.session);
952
953 char *status_type = strstatus (data.devices_status);
954
955 uint hash_mode = data.hash_mode;
956
957 char *hash_type = strhashtype (hash_mode); // not a bug
958
959 log_info ("Status.........: %s", status_type);
960
961 /**
962 * show rules
963 */
964
965 if (data.rp_files_cnt)
966 {
967 uint i;
968
969 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
970 {
971 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
972 }
973
974 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
975
976 log_info ("Rules.Type.....: %s", tmp_buf);
977
978 tmp_len = 0;
979 }
980
981 if (data.rp_gen)
982 {
983 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
984
985 if (data.rp_gen_seed)
986 {
987 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
988 }
989 }
990
991 /**
992 * show input
993 */
994
995 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
996 {
997 if (data.wordlist_mode == WL_MODE_FILE)
998 {
999 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1000 }
1001 else if (data.wordlist_mode == WL_MODE_STDIN)
1002 {
1003 log_info ("Input.Mode.....: Pipe");
1004 }
1005 }
1006 else if (data.attack_mode == ATTACK_MODE_COMBI)
1007 {
1008 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1009 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1010 }
1011 else if (data.attack_mode == ATTACK_MODE_BF)
1012 {
1013 char *mask = data.mask;
1014
1015 if (mask != NULL)
1016 {
1017 uint mask_len = data.css_cnt;
1018
1019 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1020
1021 if (mask_len > 0)
1022 {
1023 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1024 {
1025 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1026 {
1027 mask_len -= data.salts_buf[0].salt_len;
1028 }
1029 }
1030
1031 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1032
1033 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1034 }
1035
1036 if (data.maskcnt > 1)
1037 {
1038 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1039
1040 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1041 }
1042
1043 log_info ("Input.Mode.....: %s", tmp_buf);
1044 }
1045
1046 tmp_len = 0;
1047 }
1048 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1049 {
1050 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1051 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1052 }
1053 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1054 {
1055 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1056 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1057 }
1058
1059 if (data.digests_cnt == 1)
1060 {
1061 if (data.hash_mode == 2500)
1062 {
1063 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1064
1065 uint pke[25] = { 0 };
1066
1067 char *pke_ptr = (char *) pke;
1068
1069 for (uint i = 0; i < 25; i++)
1070 {
1071 pke[i] = byte_swap_32 (wpa->pke[i]);
1072 }
1073
1074 char mac1[6] = { 0 };
1075 char mac2[6] = { 0 };
1076
1077 memcpy (mac1, pke_ptr + 23, 6);
1078 memcpy (mac2, pke_ptr + 29, 6);
1079
1080 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1081 (char *) data.salts_buf[0].salt_buf,
1082 mac1[0] & 0xff,
1083 mac1[1] & 0xff,
1084 mac1[2] & 0xff,
1085 mac1[3] & 0xff,
1086 mac1[4] & 0xff,
1087 mac1[5] & 0xff,
1088 mac2[0] & 0xff,
1089 mac2[1] & 0xff,
1090 mac2[2] & 0xff,
1091 mac2[3] & 0xff,
1092 mac2[4] & 0xff,
1093 mac2[5] & 0xff);
1094 }
1095 else if (data.hash_mode == 5200)
1096 {
1097 log_info ("Hash.Target....: File (%s)", data.hashfile);
1098 }
1099 else if (data.hash_mode == 9000)
1100 {
1101 log_info ("Hash.Target....: File (%s)", data.hashfile);
1102 }
1103 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1104 {
1105 log_info ("Hash.Target....: File (%s)", data.hashfile);
1106 }
1107 else
1108 {
1109 char out_buf[4096] = { 0 };
1110
1111 ascii_digest (out_buf, 0, 0);
1112
1113 // limit length
1114 if (strlen (out_buf) > 40)
1115 {
1116 out_buf[41] = '.';
1117 out_buf[42] = '.';
1118 out_buf[43] = '.';
1119 out_buf[44] = 0;
1120 }
1121
1122 log_info ("Hash.Target....: %s", out_buf);
1123 }
1124 }
1125 else
1126 {
1127 if (data.hash_mode == 3000)
1128 {
1129 char out_buf1[4096] = { 0 };
1130 char out_buf2[4096] = { 0 };
1131
1132 ascii_digest (out_buf1, 0, 0);
1133 ascii_digest (out_buf2, 0, 1);
1134
1135 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1136 }
1137 else
1138 {
1139 log_info ("Hash.Target....: File (%s)", data.hashfile);
1140 }
1141 }
1142
1143 log_info ("Hash.Type......: %s", hash_type);
1144
1145 /**
1146 * speed new
1147 */
1148
1149 u64 speed_cnt[DEVICES_MAX] = { 0 };
1150 float speed_ms[DEVICES_MAX] = { 0 };
1151
1152 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1153 {
1154 hc_device_param_t *device_param = &data.devices_param[device_id];
1155
1156 if (device_param->skipped) continue;
1157
1158 // we need to clear values (set to 0) because in case the device does
1159 // not get new candidates it idles around but speed display would
1160 // show it as working.
1161 // if we instantly set it to 0 after reading it happens that the
1162 // speed can be shown as zero if the users refreshes too fast.
1163 // therefore, we add a timestamp when a stat was recorded and if its
1164 // too old we will not use it
1165
1166 speed_cnt[device_id] = 0;
1167 speed_ms[device_id] = 0;
1168
1169 for (int i = 0; i < SPEED_CACHE; i++)
1170 {
1171 float rec_ms;
1172
1173 hc_timer_get (device_param->speed_rec[i], rec_ms);
1174
1175 if (rec_ms > SPEED_MAXAGE) continue;
1176
1177 speed_cnt[device_id] += device_param->speed_cnt[i];
1178 speed_ms[device_id] += device_param->speed_ms[i];
1179 }
1180
1181 speed_cnt[device_id] /= SPEED_CACHE;
1182 speed_ms[device_id] /= SPEED_CACHE;
1183 }
1184
1185 float hashes_all_ms = 0;
1186
1187 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1188
1189 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1190 {
1191 hc_device_param_t *device_param = &data.devices_param[device_id];
1192
1193 if (device_param->skipped) continue;
1194
1195 hashes_dev_ms[device_id] = 0;
1196
1197 if (speed_ms[device_id])
1198 {
1199 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1200
1201 hashes_all_ms += hashes_dev_ms[device_id];
1202 }
1203 }
1204
1205 /**
1206 * exec time
1207 */
1208
1209 double exec_all_ms[DEVICES_MAX] = { 0 };
1210
1211 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1212 {
1213 hc_device_param_t *device_param = &data.devices_param[device_id];
1214
1215 if (device_param->skipped) continue;
1216
1217 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1218
1219 exec_all_ms[device_id] = exec_ms_avg;
1220 }
1221
1222 /**
1223 * timers
1224 */
1225
1226 float ms_running = 0;
1227
1228 hc_timer_get (data.timer_running, ms_running);
1229
1230 float ms_paused = data.ms_paused;
1231
1232 if (data.devices_status == STATUS_PAUSED)
1233 {
1234 float ms_paused_tmp = 0;
1235
1236 hc_timer_get (data.timer_paused, ms_paused_tmp);
1237
1238 ms_paused += ms_paused_tmp;
1239 }
1240
1241 #ifdef WIN
1242
1243 __time64_t sec_run = ms_running / 1000;
1244
1245 #else
1246
1247 time_t sec_run = ms_running / 1000;
1248
1249 #endif
1250
1251 if (sec_run)
1252 {
1253 char display_run[32] = { 0 };
1254
1255 struct tm tm_run;
1256
1257 struct tm *tmp = NULL;
1258
1259 #ifdef WIN
1260
1261 tmp = _gmtime64 (&sec_run);
1262
1263 #else
1264
1265 tmp = gmtime (&sec_run);
1266
1267 #endif
1268
1269 if (tmp != NULL)
1270 {
1271 memset (&tm_run, 0, sizeof (tm_run));
1272
1273 memcpy (&tm_run, tmp, sizeof (tm_run));
1274
1275 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1276
1277 char *start = ctime (&data.proc_start);
1278
1279 size_t start_len = strlen (start);
1280
1281 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1282 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1283
1284 log_info ("Time.Started...: %s (%s)", start, display_run);
1285 }
1286 }
1287 else
1288 {
1289 log_info ("Time.Started...: 0 secs");
1290 }
1291
1292 /**
1293 * counters
1294 */
1295
1296 uint salts_left = data.salts_cnt - data.salts_done;
1297
1298 if (salts_left == 0) salts_left = 1;
1299
1300 u64 progress_total = data.words_cnt * salts_left;
1301
1302 u64 all_done = 0;
1303 u64 all_rejected = 0;
1304 u64 all_restored = 0;
1305
1306 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1307 {
1308 if (salts_left > 1)
1309 {
1310 // otherwise the final cracked status shows 0/XXX progress
1311
1312 if (data.salts_shown[salt_pos] == 1) continue;
1313 }
1314
1315 all_done += data.words_progress_done[salt_pos];
1316 all_rejected += data.words_progress_rejected[salt_pos];
1317 all_restored += data.words_progress_restored[salt_pos];
1318 }
1319
1320 u64 progress_cur = all_restored + all_done + all_rejected;
1321 u64 progress_end = progress_total;
1322
1323 u64 progress_skip = 0;
1324
1325 if (data.skip)
1326 {
1327 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1328
1329 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1330 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1331 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1332 }
1333
1334 if (data.limit)
1335 {
1336 progress_end = MIN (data.limit, data.words_base) * salts_left;
1337
1338 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1339 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1340 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1341 }
1342
1343 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1344 u64 progress_end_relative_skip = progress_end - progress_skip;
1345
1346 float speed_ms_real = ms_running - ms_paused;
1347 u64 speed_plains_real = all_done;
1348
1349 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1350 {
1351 if (data.devices_status != STATUS_CRACKED)
1352 {
1353 u64 words_per_ms = 0;
1354
1355 if (speed_plains_real && speed_ms_real)
1356 {
1357 words_per_ms = speed_plains_real / speed_ms_real;
1358 }
1359
1360 #ifdef WIN
1361 __time64_t sec_etc = 0;
1362 #else
1363 time_t sec_etc = 0;
1364 #endif
1365
1366 if (words_per_ms)
1367 {
1368 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1369
1370 u64 ms_left = progress_left_relative_skip / words_per_ms;
1371
1372 sec_etc = ms_left / 1000;
1373 }
1374
1375 if (sec_etc == 0)
1376 {
1377 log_info ("Time.Estimated.: 0 secs");
1378 }
1379 else if ((u64) sec_etc > ETC_MAX)
1380 {
1381 log_info ("Time.Estimated.: > 10 Years");
1382 }
1383 else
1384 {
1385 char display_etc[32] = { 0 };
1386
1387 struct tm tm_etc;
1388
1389 struct tm *tmp = NULL;
1390
1391 #ifdef WIN
1392
1393 tmp = _gmtime64 (&sec_etc);
1394
1395 #else
1396
1397 tmp = gmtime (&sec_etc);
1398
1399 #endif
1400
1401 if (tmp != NULL)
1402 {
1403 memset (&tm_etc, 0, sizeof (tm_etc));
1404
1405 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1406
1407 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1408
1409 time_t now;
1410
1411 time (&now);
1412
1413 now += sec_etc;
1414
1415 char *etc = ctime (&now);
1416
1417 size_t etc_len = strlen (etc);
1418
1419 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1420 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1421
1422 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1423 }
1424 }
1425 }
1426 }
1427
1428 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1429 {
1430 hc_device_param_t *device_param = &data.devices_param[device_id];
1431
1432 if (device_param->skipped) continue;
1433
1434 char display_dev_cur[16] = { 0 };
1435
1436 strncpy (display_dev_cur, "0.00", 4);
1437
1438 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1439
1440 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1441 }
1442
1443 char display_all_cur[16] = { 0 };
1444
1445 strncpy (display_all_cur, "0.00", 4);
1446
1447 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1448
1449 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1450
1451 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1452 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1453
1454 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1455
1456 // crack-per-time
1457
1458 if (data.digests_cnt > 100)
1459 {
1460 time_t now = time (NULL);
1461
1462 int cpt_cur_min = 0;
1463 int cpt_cur_hour = 0;
1464 int cpt_cur_day = 0;
1465
1466 for (int i = 0; i < CPT_BUF; i++)
1467 {
1468 const uint cracked = data.cpt_buf[i].cracked;
1469 const time_t timestamp = data.cpt_buf[i].timestamp;
1470
1471 if ((timestamp + 60) > now)
1472 {
1473 cpt_cur_min += cracked;
1474 }
1475
1476 if ((timestamp + 3600) > now)
1477 {
1478 cpt_cur_hour += cracked;
1479 }
1480
1481 if ((timestamp + 86400) > now)
1482 {
1483 cpt_cur_day += cracked;
1484 }
1485 }
1486
1487 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1488 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1489 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1490
1491 if ((data.cpt_start + 86400) < now)
1492 {
1493 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1494 cpt_cur_min,
1495 cpt_cur_hour,
1496 cpt_cur_day,
1497 cpt_avg_min,
1498 cpt_avg_hour,
1499 cpt_avg_day);
1500 }
1501 else if ((data.cpt_start + 3600) < now)
1502 {
1503 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1504 cpt_cur_min,
1505 cpt_cur_hour,
1506 cpt_avg_min,
1507 cpt_avg_hour,
1508 cpt_avg_day);
1509 }
1510 else if ((data.cpt_start + 60) < now)
1511 {
1512 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1513 cpt_cur_min,
1514 cpt_avg_min,
1515 cpt_avg_hour,
1516 cpt_avg_day);
1517 }
1518 else
1519 {
1520 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1521 cpt_avg_min,
1522 cpt_avg_hour,
1523 cpt_avg_day);
1524 }
1525 }
1526
1527 // Restore point
1528
1529 u64 restore_point = get_lowest_words_done ();
1530
1531 u64 restore_total = data.words_base;
1532
1533 float percent_restore = 0;
1534
1535 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1536
1537 if (progress_end_relative_skip)
1538 {
1539 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1540 {
1541 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1542 float percent_rejected = 0.0;
1543
1544 if (progress_cur)
1545 {
1546 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1547 }
1548
1549 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1550 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1551
1552 if (data.restore_disable == 0)
1553 {
1554 if (percent_finished != 1)
1555 {
1556 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1557 }
1558 }
1559 }
1560 }
1561 else
1562 {
1563 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1564 {
1565 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1566 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1567
1568 if (data.restore_disable == 0)
1569 {
1570 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1571 }
1572 }
1573 else
1574 {
1575 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1576 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1577
1578 // --restore not allowed if stdin is used -- really? why?
1579
1580 //if (data.restore_disable == 0)
1581 //{
1582 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1583 //}
1584 }
1585 }
1586
1587 #ifdef HAVE_HWMON
1588 if (data.gpu_temp_disable == 0)
1589 {
1590 hc_thread_mutex_lock (mux_adl);
1591
1592 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1593 {
1594 hc_device_param_t *device_param = &data.devices_param[device_id];
1595
1596 if (device_param->skipped) continue;
1597
1598 #define HM_STR_BUF_SIZE 255
1599
1600 if (data.hm_device[device_id].fan_supported == 1)
1601 {
1602 char utilization[HM_STR_BUF_SIZE] = { 0 };
1603 char temperature[HM_STR_BUF_SIZE] = { 0 };
1604 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1605
1606 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1607 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1608
1609 if (device_param->vendor_id == VENDOR_ID_AMD)
1610 {
1611 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1612 }
1613 else if (device_param->vendor_id == VENDOR_ID_NV)
1614 {
1615 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1616 }
1617
1618 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1619 }
1620 else
1621 {
1622 char utilization[HM_STR_BUF_SIZE] = { 0 };
1623 char temperature[HM_STR_BUF_SIZE] = { 0 };
1624
1625 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1626 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1627
1628 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1629 }
1630 }
1631
1632 hc_thread_mutex_unlock (mux_adl);
1633 }
1634 #endif // HAVE_HWMON
1635 }
1636
1637 static void status_benchmark ()
1638 {
1639 if (data.devices_status == STATUS_INIT) return;
1640 if (data.devices_status == STATUS_STARTING) return;
1641
1642 if (data.words_cnt == 0) return;
1643
1644 u64 speed_cnt[DEVICES_MAX] = { 0 };
1645 float speed_ms[DEVICES_MAX] = { 0 };
1646
1647 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1648 {
1649 hc_device_param_t *device_param = &data.devices_param[device_id];
1650
1651 if (device_param->skipped) continue;
1652
1653 speed_cnt[device_id] = 0;
1654 speed_ms[device_id] = 0;
1655
1656 for (int i = 0; i < SPEED_CACHE; i++)
1657 {
1658 speed_cnt[device_id] += device_param->speed_cnt[i];
1659 speed_ms[device_id] += device_param->speed_ms[i];
1660 }
1661
1662 speed_cnt[device_id] /= SPEED_CACHE;
1663 speed_ms[device_id] /= SPEED_CACHE;
1664 }
1665
1666 float hashes_all_ms = 0;
1667
1668 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1669
1670 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1671 {
1672 hc_device_param_t *device_param = &data.devices_param[device_id];
1673
1674 if (device_param->skipped) continue;
1675
1676 hashes_dev_ms[device_id] = 0;
1677
1678 if (speed_ms[device_id])
1679 {
1680 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1681
1682 hashes_all_ms += hashes_dev_ms[device_id];
1683 }
1684 }
1685
1686 /**
1687 * exec time
1688 */
1689
1690 double exec_all_ms[DEVICES_MAX] = { 0 };
1691
1692 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1693 {
1694 hc_device_param_t *device_param = &data.devices_param[device_id];
1695
1696 if (device_param->skipped) continue;
1697
1698 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1699
1700 exec_all_ms[device_id] = exec_ms_avg;
1701 }
1702
1703 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1704 {
1705 hc_device_param_t *device_param = &data.devices_param[device_id];
1706
1707 if (device_param->skipped) continue;
1708
1709 char display_dev_cur[16] = { 0 };
1710
1711 strncpy (display_dev_cur, "0.00", 4);
1712
1713 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1714
1715 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1716 }
1717
1718 char display_all_cur[16] = { 0 };
1719
1720 strncpy (display_all_cur, "0.00", 4);
1721
1722 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1723
1724 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1725 }
1726
1727 /**
1728 * oclHashcat -only- functions
1729 */
1730
1731 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1732 {
1733 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1734 {
1735 if (attack_kern == ATTACK_KERN_STRAIGHT)
1736 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1737 else if (attack_kern == ATTACK_KERN_COMBI)
1738 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1739 else if (attack_kern == ATTACK_KERN_BF)
1740 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1741 }
1742 else
1743 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1744 }
1745
1746 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1747 {
1748 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1749 {
1750 if (attack_kern == ATTACK_KERN_STRAIGHT)
1751 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1752 else if (attack_kern == ATTACK_KERN_COMBI)
1753 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1754 else if (attack_kern == ATTACK_KERN_BF)
1755 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1756 }
1757 else
1758 {
1759 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1760 }
1761 }
1762
1763 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1764 {
1765 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1766 {
1767 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1768 }
1769 else
1770 {
1771 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1772 }
1773 }
1774
1775 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1776 {
1777 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1778 {
1779 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1780 }
1781 else
1782 {
1783 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1784 }
1785 }
1786
1787 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1788 {
1789 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1790 }
1791
1792 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1793 {
1794 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1795 }
1796
1797 static uint convert_from_hex (char *line_buf, const uint line_len)
1798 {
1799 if (line_len & 1) return (line_len); // not in hex
1800
1801 if (data.hex_wordlist == 1)
1802 {
1803 uint i;
1804 uint j;
1805
1806 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1807 {
1808 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1809 }
1810
1811 memset (line_buf + i, 0, line_len - i);
1812
1813 return (i);
1814 }
1815 else if (line_len >= 6) // $HEX[] = 6
1816 {
1817 if (line_buf[0] != '$') return (line_len);
1818 if (line_buf[1] != 'H') return (line_len);
1819 if (line_buf[2] != 'E') return (line_len);
1820 if (line_buf[3] != 'X') return (line_len);
1821 if (line_buf[4] != '[') return (line_len);
1822 if (line_buf[line_len - 1] != ']') return (line_len);
1823
1824 uint i;
1825 uint j;
1826
1827 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1828 {
1829 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1830 }
1831
1832 memset (line_buf + i, 0, line_len - i);
1833
1834 return (i);
1835 }
1836
1837 return (line_len);
1838 }
1839
1840 static void clear_prompt ()
1841 {
1842 fputc ('\r', stdout);
1843
1844 for (size_t i = 0; i < strlen (PROMPT); i++)
1845 {
1846 fputc (' ', stdout);
1847 }
1848
1849 fputc ('\r', stdout);
1850
1851 fflush (stdout);
1852 }
1853
1854 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1855 {
1856 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1857 }
1858
1859 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1860 {
1861 char *outfile = data.outfile;
1862 uint quiet = data.quiet;
1863 FILE *pot_fp = data.pot_fp;
1864 uint loopback = data.loopback;
1865 uint debug_mode = data.debug_mode;
1866 char *debug_file = data.debug_file;
1867
1868 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1869 int debug_rule_len = 0; // -1 error
1870 uint debug_plain_len = 0;
1871
1872 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1873
1874 // hash
1875
1876 char out_buf[4096] = { 0 };
1877
1878 ascii_digest (out_buf, salt_pos, digest_pos);
1879
1880 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1881
1882 // plain
1883
1884 plain_t plain;
1885
1886 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1887
1888 uint gidvid = plain.gidvid;
1889 uint il_pos = plain.il_pos;
1890
1891 u64 crackpos = device_param->words_off;
1892
1893 uint plain_buf[16] = { 0 };
1894
1895 u8 *plain_ptr = (u8 *) plain_buf;
1896 unsigned int plain_len = 0;
1897
1898 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1899 {
1900 u64 gidd = gidvid;
1901 u64 gidm = 0;
1902
1903 pw_t pw;
1904
1905 gidd_to_pw_t (device_param, gidd, &pw);
1906
1907 for (int i = 0, j = gidm; i < 16; i++, j++)
1908 {
1909 plain_buf[i] = pw.i[j];
1910 }
1911
1912 plain_len = pw.pw_len;
1913
1914 const uint off = device_param->innerloop_pos + il_pos;
1915
1916 if (debug_mode > 0)
1917 {
1918 debug_rule_len = 0;
1919
1920 // save rule
1921 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1922 {
1923 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1924
1925 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1926 }
1927
1928 // save plain
1929 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1930 {
1931 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1932
1933 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1934
1935 debug_plain_len = plain_len;
1936 }
1937 }
1938
1939 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1940
1941 crackpos += gidvid;
1942 crackpos *= data.kernel_rules_cnt;
1943 crackpos += device_param->innerloop_pos + il_pos;
1944
1945 if (plain_len > data.pw_max) plain_len = data.pw_max;
1946 }
1947 else if (data.attack_mode == ATTACK_MODE_COMBI)
1948 {
1949 u64 gidd = gidvid;
1950 u64 gidm = 0;
1951
1952 pw_t pw;
1953
1954 gidd_to_pw_t (device_param, gidd, &pw);
1955
1956 for (int i = 0, j = gidm; i < 16; i++, j++)
1957 {
1958 plain_buf[i] = pw.i[j];
1959 }
1960
1961 plain_len = pw.pw_len;
1962
1963 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1964 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1965
1966 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1967 {
1968 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1969 }
1970 else
1971 {
1972 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1973
1974 memcpy (plain_ptr, comb_buf, comb_len);
1975 }
1976
1977 plain_len += comb_len;
1978
1979 crackpos += gidvid;
1980 crackpos *= data.combs_cnt;
1981 crackpos += device_param->innerloop_pos + il_pos;
1982
1983 if (data.pw_max != PW_DICTMAX1)
1984 {
1985 if (plain_len > data.pw_max) plain_len = data.pw_max;
1986 }
1987 }
1988 else if (data.attack_mode == ATTACK_MODE_BF)
1989 {
1990 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1991 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1992
1993 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1994 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1995
1996 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1997 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1998
1999 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2000 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2001
2002 plain_len = data.css_cnt;
2003
2004 crackpos += gidvid;
2005 crackpos *= data.bfs_cnt;
2006 crackpos += device_param->innerloop_pos + il_pos;
2007 }
2008 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2009 {
2010 u64 gidd = gidvid;
2011 u64 gidm = 0;
2012
2013 pw_t pw;
2014
2015 gidd_to_pw_t (device_param, gidd, &pw);
2016
2017 for (int i = 0, j = gidm; i < 16; i++, j++)
2018 {
2019 plain_buf[i] = pw.i[j];
2020 }
2021
2022 plain_len = pw.pw_len;
2023
2024 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2025
2026 uint start = 0;
2027 uint stop = device_param->kernel_params_mp_buf32[4];
2028
2029 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2030
2031 plain_len += start + stop;
2032
2033 crackpos += gidvid;
2034 crackpos *= data.combs_cnt;
2035 crackpos += device_param->innerloop_pos + il_pos;
2036
2037 if (data.pw_max != PW_DICTMAX1)
2038 {
2039 if (plain_len > data.pw_max) plain_len = data.pw_max;
2040 }
2041 }
2042 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2043 {
2044 u64 gidd = gidvid;
2045 u64 gidm = 0;
2046
2047 pw_t pw;
2048
2049 gidd_to_pw_t (device_param, gidd, &pw);
2050
2051 for (int i = 0, j = gidm; i < 16; i++, j++)
2052 {
2053 plain_buf[i] = pw.i[j];
2054 }
2055
2056 plain_len = pw.pw_len;
2057
2058 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2059
2060 uint start = 0;
2061 uint stop = device_param->kernel_params_mp_buf32[4];
2062
2063 memmove (plain_ptr + stop, plain_ptr, plain_len);
2064
2065 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2066
2067 plain_len += start + stop;
2068
2069 crackpos += gidvid;
2070 crackpos *= data.combs_cnt;
2071 crackpos += device_param->innerloop_pos + il_pos;
2072
2073 if (data.pw_max != PW_DICTMAX1)
2074 {
2075 if (plain_len > data.pw_max) plain_len = data.pw_max;
2076 }
2077 }
2078
2079 if (data.attack_mode == ATTACK_MODE_BF)
2080 {
2081 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2082 {
2083 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2084 {
2085 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2086 {
2087 plain_len = plain_len - data.salts_buf[0].salt_len;
2088 }
2089 }
2090
2091 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2092 {
2093 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2094 {
2095 plain_ptr[j] = plain_ptr[i];
2096 }
2097
2098 plain_len = plain_len / 2;
2099 }
2100 }
2101 }
2102
2103 // if enabled, update also the potfile
2104
2105 if (pot_fp)
2106 {
2107 lock_file (pot_fp);
2108
2109 fprintf (pot_fp, "%s:", out_buf);
2110
2111 format_plain (pot_fp, plain_ptr, plain_len, 1);
2112
2113 fputc ('\n', pot_fp);
2114
2115 fflush (pot_fp);
2116
2117 unlock_file (pot_fp);
2118 }
2119
2120 // outfile
2121
2122 FILE *out_fp = NULL;
2123
2124 if (outfile != NULL)
2125 {
2126 if ((out_fp = fopen (outfile, "ab")) == NULL)
2127 {
2128 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2129
2130 out_fp = stdout;
2131 }
2132 lock_file (out_fp);
2133 }
2134 else
2135 {
2136 out_fp = stdout;
2137
2138 if (quiet == 0) clear_prompt ();
2139 }
2140
2141 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2142
2143 if (outfile != NULL)
2144 {
2145 if (out_fp != stdout)
2146 {
2147 fclose (out_fp);
2148 }
2149 }
2150 else
2151 {
2152 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2153 {
2154 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2155 {
2156 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2157 if (quiet == 0) fflush (stdout);
2158 }
2159 }
2160 }
2161
2162 // loopback
2163
2164 if (loopback)
2165 {
2166 char *loopback_file = data.loopback_file;
2167
2168 FILE *fb_fp = NULL;
2169
2170 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2171 {
2172 lock_file (fb_fp);
2173
2174 format_plain (fb_fp, plain_ptr, plain_len, 1);
2175
2176 fputc ('\n', fb_fp);
2177
2178 fclose (fb_fp);
2179 }
2180 }
2181
2182 // (rule) debug mode
2183
2184 // the next check implies that:
2185 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2186 // - debug_mode > 0
2187
2188 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2189 {
2190 if (debug_rule_len < 0) debug_rule_len = 0;
2191
2192 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2193
2194 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2195
2196 if ((quiet == 0) && (debug_file == NULL))
2197 {
2198 fprintf (stdout, "%s", PROMPT);
2199 fflush (stdout);
2200 }
2201 }
2202 }
2203
2204 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2205 {
2206 salt_t *salt_buf = &data.salts_buf[salt_pos];
2207
2208 int found = 0;
2209
2210 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2211
2212 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2213
2214 if (found == 1)
2215 {
2216 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2217
2218 log_info_nn ("");
2219
2220 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2221
2222 uint cpt_cracked = 0;
2223
2224 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2225 {
2226 uint idx = salt_buf->digests_offset + digest_pos;
2227
2228 if (data.digests_shown_tmp[idx] == 0) continue;
2229
2230 if (data.digests_shown[idx] == 1) continue;
2231
2232 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2233 {
2234 data.digests_shown[idx] = 1;
2235
2236 data.digests_done++;
2237
2238 cpt_cracked++;
2239
2240 salt_buf->digests_done++;
2241
2242 if (salt_buf->digests_done == salt_buf->digests_cnt)
2243 {
2244 data.salts_shown[salt_pos] = 1;
2245
2246 data.salts_done++;
2247 }
2248 }
2249
2250 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2251
2252 check_hash (device_param, salt_pos, digest_pos);
2253 }
2254
2255 if (cpt_cracked > 0)
2256 {
2257 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2258 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2259
2260 data.cpt_pos++;
2261
2262 data.cpt_total += cpt_cracked;
2263
2264 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2265 }
2266
2267 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2268 {
2269 // we need to reset cracked state on the device
2270 // otherwise host thinks again and again the hash was cracked
2271 // and returns invalid password each time
2272
2273 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2274
2275 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2276 }
2277
2278 memset (device_param->result, 0, device_param->size_results);
2279
2280 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2281 }
2282 }
2283
2284 static void save_hash ()
2285 {
2286 char *hashfile = data.hashfile;
2287
2288 char new_hashfile[256] = { 0 };
2289 char old_hashfile[256] = { 0 };
2290
2291 snprintf (new_hashfile, 255, "%s.new", hashfile);
2292 snprintf (old_hashfile, 255, "%s.old", hashfile);
2293
2294 unlink (new_hashfile);
2295
2296 char separator = data.separator;
2297
2298 FILE *fp = fopen (new_hashfile, "wb");
2299
2300 if (fp == NULL)
2301 {
2302 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2303
2304 exit (-1);
2305 }
2306
2307 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2308 {
2309 if (data.salts_shown[salt_pos] == 1) continue;
2310
2311 salt_t *salt_buf = &data.salts_buf[salt_pos];
2312
2313 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2314 {
2315 uint idx = salt_buf->digests_offset + digest_pos;
2316
2317 if (data.digests_shown[idx] == 1) continue;
2318
2319 if (data.hash_mode != 2500)
2320 {
2321 char out_buf[4096] = { 0 };
2322
2323 if (data.username == 1)
2324 {
2325 user_t *user = data.hash_info[idx]->user;
2326
2327 uint i;
2328
2329 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2330
2331 fputc (separator, fp);
2332 }
2333
2334 ascii_digest (out_buf, salt_pos, digest_pos);
2335
2336 fputs (out_buf, fp);
2337
2338 log_out (fp, "");
2339 }
2340 else
2341 {
2342 hccap_t hccap;
2343
2344 to_hccap_t (&hccap, salt_pos, digest_pos);
2345
2346 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2347 }
2348 }
2349 }
2350
2351 fflush (fp);
2352
2353 fclose (fp);
2354
2355 unlink (old_hashfile);
2356
2357 if (rename (hashfile, old_hashfile) != 0)
2358 {
2359 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2360
2361 exit (-1);
2362 }
2363
2364 unlink (hashfile);
2365
2366 if (rename (new_hashfile, hashfile) != 0)
2367 {
2368 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2369
2370 exit (-1);
2371 }
2372
2373 unlink (old_hashfile);
2374 }
2375
2376 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2377 {
2378 // function called only in case kernel_power_all > words_left
2379
2380 float kernel_power_div = (float) (total_left) / kernel_power_all;
2381
2382 kernel_power_div += kernel_power_div / 100;
2383
2384 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2385
2386 while (kernel_power_new < total_left)
2387 {
2388 kernel_power_div += kernel_power_div / 100;
2389
2390 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2391 }
2392
2393 if (data.quiet == 0)
2394 {
2395 clear_prompt ();
2396
2397 log_info ("");
2398
2399 log_info ("INFO: approaching final keyspace, workload adjusted");
2400
2401 log_info ("");
2402
2403 fprintf (stdout, "%s", PROMPT);
2404
2405 fflush (stdout);
2406 }
2407
2408 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2409
2410 return kernel_power_div;
2411 }
2412
2413 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2414 {
2415 uint num_elements = num;
2416
2417 device_param->kernel_params_buf32[30] = data.combs_mode;
2418 device_param->kernel_params_buf32[31] = num;
2419
2420 uint kernel_threads = device_param->kernel_threads;
2421
2422 while (num_elements % kernel_threads) num_elements++;
2423
2424 cl_kernel kernel = NULL;
2425
2426 switch (kern_run)
2427 {
2428 case KERN_RUN_1: kernel = device_param->kernel1; break;
2429 case KERN_RUN_12: kernel = device_param->kernel12; break;
2430 case KERN_RUN_2: kernel = device_param->kernel2; break;
2431 case KERN_RUN_23: kernel = device_param->kernel23; break;
2432 case KERN_RUN_3: kernel = device_param->kernel3; break;
2433 }
2434
2435 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2436 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2437 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2438 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2439 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2440 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2441 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2442 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2443 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2444 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2445 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2446
2447 hc_timer_t timer;
2448
2449 hc_timer_set (&timer);
2450
2451 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2452 {
2453 const size_t global_work_size[3] = { num_elements, 32, 1 };
2454 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2455
2456 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2457 }
2458 else
2459 {
2460 size_t workgroup_size = 0;
2461
2462 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2463
2464 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2465
2466 const size_t global_work_size[3] = { num_elements, 1, 1 };
2467 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2468
2469 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2470 }
2471
2472 hc_clFlush (data.ocl, device_param->command_queue);
2473
2474 hc_clFinish (data.ocl, device_param->command_queue);
2475
2476 if (event_update)
2477 {
2478 float exec_time;
2479
2480 hc_timer_get (timer, exec_time);
2481
2482 uint exec_pos = device_param->exec_pos;
2483
2484 device_param->exec_ms[exec_pos] = exec_time;
2485
2486 exec_pos++;
2487
2488 if (exec_pos == EXEC_CACHE)
2489 {
2490 exec_pos = 0;
2491 }
2492
2493 device_param->exec_pos = exec_pos;
2494 }
2495 }
2496
2497 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2498 {
2499 uint num_elements = num;
2500
2501 switch (kern_run)
2502 {
2503 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2504 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2505 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2506 }
2507
2508 // causes problems with special threads like in bcrypt
2509 // const uint kernel_threads = device_param->kernel_threads;
2510
2511 uint kernel_threads = KERNEL_THREADS;
2512
2513 while (num_elements % kernel_threads) num_elements++;
2514
2515 cl_kernel kernel = NULL;
2516
2517 switch (kern_run)
2518 {
2519 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2520 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2521 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2522 }
2523
2524 switch (kern_run)
2525 {
2526 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2527 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2528 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2529 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2530 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2531 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2532 break;
2533 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2534 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2535 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2536 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2537 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2538 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2539 break;
2540 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2541 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2542 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2543 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2544 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2545 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2546 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2547 break;
2548 }
2549
2550 size_t workgroup_size = 0;
2551 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
2552 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2553
2554 const size_t global_work_size[3] = { num_elements, 1, 1 };
2555 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2556
2557 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2558
2559 hc_clFlush (data.ocl, device_param->command_queue);
2560
2561 hc_clFinish (data.ocl, device_param->command_queue);
2562 }
2563
2564 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2565 {
2566 uint num_elements = num;
2567
2568 uint kernel_threads = device_param->kernel_threads;
2569
2570 while (num_elements % kernel_threads) num_elements++;
2571
2572 cl_kernel kernel = device_param->kernel_tb;
2573
2574 size_t workgroup_size = 0;
2575 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2576 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2577
2578 const size_t global_work_size[3] = { num_elements, 1, 1 };
2579 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2580
2581 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2582
2583 hc_clFlush (data.ocl, device_param->command_queue);
2584
2585 hc_clFinish (data.ocl, device_param->command_queue);
2586 }
2587
2588 static void run_kernel_tm (hc_device_param_t *device_param)
2589 {
2590 const uint num_elements = 1024; // fixed
2591
2592 uint kernel_threads = 32;
2593
2594 cl_kernel kernel = device_param->kernel_tm;
2595
2596 size_t workgroup_size = 0;
2597 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2598 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2599
2600 const size_t global_work_size[3] = { num_elements, 1, 1 };
2601 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2602
2603 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2604
2605 hc_clFlush (data.ocl, device_param->command_queue);
2606
2607 hc_clFinish (data.ocl, device_param->command_queue);
2608 }
2609
2610 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2611 {
2612 uint num_elements = num;
2613
2614 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2615 device_param->kernel_params_amp_buf32[6] = num_elements;
2616
2617 // causes problems with special threads like in bcrypt
2618 // const uint kernel_threads = device_param->kernel_threads;
2619
2620 uint kernel_threads = KERNEL_THREADS;
2621
2622 while (num_elements % kernel_threads) num_elements++;
2623
2624 cl_kernel kernel = device_param->kernel_amp;
2625
2626 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2627 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2628
2629 size_t workgroup_size = 0;
2630 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2631 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2632
2633 const size_t global_work_size[3] = { num_elements, 1, 1 };
2634 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2635
2636 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2637
2638 hc_clFlush (data.ocl, device_param->command_queue);
2639
2640 hc_clFinish (data.ocl, device_param->command_queue);
2641 }
2642
2643 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2644 {
2645 int rc = -1;
2646
2647 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2648 {
2649 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2650
2651 const cl_uchar zero = 0;
2652
2653 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2654 }
2655
2656 if (rc != 0)
2657 {
2658 // NOTE: clEnqueueFillBuffer () always fails with -59
2659 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2660 // How's that possible, OpenCL 1.2 support is advertised??
2661 // We need to workaround...
2662
2663 #define FILLSZ 0x100000
2664
2665 char *tmp = (char *) mymalloc (FILLSZ);
2666
2667 for (uint i = 0; i < size; i += FILLSZ)
2668 {
2669 const int left = size - i;
2670
2671 const int fillsz = MIN (FILLSZ, left);
2672
2673 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2674 }
2675
2676 myfree (tmp);
2677 }
2678 }
2679
2680 static void choose_kernel (hc_device_param_t *device_param, const uint attack_exec, const uint attack_mode, const uint opts_type, const salt_t *salt_buf, const uint highest_pw_len, const uint pws_cnt)
2681 {
2682 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2683 {
2684 if (attack_mode == ATTACK_MODE_BF)
2685 {
2686 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2687 {
2688 const uint size_tm = 32 * sizeof (bs_word_t);
2689
2690 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2691
2692 run_kernel_tm (device_param);
2693
2694 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2695 }
2696 }
2697
2698 if (highest_pw_len < 16)
2699 {
2700 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2701 }
2702 else if (highest_pw_len < 32)
2703 {
2704 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2705 }
2706 else
2707 {
2708 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2709 }
2710 }
2711 else
2712 {
2713 run_kernel_amp (device_param, pws_cnt);
2714
2715 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2716
2717 if (opts_type & OPTS_TYPE_HOOK12)
2718 {
2719 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2720 }
2721
2722 uint iter = salt_buf->salt_iter;
2723
2724 uint loop_step = device_param->kernel_loops;
2725
2726 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2727 {
2728 uint loop_left = iter - loop_pos;
2729
2730 loop_left = MIN (loop_left, loop_step);
2731
2732 device_param->kernel_params_buf32[25] = loop_pos;
2733 device_param->kernel_params_buf32[26] = loop_left;
2734
2735 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2736
2737 if (data.devices_status == STATUS_CRACKED) break;
2738 if (data.devices_status == STATUS_ABORTED) break;
2739 if (data.devices_status == STATUS_QUIT) break;
2740 }
2741
2742 if (opts_type & OPTS_TYPE_HOOK23)
2743 {
2744 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2745
2746 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2747
2748 // do something with data
2749
2750 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2751 }
2752
2753 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2754 }
2755 }
2756
2757 static int run_rule_engine (const int rule_len, const char *rule_buf)
2758 {
2759 if (rule_len == 0)
2760 {
2761 return 0;
2762 }
2763 else if (rule_len == 1)
2764 {
2765 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2766 }
2767
2768 return 1;
2769 }
2770
2771 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2772 {
2773 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2774 {
2775 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2776 }
2777 else if (data.attack_kern == ATTACK_KERN_COMBI)
2778 {
2779 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2780 {
2781 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2782 {
2783 for (u32 i = 0; i < pws_cnt; i++)
2784 {
2785 const u32 pw_len = device_param->pws_buf[i].pw_len;
2786
2787 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2788
2789 ptr[pw_len] = 0x01;
2790 }
2791 }
2792 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2793 {
2794 for (u32 i = 0; i < pws_cnt; i++)
2795 {
2796 const u32 pw_len = device_param->pws_buf[i].pw_len;
2797
2798 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2799
2800 ptr[pw_len] = 0x80;
2801 }
2802 }
2803 }
2804
2805 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2806 }
2807 else if (data.attack_kern == ATTACK_KERN_BF)
2808 {
2809 const u64 off = device_param->words_off;
2810
2811 device_param->kernel_params_mp_l_buf64[3] = off;
2812
2813 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2814 }
2815 }
2816
2817 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops, const int repeat)
2818 {
2819 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2820
2821 device_param->kernel_params_buf32[26] = kernel_loops;
2822 device_param->kernel_params_buf32[27] = kernel_loops;
2823
2824 // init some fake words
2825
2826 for (u32 i = 0; i < kernel_power; i++)
2827 {
2828 device_param->pws_buf[i].i[1] = 0x01234567;
2829 device_param->pws_buf[i].pw_len = i & 7;
2830 }
2831
2832 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);
2833
2834 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2835 {
2836 run_kernel_amp (device_param, kernel_power);
2837 }
2838
2839 // caching run
2840
2841 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2842 {
2843 run_kernel (KERN_RUN_1, device_param, kernel_power, false);
2844 }
2845 else
2846 {
2847 run_kernel (KERN_RUN_2, device_param, kernel_power, false);
2848 }
2849
2850 // now user repeats
2851
2852 for (int i = 0; i < repeat; i++)
2853 {
2854 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2855 {
2856 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2857 }
2858 else
2859 {
2860 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2861 }
2862 }
2863
2864 const double exec_ms_prev = get_avg_exec_time (device_param, repeat);
2865
2866 // reset fake words
2867
2868 memset (device_param->pws_buf, 0, kernel_power * sizeof (pw_t));
2869
2870 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);
2871 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);
2872
2873 return exec_ms_prev;
2874 }
2875
2876 static void autotune (hc_device_param_t *device_param)
2877 {
2878 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2879
2880 const u32 kernel_accel_min = device_param->kernel_accel_min;
2881 const u32 kernel_accel_max = device_param->kernel_accel_max;
2882
2883 const u32 kernel_loops_min = device_param->kernel_loops_min;
2884 const u32 kernel_loops_max = device_param->kernel_loops_max;
2885
2886 u32 kernel_accel = kernel_accel_min;
2887 u32 kernel_loops = kernel_loops_min;
2888
2889 // steps
2890
2891 #define STEPS_CNT 10
2892
2893 #define STEPS_ACCEL_CNT (STEPS_CNT + 2)
2894 #define STEPS_LOOPS_CNT (STEPS_CNT + 2)
2895
2896 u32 steps_accel[STEPS_ACCEL_CNT];
2897 u32 steps_loops[STEPS_LOOPS_CNT];
2898
2899 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2900 {
2901 steps_accel[i] = 1 << i;
2902 }
2903
2904 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2905 {
2906 steps_loops[i] = 1 << i;
2907 }
2908
2909 steps_accel[STEPS_CNT + 0] = kernel_accel_min;
2910 steps_accel[STEPS_CNT + 1] = kernel_accel_max;
2911
2912 steps_loops[STEPS_CNT + 0] = kernel_loops_min;
2913 steps_loops[STEPS_CNT + 1] = kernel_loops_max;
2914
2915 qsort (steps_accel, STEPS_ACCEL_CNT, sizeof (u32), sort_by_u32);
2916 qsort (steps_loops, STEPS_LOOPS_CNT, sizeof (u32), sort_by_u32);
2917
2918 // find out highest kernel-loops that stays below target_ms, we can use it later for multiplication as this is a linear function
2919
2920 u32 kernel_loops_tmp;
2921
2922 for (kernel_loops_tmp = kernel_loops_max; kernel_loops_tmp > kernel_loops_min; kernel_loops_tmp >>= 1)
2923 {
2924 const double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops_tmp, 1);
2925
2926 if (exec_ms < target_ms) break;
2927 }
2928
2929 // kernel-accel
2930
2931 if (kernel_accel_min < kernel_accel_max)
2932 {
2933 double e_best = 0;
2934
2935 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2936 {
2937 const u32 kernel_accel_try = steps_accel[i];
2938
2939 if (kernel_accel_try < kernel_accel_min) continue;
2940 if (kernel_accel_try > kernel_accel_max) break;
2941
2942 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_tmp, 1);
2943
2944 if (exec_ms > target_ms) break;
2945
2946 const double e = kernel_accel_try / exec_ms;
2947
2948 if (e > e_best)
2949 {
2950 kernel_accel = kernel_accel_try;
2951
2952 e_best = e;
2953 }
2954 }
2955 }
2956
2957 // kernel-loops final
2958
2959 if (kernel_loops_min < kernel_loops_max)
2960 {
2961 double e_best = 0;
2962
2963 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2964 {
2965 const u32 kernel_loops_try = steps_loops[i];
2966
2967 if (kernel_loops_try < kernel_loops_min) continue;
2968 if (kernel_loops_try > kernel_loops_max) break;
2969
2970 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops_try, 1);
2971
2972 if (exec_ms > target_ms) break;
2973
2974 const double e = kernel_loops_try / exec_ms;
2975
2976 if (e > e_best)
2977 {
2978 kernel_loops = kernel_loops_try;
2979
2980 e_best = e;
2981 }
2982 }
2983 }
2984
2985 // final balance
2986
2987 u32 kernel_accel_best = kernel_accel;
2988 u32 kernel_loops_best = kernel_loops;
2989
2990 u32 exec_best = -1;
2991
2992 // reset
2993
2994 if (kernel_accel_min < kernel_accel_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_min) break;
3005 if (kernel_loops_try > kernel_loops_max) 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
3020
3021 if (kernel_loops_min < kernel_loops_max)
3022 {
3023 u32 kernel_accel_try = kernel_accel;
3024 u32 kernel_loops_try = kernel_loops;
3025
3026 for (int i = 0; i < 2; i++)
3027 {
3028 kernel_accel_try <<= 1;
3029 kernel_loops_try >>= 1;
3030
3031 if (kernel_accel_try > kernel_accel_max) break;
3032 if (kernel_loops_try < kernel_loops_min) break;
3033
3034 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
3035
3036 if (exec_ms < exec_best)
3037 {
3038 kernel_accel_best = kernel_accel_try;
3039 kernel_loops_best = kernel_loops_try;
3040
3041 exec_best = exec_ms;
3042 }
3043 }
3044 }
3045
3046 // reset timer
3047
3048 device_param->exec_pos = 0;
3049
3050 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3051
3052 // store
3053
3054 kernel_accel = kernel_accel_best;
3055 kernel_loops = kernel_loops_best;
3056
3057 device_param->kernel_accel = kernel_accel;
3058 device_param->kernel_loops = kernel_loops;
3059
3060 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3061
3062 device_param->kernel_power = kernel_power;
3063
3064 if (data.quiet == 0) log_info ("Device #%u: autotuned kernel-accel to %u", device_param->device_id + 1, kernel_accel);
3065 if (data.quiet == 0) log_info ("Device #%u: autotuned kernel-loops to %u", device_param->device_id + 1, kernel_loops);
3066 if (data.quiet == 0) log_info ("");
3067 }
3068
3069 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3070 {
3071 // init speed timer
3072
3073 uint speed_pos = device_param->speed_pos;
3074
3075 #ifdef _POSIX
3076 if (device_param->timer_speed.tv_sec == 0)
3077 {
3078 hc_timer_set (&device_param->timer_speed);
3079 }
3080 #endif
3081
3082 #ifdef _WIN
3083 if (device_param->timer_speed.QuadPart == 0)
3084 {
3085 hc_timer_set (&device_param->timer_speed);
3086 }
3087 #endif
3088
3089 // find higest password length, this is for optimization stuff
3090
3091 uint highest_pw_len = 0;
3092
3093 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3094 {
3095 }
3096 else if (data.attack_kern == ATTACK_KERN_COMBI)
3097 {
3098 }
3099 else if (data.attack_kern == ATTACK_KERN_BF)
3100 {
3101 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3102 + device_param->kernel_params_mp_l_buf32[5];
3103 }
3104
3105 // bitslice optimization stuff
3106
3107 if (data.attack_mode == ATTACK_MODE_BF)
3108 {
3109 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
3110 {
3111 run_kernel_tb (device_param, pws_cnt);
3112 }
3113 }
3114
3115 // iteration type
3116
3117 uint innerloop_step = 0;
3118 uint innerloop_cnt = 0;
3119
3120 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3121 else innerloop_step = 1;
3122
3123 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3124 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3125 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3126
3127 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3128
3129 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3130 {
3131 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3132
3133 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3134
3135 if (data.devices_status == STATUS_CRACKED) break;
3136 if (data.devices_status == STATUS_ABORTED) break;
3137 if (data.devices_status == STATUS_QUIT) break;
3138 if (data.devices_status == STATUS_BYPASS) break;
3139
3140 if (data.salts_shown[salt_pos] == 1) continue;
3141
3142 salt_t *salt_buf = &data.salts_buf[salt_pos];
3143
3144 device_param->kernel_params_buf32[24] = salt_pos;
3145 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3146 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3147
3148 FILE *combs_fp = device_param->combs_fp;
3149
3150 if (data.attack_mode == ATTACK_MODE_COMBI)
3151 {
3152 rewind (combs_fp);
3153 }
3154
3155 // innerloops
3156
3157 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3158 {
3159 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3160
3161 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3162
3163 if (data.devices_status == STATUS_CRACKED) break;
3164 if (data.devices_status == STATUS_ABORTED) break;
3165 if (data.devices_status == STATUS_QUIT) break;
3166 if (data.devices_status == STATUS_BYPASS) break;
3167
3168 uint innerloop_left = innerloop_cnt - innerloop_pos;
3169
3170 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3171
3172 device_param->innerloop_pos = innerloop_pos;
3173 device_param->innerloop_left = innerloop_left;
3174
3175 device_param->kernel_params_buf32[27] = innerloop_left;
3176
3177 // i think we can get rid of this
3178 if (innerloop_left == 0)
3179 {
3180 puts ("bug, how should this happen????\n");
3181
3182 continue;
3183 }
3184
3185 // initialize amplifiers
3186
3187 if (data.attack_mode == ATTACK_MODE_COMBI)
3188 {
3189 char line_buf[BUFSIZ] = { 0 };
3190
3191 uint i = 0;
3192
3193 while (i < innerloop_left)
3194 {
3195 if (feof (combs_fp)) break;
3196
3197 int line_len = fgetl (combs_fp, line_buf);
3198
3199 if (line_len >= PW_MAX1) continue;
3200
3201 line_len = convert_from_hex (line_buf, line_len);
3202
3203 char *line_buf_new = line_buf;
3204
3205 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3206 {
3207 char rule_buf_out[BLOCK_SIZE] = { 0 };
3208
3209 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3210
3211 if (rule_len_out < 0)
3212 {
3213 data.words_progress_rejected[salt_pos] += pws_cnt;
3214
3215 continue;
3216 }
3217
3218 line_len = rule_len_out;
3219
3220 line_buf_new = rule_buf_out;
3221 }
3222
3223 line_len = MIN (line_len, PW_DICTMAX);
3224
3225 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3226
3227 memcpy (ptr, line_buf_new, line_len);
3228
3229 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3230
3231 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3232 {
3233 uppercase (ptr, line_len);
3234 }
3235
3236 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3237 {
3238 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3239 {
3240 ptr[line_len] = 0x80;
3241 }
3242
3243 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3244 {
3245 ptr[line_len] = 0x01;
3246 }
3247 }
3248
3249 device_param->combs_buf[i].pw_len = line_len;
3250
3251 i++;
3252 }
3253
3254 for (uint j = i; j < innerloop_left; j++)
3255 {
3256 device_param->combs_buf[j].i[0] = 0;
3257 device_param->combs_buf[j].i[1] = 0;
3258 device_param->combs_buf[j].i[2] = 0;
3259 device_param->combs_buf[j].i[3] = 0;
3260 device_param->combs_buf[j].i[4] = 0;
3261 device_param->combs_buf[j].i[5] = 0;
3262 device_param->combs_buf[j].i[6] = 0;
3263 device_param->combs_buf[j].i[7] = 0;
3264
3265 device_param->combs_buf[j].pw_len = 0;
3266 }
3267
3268 innerloop_left = i;
3269 }
3270 else if (data.attack_mode == ATTACK_MODE_BF)
3271 {
3272 u64 off = innerloop_pos;
3273
3274 device_param->kernel_params_mp_r_buf64[3] = off;
3275
3276 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3277 }
3278 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3279 {
3280 u64 off = innerloop_pos;
3281
3282 device_param->kernel_params_mp_buf64[3] = off;
3283
3284 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3285 }
3286 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3287 {
3288 u64 off = innerloop_pos;
3289
3290 device_param->kernel_params_mp_buf64[3] = off;
3291
3292 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3293 }
3294
3295 // copy amplifiers
3296
3297 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3298 {
3299 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);
3300 }
3301 else if (data.attack_mode == ATTACK_MODE_COMBI)
3302 {
3303 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);
3304 }
3305 else if (data.attack_mode == ATTACK_MODE_BF)
3306 {
3307 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);
3308 }
3309 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3310 {
3311 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);
3312 }
3313 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3314 {
3315 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);
3316 }
3317
3318 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3319
3320 if (data.benchmark == 1)
3321 {
3322 for (u32 i = 0; i < data.benchmark_repeats; i++)
3323 {
3324 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3325 }
3326 }
3327
3328 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3329
3330 if (data.devices_status == STATUS_CRACKED) break;
3331 if (data.devices_status == STATUS_ABORTED) break;
3332 if (data.devices_status == STATUS_QUIT) break;
3333
3334 /**
3335 * result
3336 */
3337
3338 hc_thread_mutex_lock (mux_display);
3339
3340 check_cracked (device_param, salt_pos);
3341
3342 hc_thread_mutex_unlock (mux_display);
3343
3344 /**
3345 * progress
3346 */
3347
3348 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3349
3350 if (data.benchmark == 1)
3351 {
3352 perf_sum_all = (perf_sum_all * data.benchmark_repeats) + perf_sum_all;
3353 }
3354
3355 hc_thread_mutex_lock (mux_counter);
3356
3357 data.words_progress_done[salt_pos] += perf_sum_all;
3358
3359 hc_thread_mutex_unlock (mux_counter);
3360
3361 /**
3362 * speed
3363 */
3364
3365 float speed_ms;
3366
3367 hc_timer_get (device_param->timer_speed, speed_ms);
3368
3369 hc_timer_set (&device_param->timer_speed);
3370
3371 hc_thread_mutex_lock (mux_display);
3372
3373 device_param->speed_cnt[speed_pos] = perf_sum_all;
3374
3375 device_param->speed_ms[speed_pos] = speed_ms;
3376
3377 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3378
3379 hc_thread_mutex_unlock (mux_display);
3380
3381 speed_pos++;
3382
3383 if (speed_pos == SPEED_CACHE)
3384 {
3385 speed_pos = 0;
3386 }
3387
3388 /**
3389 * benchmark
3390 */
3391
3392 if (data.benchmark == 1) break;
3393 }
3394 }
3395
3396 device_param->speed_pos = speed_pos;
3397 }
3398
3399 static void load_segment (wl_data_t *wl_data, FILE *fd)
3400 {
3401 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3402
3403 wl_data->pos = 0;
3404
3405 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3406
3407 wl_data->buf[wl_data->cnt] = 0;
3408
3409 if (wl_data->cnt == 0) return;
3410
3411 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3412
3413 while (!feof (fd))
3414 {
3415 if (wl_data->cnt == wl_data->avail)
3416 {
3417 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3418
3419 wl_data->avail += wl_data->incr;
3420 }
3421
3422 const int c = fgetc (fd);
3423
3424 if (c == EOF) break;
3425
3426 wl_data->buf[wl_data->cnt] = (char) c;
3427
3428 wl_data->cnt++;
3429
3430 if (c == '\n') break;
3431 }
3432
3433 // ensure stream ends with a newline
3434
3435 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3436 {
3437 wl_data->cnt++;
3438
3439 wl_data->buf[wl_data->cnt - 1] = '\n';
3440 }
3441
3442 return;
3443 }
3444
3445 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3446 {
3447 char *ptr = buf;
3448
3449 for (u32 i = 0; i < sz; i++, ptr++)
3450 {
3451 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3452
3453 if (i == 7)
3454 {
3455 *off = i;
3456 *len = i;
3457
3458 return;
3459 }
3460
3461 if (*ptr != '\n') continue;
3462
3463 *off = i + 1;
3464
3465 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3466
3467 *len = i;
3468
3469 return;
3470 }
3471
3472 *off = sz;
3473 *len = sz;
3474 }
3475
3476 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3477 {
3478 char *ptr = buf;
3479
3480 for (u32 i = 0; i < sz; i++, ptr++)
3481 {
3482 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3483
3484 if (*ptr != '\n') continue;
3485
3486 *off = i + 1;
3487
3488 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3489
3490 *len = i;
3491
3492 return;
3493 }
3494
3495 *off = sz;
3496 *len = sz;
3497 }
3498
3499 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3500 {
3501 char *ptr = buf;
3502
3503 for (u32 i = 0; i < sz; i++, ptr++)
3504 {
3505 if (*ptr != '\n') continue;
3506
3507 *off = i + 1;
3508
3509 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3510
3511 *len = i;
3512
3513 return;
3514 }
3515
3516 *off = sz;
3517 *len = sz;
3518 }
3519
3520 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3521 {
3522 while (wl_data->pos < wl_data->cnt)
3523 {
3524 uint off;
3525 uint len;
3526
3527 char *ptr = wl_data->buf + wl_data->pos;
3528
3529 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3530
3531 wl_data->pos += off;
3532
3533 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3534 {
3535 char rule_buf_out[BLOCK_SIZE] = { 0 };
3536
3537 int rule_len_out = -1;
3538
3539 if (len < BLOCK_SIZE)
3540 {
3541 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3542 }
3543
3544 if (rule_len_out < 0)
3545 {
3546 continue;
3547 }
3548
3549 if (rule_len_out > PW_MAX)
3550 {
3551 continue;
3552 }
3553 }
3554 else
3555 {
3556 if (len > PW_MAX)
3557 {
3558 continue;
3559 }
3560 }
3561
3562 *out_buf = ptr;
3563 *out_len = len;
3564
3565 return;
3566 }
3567
3568 if (feof (fd))
3569 {
3570 fprintf (stderr, "BUG feof()!!\n");
3571
3572 return;
3573 }
3574
3575 load_segment (wl_data, fd);
3576
3577 get_next_word (wl_data, fd, out_buf, out_len);
3578 }
3579
3580 #ifdef _POSIX
3581 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3582 #endif
3583
3584 #ifdef _WIN
3585 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3586 #endif
3587 {
3588 hc_signal (NULL);
3589
3590 dictstat_t d;
3591
3592 d.cnt = 0;
3593
3594 #ifdef _POSIX
3595 fstat (fileno (fd), &d.stat);
3596 #endif
3597
3598 #ifdef _WIN
3599 _fstat64 (fileno (fd), &d.stat);
3600 #endif
3601
3602 d.stat.st_mode = 0;
3603 d.stat.st_nlink = 0;
3604 d.stat.st_uid = 0;
3605 d.stat.st_gid = 0;
3606 d.stat.st_rdev = 0;
3607 d.stat.st_atime = 0;
3608
3609 #ifdef _POSIX
3610 d.stat.st_blksize = 0;
3611 d.stat.st_blocks = 0;
3612 #endif
3613
3614 if (d.stat.st_size == 0) return 0;
3615
3616 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3617
3618 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3619 {
3620 if (d_cache)
3621 {
3622 u64 cnt = d_cache->cnt;
3623
3624 u64 keyspace = cnt;
3625
3626 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3627 {
3628 keyspace *= data.kernel_rules_cnt;
3629 }
3630 else if (data.attack_kern == ATTACK_KERN_COMBI)
3631 {
3632 keyspace *= data.combs_cnt;
3633 }
3634
3635 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);
3636 if (data.quiet == 0) log_info ("");
3637
3638 hc_signal (sigHandler_default);
3639
3640 return (keyspace);
3641 }
3642 }
3643
3644 time_t now = 0;
3645 time_t prev = 0;
3646
3647 u64 comp = 0;
3648 u64 cnt = 0;
3649 u64 cnt2 = 0;
3650
3651 while (!feof (fd))
3652 {
3653 load_segment (wl_data, fd);
3654
3655 comp += wl_data->cnt;
3656
3657 u32 i = 0;
3658
3659 while (i < wl_data->cnt)
3660 {
3661 u32 len;
3662 u32 off;
3663
3664 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3665
3666 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3667 {
3668 char rule_buf_out[BLOCK_SIZE] = { 0 };
3669
3670 int rule_len_out = -1;
3671
3672 if (len < BLOCK_SIZE)
3673 {
3674 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3675 }
3676
3677 if (rule_len_out < 0)
3678 {
3679 len = PW_MAX1;
3680 }
3681 else
3682 {
3683 len = rule_len_out;
3684 }
3685 }
3686
3687 if (len < PW_MAX1)
3688 {
3689 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3690 {
3691 cnt += data.kernel_rules_cnt;
3692 }
3693 else if (data.attack_kern == ATTACK_KERN_COMBI)
3694 {
3695 cnt += data.combs_cnt;
3696 }
3697
3698 d.cnt++;
3699 }
3700
3701 i += off;
3702
3703 cnt2++;
3704 }
3705
3706 time (&now);
3707
3708 if ((now - prev) == 0) continue;
3709
3710 float percent = (float) comp / (float) d.stat.st_size;
3711
3712 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);
3713
3714 time (&prev);
3715 }
3716
3717 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);
3718 if (data.quiet == 0) log_info ("");
3719
3720 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3721
3722 hc_signal (sigHandler_default);
3723
3724 return (cnt);
3725 }
3726
3727 static void *thread_monitor (void *p)
3728 {
3729 uint runtime_check = 0;
3730 uint remove_check = 0;
3731 uint status_check = 0;
3732 uint restore_check = 0;
3733
3734 uint restore_left = data.restore_timer;
3735 uint remove_left = data.remove_timer;
3736 uint status_left = data.status_timer;
3737
3738 #ifdef HAVE_HWMON
3739 uint hwmon_check = 0;
3740
3741 // these variables are mainly used for fan control (AMD only)
3742
3743 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3744
3745 // temperature controller "loopback" values
3746
3747 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3748 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3749
3750 #ifdef HAVE_ADL
3751 int temp_threshold = 1; // degrees celcius
3752
3753 int fan_speed_min = 15; // in percentage
3754 int fan_speed_max = 100;
3755 #endif // HAVE_ADL
3756
3757 time_t last_temp_check_time;
3758 #endif // HAVE_HWMON
3759
3760 uint sleep_time = 1;
3761
3762 if (data.runtime)
3763 {
3764 runtime_check = 1;
3765 }
3766
3767 if (data.restore_timer)
3768 {
3769 restore_check = 1;
3770 }
3771
3772 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3773 {
3774 remove_check = 1;
3775 }
3776
3777 if (data.status == 1)
3778 {
3779 status_check = 1;
3780 }
3781
3782 #ifdef HAVE_HWMON
3783 if (data.gpu_temp_disable == 0)
3784 {
3785 time (&last_temp_check_time);
3786
3787 hwmon_check = 1;
3788 }
3789 #endif
3790
3791 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3792 {
3793 #ifdef HAVE_HWMON
3794 if (hwmon_check == 0)
3795 #endif
3796 return (p);
3797 }
3798
3799 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3800 {
3801 hc_sleep (sleep_time);
3802
3803 if (data.devices_status != STATUS_RUNNING) continue;
3804
3805 #ifdef HAVE_HWMON
3806 if (hwmon_check == 1)
3807 {
3808 hc_thread_mutex_lock (mux_adl);
3809
3810 time_t temp_check_time;
3811
3812 time (&temp_check_time);
3813
3814 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3815
3816 if (Ta == 0) Ta = 1;
3817
3818 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3819 {
3820 hc_device_param_t *device_param = &data.devices_param[device_id];
3821
3822 if (device_param->skipped) continue;
3823
3824 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3825
3826 const int temperature = hm_get_temperature_with_device_id (device_id);
3827
3828 if (temperature > (int) data.gpu_temp_abort)
3829 {
3830 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3831
3832 if (data.devices_status != STATUS_QUIT) myabort ();
3833
3834 break;
3835 }
3836
3837 #ifdef HAVE_ADL
3838 const int gpu_temp_retain = data.gpu_temp_retain;
3839
3840 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3841 {
3842 if (data.hm_device[device_id].fan_supported == 1)
3843 {
3844 int temp_cur = temperature;
3845
3846 int temp_diff_new = gpu_temp_retain - temp_cur;
3847
3848 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3849
3850 // calculate Ta value (time difference in seconds between the last check and this check)
3851
3852 last_temp_check_time = temp_check_time;
3853
3854 float Kp = 1.8;
3855 float Ki = 0.005;
3856 float Kd = 6;
3857
3858 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3859
3860 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);
3861
3862 if (abs (fan_diff_required) >= temp_threshold)
3863 {
3864 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3865
3866 int fan_speed_level = fan_speed_cur;
3867
3868 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3869
3870 int fan_speed_new = fan_speed_level - fan_diff_required;
3871
3872 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3873 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3874
3875 if (fan_speed_new != fan_speed_cur)
3876 {
3877 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3878 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3879
3880 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3881 {
3882 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3883
3884 fan_speed_chgd[device_id] = 1;
3885 }
3886
3887 temp_diff_old[device_id] = temp_diff_new;
3888 }
3889 }
3890 }
3891 }
3892 #endif // HAVE_ADL
3893 }
3894
3895 hc_thread_mutex_unlock (mux_adl);
3896 }
3897 #endif // HAVE_HWMON
3898
3899 if (restore_check == 1)
3900 {
3901 restore_left--;
3902
3903 if (restore_left == 0)
3904 {
3905 if (data.restore_disable == 0) cycle_restore ();
3906
3907 restore_left = data.restore_timer;
3908 }
3909 }
3910
3911 if ((runtime_check == 1) && (data.runtime_start > 0))
3912 {
3913 time_t runtime_cur;
3914
3915 time (&runtime_cur);
3916
3917 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3918
3919 if (runtime_left <= 0)
3920 {
3921 if (data.benchmark == 0)
3922 {
3923 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3924 }
3925
3926 if (data.devices_status != STATUS_QUIT) myabort ();
3927 }
3928 }
3929
3930 if (remove_check == 1)
3931 {
3932 remove_left--;
3933
3934 if (remove_left == 0)
3935 {
3936 if (data.digests_saved != data.digests_done)
3937 {
3938 data.digests_saved = data.digests_done;
3939
3940 save_hash ();
3941 }
3942
3943 remove_left = data.remove_timer;
3944 }
3945 }
3946
3947 if (status_check == 1)
3948 {
3949 status_left--;
3950
3951 if (status_left == 0)
3952 {
3953 hc_thread_mutex_lock (mux_display);
3954
3955 if (data.quiet == 0) clear_prompt ();
3956
3957 if (data.quiet == 0) log_info ("");
3958
3959 status_display ();
3960
3961 if (data.quiet == 0) log_info ("");
3962
3963 hc_thread_mutex_unlock (mux_display);
3964
3965 status_left = data.status_timer;
3966 }
3967 }
3968 }
3969
3970 #ifdef HAVE_HWMON
3971 myfree (fan_speed_chgd);
3972
3973 myfree (temp_diff_old);
3974 myfree (temp_diff_sum);
3975 #endif
3976
3977 p = NULL;
3978
3979 return (p);
3980 }
3981
3982 static void *thread_outfile_remove (void *p)
3983 {
3984 // some hash-dependent constants
3985 char *outfile_dir = data.outfile_check_directory;
3986 uint dgst_size = data.dgst_size;
3987 uint isSalted = data.isSalted;
3988 uint esalt_size = data.esalt_size;
3989 uint hash_mode = data.hash_mode;
3990
3991 uint outfile_check_timer = data.outfile_check_timer;
3992
3993 char separator = data.separator;
3994
3995 // some hash-dependent functions
3996 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3997 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3998
3999 // buffers
4000 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4001
4002 hash_buf.digest = mymalloc (dgst_size);
4003
4004 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4005
4006 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4007
4008 uint digest_buf[64] = { 0 };
4009
4010 outfile_data_t *out_info = NULL;
4011
4012 char **out_files = NULL;
4013
4014 time_t folder_mtime = 0;
4015
4016 int out_cnt = 0;
4017
4018 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4019
4020 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4021 {
4022 hc_sleep (1);
4023
4024 if (data.devices_status != STATUS_RUNNING) continue;
4025
4026 check_left--;
4027
4028 if (check_left == 0)
4029 {
4030 struct stat outfile_check_stat;
4031
4032 if (stat (outfile_dir, &outfile_check_stat) == 0)
4033 {
4034 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4035
4036 if (is_dir == 1)
4037 {
4038 if (outfile_check_stat.st_mtime > folder_mtime)
4039 {
4040 char **out_files_new = scan_directory (outfile_dir);
4041
4042 int out_cnt_new = count_dictionaries (out_files_new);
4043
4044 outfile_data_t *out_info_new = NULL;
4045
4046 if (out_cnt_new > 0)
4047 {
4048 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4049
4050 for (int i = 0; i < out_cnt_new; i++)
4051 {
4052 out_info_new[i].file_name = out_files_new[i];
4053
4054 // check if there are files that we have seen/checked before (and not changed)
4055
4056 for (int j = 0; j < out_cnt; j++)
4057 {
4058 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4059 {
4060 struct stat outfile_stat;
4061
4062 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4063 {
4064 if (outfile_stat.st_ctime == out_info[j].ctime)
4065 {
4066 out_info_new[i].ctime = out_info[j].ctime;
4067 out_info_new[i].seek = out_info[j].seek;
4068 }
4069 }
4070 }
4071 }
4072 }
4073 }
4074
4075 local_free (out_info);
4076 local_free (out_files);
4077
4078 out_files = out_files_new;
4079 out_cnt = out_cnt_new;
4080 out_info = out_info_new;
4081
4082 folder_mtime = outfile_check_stat.st_mtime;
4083 }
4084
4085 for (int j = 0; j < out_cnt; j++)
4086 {
4087 FILE *fp = fopen (out_info[j].file_name, "rb");
4088
4089 if (fp != NULL)
4090 {
4091 //hc_thread_mutex_lock (mux_display);
4092
4093 #ifdef _POSIX
4094 struct stat outfile_stat;
4095
4096 fstat (fileno (fp), &outfile_stat);
4097 #endif
4098
4099 #ifdef _WIN
4100 struct stat64 outfile_stat;
4101
4102 _fstat64 (fileno (fp), &outfile_stat);
4103 #endif
4104
4105 if (outfile_stat.st_ctime > out_info[j].ctime)
4106 {
4107 out_info[j].ctime = outfile_stat.st_ctime;
4108 out_info[j].seek = 0;
4109 }
4110
4111 fseek (fp, out_info[j].seek, SEEK_SET);
4112
4113 while (!feof (fp))
4114 {
4115 char line_buf[BUFSIZ] = { 0 };
4116
4117 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
4118
4119 if (ptr == NULL) break;
4120
4121 int line_len = strlen (line_buf);
4122
4123 if (line_len <= 0) continue;
4124
4125 int iter = MAX_CUT_TRIES;
4126
4127 for (uint i = line_len - 1; i && iter; i--, line_len--)
4128 {
4129 if (line_buf[i] != separator) continue;
4130
4131 int parser_status = PARSER_OK;
4132
4133 if ((hash_mode != 2500) && (hash_mode != 6800))
4134 {
4135 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4136 }
4137
4138 uint found = 0;
4139
4140 if (parser_status == PARSER_OK)
4141 {
4142 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4143 {
4144 if (data.salts_shown[salt_pos] == 1) continue;
4145
4146 salt_t *salt_buf = &data.salts_buf[salt_pos];
4147
4148 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4149 {
4150 uint idx = salt_buf->digests_offset + digest_pos;
4151
4152 if (data.digests_shown[idx] == 1) continue;
4153
4154 uint cracked = 0;
4155
4156 if (hash_mode == 6800)
4157 {
4158 if (i == salt_buf->salt_len)
4159 {
4160 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4161 }
4162 }
4163 else if (hash_mode == 2500)
4164 {
4165 // BSSID : MAC1 : MAC2 (:plain)
4166 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4167 {
4168 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4169
4170 if (!cracked) continue;
4171
4172 // now compare MAC1 and MAC2 too, since we have this additional info
4173 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4174 char *mac2_pos = mac1_pos + 12 + 1;
4175
4176 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4177 wpa_t *wpa = &wpas[salt_pos];
4178
4179 uint pke[25] = { 0 };
4180
4181 char *pke_ptr = (char *) pke;
4182
4183 for (uint i = 0; i < 25; i++)
4184 {
4185 pke[i] = byte_swap_32 (wpa->pke[i]);
4186 }
4187
4188 u8 mac1[6] = { 0 };
4189 u8 mac2[6] = { 0 };
4190
4191 memcpy (mac1, pke_ptr + 23, 6);
4192 memcpy (mac2, pke_ptr + 29, 6);
4193
4194 // compare hex string(s) vs binary MAC address(es)
4195
4196 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4197 {
4198 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4199 {
4200 cracked = 0;
4201 break;
4202 }
4203 }
4204
4205 // early skip ;)
4206 if (!cracked) continue;
4207
4208 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4209 {
4210 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4211 {
4212 cracked = 0;
4213 break;
4214 }
4215 }
4216 }
4217 }
4218 else
4219 {
4220 char *digests_buf_ptr = (char *) data.digests_buf;
4221
4222 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4223
4224 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4225 }
4226
4227 if (cracked == 1)
4228 {
4229 found = 1;
4230
4231 data.digests_shown[idx] = 1;
4232
4233 data.digests_done++;
4234
4235 salt_buf->digests_done++;
4236
4237 if (salt_buf->digests_done == salt_buf->digests_cnt)
4238 {
4239 data.salts_shown[salt_pos] = 1;
4240
4241 data.salts_done++;
4242
4243 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4244 }
4245 }
4246 }
4247
4248 if (data.devices_status == STATUS_CRACKED) break;
4249 }
4250 }
4251
4252 if (found) break;
4253
4254 if (data.devices_status == STATUS_CRACKED) break;
4255
4256 iter--;
4257 }
4258
4259 if (data.devices_status == STATUS_CRACKED) break;
4260 }
4261
4262 out_info[j].seek = ftell (fp);
4263
4264 //hc_thread_mutex_unlock (mux_display);
4265
4266 fclose (fp);
4267 }
4268 }
4269 }
4270 }
4271
4272 check_left = outfile_check_timer;
4273 }
4274 }
4275
4276 if (esalt_size) local_free (hash_buf.esalt);
4277
4278 if (isSalted) local_free (hash_buf.salt);
4279
4280 local_free (hash_buf.digest);
4281
4282 local_free (out_info);
4283
4284 local_free (out_files);
4285
4286 p = NULL;
4287
4288 return (p);
4289 }
4290
4291 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4292 {
4293 if (device_param->pws_cnt < device_param->kernel_power)
4294 {
4295 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4296
4297 memcpy (pw->i, pw_buf, pw_len);
4298
4299 memset (pw->i + pw_len, 0, sizeof (pw->i) - pw_len);
4300
4301 pw->pw_len = pw_len;
4302
4303 device_param->pws_cnt++;
4304 }
4305 else
4306 {
4307 fprintf (stderr, "BUG pw_add()!!\n");
4308
4309 return;
4310 }
4311 }
4312
4313 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4314 {
4315 hc_thread_mutex_lock (mux_dispatcher);
4316
4317 const u64 words_cur = data.words_cur;
4318 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4319
4320 device_param->words_off = words_cur;
4321
4322 const u64 words_left = words_base - words_cur;
4323
4324 if (allow_div)
4325 {
4326 if (data.kernel_power_all > words_left)
4327 {
4328 if (data.kernel_power_div == 0)
4329 {
4330 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4331 }
4332 }
4333
4334 if (data.kernel_power_div)
4335 {
4336 if (device_param->kernel_power == device_param->kernel_power_user)
4337 {
4338 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4339
4340 if (kernel_power_new < device_param->kernel_power)
4341 {
4342 device_param->kernel_power = kernel_power_new;
4343 }
4344 }
4345 }
4346 }
4347
4348 const uint kernel_power = device_param->kernel_power;
4349
4350 uint work = MIN (words_left, kernel_power);
4351
4352 work = MIN (work, max);
4353
4354 data.words_cur += work;
4355
4356 hc_thread_mutex_unlock (mux_dispatcher);
4357
4358 return work;
4359 }
4360
4361 static void *thread_calc_stdin (void *p)
4362 {
4363 hc_device_param_t *device_param = (hc_device_param_t *) p;
4364
4365 if (device_param->skipped) return NULL;
4366
4367 autotune (device_param);
4368
4369 const uint attack_kern = data.attack_kern;
4370
4371 const uint kernel_power = device_param->kernel_power;
4372
4373 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4374 {
4375 hc_thread_mutex_lock (mux_dispatcher);
4376
4377 if (feof (stdin) != 0)
4378 {
4379 hc_thread_mutex_unlock (mux_dispatcher);
4380
4381 break;
4382 }
4383
4384 uint words_cur = 0;
4385
4386 while (words_cur < kernel_power)
4387 {
4388 char buf[BUFSIZ] = { 0 };
4389
4390 char *line_buf = fgets (buf, sizeof (buf), stdin);
4391
4392 if (line_buf == NULL) break;
4393
4394 uint line_len = in_superchop (line_buf);
4395
4396 line_len = convert_from_hex (line_buf, line_len);
4397
4398 // post-process rule engine
4399
4400 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4401 {
4402 char rule_buf_out[BLOCK_SIZE] = { 0 };
4403
4404 int rule_len_out = -1;
4405
4406 if (line_len < BLOCK_SIZE)
4407 {
4408 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4409 }
4410
4411 if (rule_len_out < 0) continue;
4412
4413 line_buf = rule_buf_out;
4414 line_len = rule_len_out;
4415 }
4416
4417 if (line_len > PW_MAX)
4418 {
4419 continue;
4420 }
4421
4422 if (attack_kern == ATTACK_KERN_STRAIGHT)
4423 {
4424 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4425 {
4426 hc_thread_mutex_lock (mux_counter);
4427
4428 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4429 {
4430 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4431 }
4432
4433 hc_thread_mutex_unlock (mux_counter);
4434
4435 continue;
4436 }
4437 }
4438 else if (attack_kern == ATTACK_KERN_COMBI)
4439 {
4440 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4441 // since we still need to combine the plains
4442
4443 if (line_len > data.pw_max)
4444 {
4445 hc_thread_mutex_lock (mux_counter);
4446
4447 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4448 {
4449 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4450 }
4451
4452 hc_thread_mutex_unlock (mux_counter);
4453
4454 continue;
4455 }
4456 }
4457
4458 pw_add (device_param, (u8 *) line_buf, line_len);
4459
4460 words_cur++;
4461
4462 if (data.devices_status == STATUS_CRACKED) break;
4463 if (data.devices_status == STATUS_ABORTED) break;
4464 if (data.devices_status == STATUS_QUIT) break;
4465 if (data.devices_status == STATUS_BYPASS) break;
4466 }
4467
4468 hc_thread_mutex_unlock (mux_dispatcher);
4469
4470 if (data.devices_status == STATUS_CRACKED) break;
4471 if (data.devices_status == STATUS_ABORTED) break;
4472 if (data.devices_status == STATUS_QUIT) break;
4473 if (data.devices_status == STATUS_BYPASS) break;
4474
4475 // flush
4476
4477 const uint pws_cnt = device_param->pws_cnt;
4478
4479 if (pws_cnt)
4480 {
4481 run_copy (device_param, pws_cnt);
4482
4483 run_cracker (device_param, pws_cnt);
4484
4485 device_param->pws_cnt = 0;
4486
4487 if (attack_kern == ATTACK_KERN_STRAIGHT)
4488 {
4489 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4490 }
4491 else if (attack_kern == ATTACK_KERN_COMBI)
4492 {
4493 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4494 }
4495 }
4496 }
4497
4498 device_param->kernel_accel = 0;
4499 device_param->kernel_loops = 0;
4500
4501 return NULL;
4502 }
4503
4504 static void *thread_calc (void *p)
4505 {
4506 hc_device_param_t *device_param = (hc_device_param_t *) p;
4507
4508 if (device_param->skipped) return NULL;
4509
4510 autotune (device_param);
4511
4512 const uint attack_mode = data.attack_mode;
4513 const uint attack_kern = data.attack_kern;
4514
4515 if (attack_mode == ATTACK_MODE_BF)
4516 {
4517 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4518 {
4519 const uint work = get_work (device_param, -1, true);
4520
4521 if (work == 0) break;
4522
4523 const u64 words_off = device_param->words_off;
4524 const u64 words_fin = words_off + work;
4525
4526 const uint pws_cnt = work;
4527
4528 device_param->pws_cnt = pws_cnt;
4529
4530 if (pws_cnt)
4531 {
4532 run_copy (device_param, pws_cnt);
4533
4534 run_cracker (device_param, pws_cnt);
4535
4536 device_param->pws_cnt = 0;
4537
4538 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4539 }
4540
4541 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4542
4543 if (data.devices_status == STATUS_CRACKED) break;
4544 if (data.devices_status == STATUS_ABORTED) break;
4545 if (data.devices_status == STATUS_QUIT) break;
4546 if (data.devices_status == STATUS_BYPASS) break;
4547
4548 if (data.benchmark == 1) break;
4549
4550 device_param->words_done = words_fin;
4551 }
4552 }
4553 else
4554 {
4555 const uint segment_size = data.segment_size;
4556
4557 char *dictfile = data.dictfile;
4558
4559 if (attack_mode == ATTACK_MODE_COMBI)
4560 {
4561 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4562 {
4563 dictfile = data.dictfile2;
4564 }
4565 }
4566
4567 FILE *fd = fopen (dictfile, "rb");
4568
4569 if (fd == NULL)
4570 {
4571 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4572
4573 return NULL;
4574 }
4575
4576 if (attack_mode == ATTACK_MODE_COMBI)
4577 {
4578 const uint combs_mode = data.combs_mode;
4579
4580 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4581 {
4582 const char *dictfilec = data.dictfile2;
4583
4584 FILE *combs_fp = fopen (dictfilec, "rb");
4585
4586 if (combs_fp == NULL)
4587 {
4588 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4589
4590 fclose (fd);
4591
4592 return NULL;
4593 }
4594
4595 device_param->combs_fp = combs_fp;
4596 }
4597 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4598 {
4599 const char *dictfilec = data.dictfile;
4600
4601 FILE *combs_fp = fopen (dictfilec, "rb");
4602
4603 if (combs_fp == NULL)
4604 {
4605 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4606
4607 fclose (fd);
4608
4609 return NULL;
4610 }
4611
4612 device_param->combs_fp = combs_fp;
4613 }
4614 }
4615
4616 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4617
4618 wl_data->buf = (char *) mymalloc (segment_size);
4619 wl_data->avail = segment_size;
4620 wl_data->incr = segment_size;
4621 wl_data->cnt = 0;
4622 wl_data->pos = 0;
4623
4624 u64 words_cur = 0;
4625
4626 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4627 {
4628 u64 words_off = 0;
4629 u64 words_fin = 0;
4630
4631 bool allow_div = true;
4632
4633 u64 max = -1;
4634
4635 while (max)
4636 {
4637 const uint work = get_work (device_param, max, allow_div);
4638
4639 allow_div = false;
4640
4641 if (work == 0) break;
4642
4643 words_off = device_param->words_off;
4644 words_fin = words_off + work;
4645
4646 char *line_buf;
4647 uint line_len;
4648
4649 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4650
4651 max = 0;
4652
4653 for ( ; words_cur < words_fin; words_cur++)
4654 {
4655 get_next_word (wl_data, fd, &line_buf, &line_len);
4656
4657 line_len = convert_from_hex (line_buf, line_len);
4658
4659 // post-process rule engine
4660
4661 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4662 {
4663 char rule_buf_out[BLOCK_SIZE] = { 0 };
4664
4665 int rule_len_out = -1;
4666
4667 if (line_len < BLOCK_SIZE)
4668 {
4669 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4670 }
4671
4672 if (rule_len_out < 0) continue;
4673
4674 line_buf = rule_buf_out;
4675 line_len = rule_len_out;
4676 }
4677
4678 if (attack_kern == ATTACK_KERN_STRAIGHT)
4679 {
4680 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4681 {
4682 max++;
4683
4684 hc_thread_mutex_lock (mux_counter);
4685
4686 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4687 {
4688 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4689 }
4690
4691 hc_thread_mutex_unlock (mux_counter);
4692
4693 continue;
4694 }
4695 }
4696 else if (attack_kern == ATTACK_KERN_COMBI)
4697 {
4698 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4699 // since we still need to combine the plains
4700
4701 if (line_len > data.pw_max)
4702 {
4703 max++;
4704
4705 hc_thread_mutex_lock (mux_counter);
4706
4707 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4708 {
4709 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4710 }
4711
4712 hc_thread_mutex_unlock (mux_counter);
4713
4714 continue;
4715 }
4716 }
4717
4718 pw_add (device_param, (u8 *) line_buf, line_len);
4719
4720 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4721
4722 if (data.devices_status == STATUS_CRACKED) break;
4723 if (data.devices_status == STATUS_ABORTED) break;
4724 if (data.devices_status == STATUS_QUIT) break;
4725 if (data.devices_status == STATUS_BYPASS) break;
4726 }
4727
4728 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4729
4730 if (data.devices_status == STATUS_CRACKED) break;
4731 if (data.devices_status == STATUS_ABORTED) break;
4732 if (data.devices_status == STATUS_QUIT) break;
4733 if (data.devices_status == STATUS_BYPASS) break;
4734 }
4735
4736 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4737
4738 if (data.devices_status == STATUS_CRACKED) break;
4739 if (data.devices_status == STATUS_ABORTED) break;
4740 if (data.devices_status == STATUS_QUIT) break;
4741 if (data.devices_status == STATUS_BYPASS) break;
4742
4743 //
4744 // flush
4745 //
4746
4747 const uint pws_cnt = device_param->pws_cnt;
4748
4749 if (pws_cnt)
4750 {
4751 run_copy (device_param, pws_cnt);
4752
4753 run_cracker (device_param, pws_cnt);
4754
4755 device_param->pws_cnt = 0;
4756
4757 if (attack_kern == ATTACK_KERN_STRAIGHT)
4758 {
4759 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4760 }
4761 else if (attack_kern == ATTACK_KERN_COMBI)
4762 {
4763 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4764 }
4765 }
4766
4767 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4768
4769 if (data.devices_status == STATUS_CRACKED) break;
4770 if (data.devices_status == STATUS_ABORTED) break;
4771 if (data.devices_status == STATUS_QUIT) break;
4772 if (data.devices_status == STATUS_BYPASS) break;
4773
4774 if (words_fin == 0) break;
4775
4776 device_param->words_done = words_fin;
4777 }
4778
4779 if (attack_mode == ATTACK_MODE_COMBI)
4780 {
4781 fclose (device_param->combs_fp);
4782 }
4783
4784 free (wl_data->buf);
4785 free (wl_data);
4786
4787 fclose (fd);
4788 }
4789
4790 device_param->kernel_accel = 0;
4791 device_param->kernel_loops = 0;
4792
4793 return NULL;
4794 }
4795
4796 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4797 {
4798 if (!device_param)
4799 {
4800 log_error ("ERROR: %s : Invalid argument", __func__);
4801
4802 exit (-1);
4803 }
4804
4805 salt_t *salt_buf = &data.salts_buf[salt_pos];
4806
4807 device_param->kernel_params_buf32[24] = salt_pos;
4808 device_param->kernel_params_buf32[27] = 1;
4809 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4810 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4811 device_param->kernel_params_buf32[30] = 0;
4812 device_param->kernel_params_buf32[31] = 1;
4813
4814 char *dictfile_old = data.dictfile;
4815
4816 const char *weak_hash_check = "weak-hash-check";
4817
4818 data.dictfile = (char *) weak_hash_check;
4819
4820 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4821
4822 data.kernel_rules_buf[0].cmds[0] = 0;
4823
4824 /**
4825 * run the kernel
4826 */
4827
4828 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4829 {
4830 run_kernel (KERN_RUN_1, device_param, 1, false);
4831 }
4832 else
4833 {
4834 run_kernel (KERN_RUN_1, device_param, 1, false);
4835
4836 uint loop_step = 16;
4837
4838 const uint iter = salt_buf->salt_iter;
4839
4840 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4841 {
4842 uint loop_left = iter - loop_pos;
4843
4844 loop_left = MIN (loop_left, loop_step);
4845
4846 device_param->kernel_params_buf32[25] = loop_pos;
4847 device_param->kernel_params_buf32[26] = loop_left;
4848
4849 run_kernel (KERN_RUN_2, device_param, 1, false);
4850 }
4851
4852 run_kernel (KERN_RUN_3, device_param, 1, false);
4853 }
4854
4855 /**
4856 * result
4857 */
4858
4859 check_cracked (device_param, salt_pos);
4860
4861 /**
4862 * cleanup
4863 */
4864
4865 device_param->kernel_params_buf32[24] = 0;
4866 device_param->kernel_params_buf32[25] = 0;
4867 device_param->kernel_params_buf32[26] = 0;
4868 device_param->kernel_params_buf32[27] = 0;
4869 device_param->kernel_params_buf32[28] = 0;
4870 device_param->kernel_params_buf32[29] = 0;
4871 device_param->kernel_params_buf32[30] = 0;
4872 device_param->kernel_params_buf32[31] = 0;
4873
4874 data.dictfile = dictfile_old;
4875
4876 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4877 }
4878
4879 // hlfmt hashcat
4880
4881 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4882 {
4883 if (data.username == 0)
4884 {
4885 *hashbuf_pos = line_buf;
4886 *hashbuf_len = line_len;
4887 }
4888 else
4889 {
4890 char *pos = line_buf;
4891 int len = line_len;
4892
4893 for (int i = 0; i < line_len; i++, pos++, len--)
4894 {
4895 if (line_buf[i] == data.separator)
4896 {
4897 pos++;
4898
4899 len--;
4900
4901 break;
4902 }
4903 }
4904
4905 *hashbuf_pos = pos;
4906 *hashbuf_len = len;
4907 }
4908 }
4909
4910 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4911 {
4912 char *pos = NULL;
4913 int len = 0;
4914
4915 int sep_cnt = 0;
4916
4917 for (int i = 0; i < line_len; i++)
4918 {
4919 if (line_buf[i] == data.separator)
4920 {
4921 sep_cnt++;
4922
4923 continue;
4924 }
4925
4926 if (sep_cnt == 0)
4927 {
4928 if (pos == NULL) pos = line_buf + i;
4929
4930 len++;
4931 }
4932 }
4933
4934 *userbuf_pos = pos;
4935 *userbuf_len = len;
4936 }
4937
4938 // hlfmt pwdump
4939
4940 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4941 {
4942 int sep_cnt = 0;
4943
4944 int sep2_len = 0;
4945 int sep3_len = 0;
4946
4947 for (int i = 0; i < line_len; i++)
4948 {
4949 if (line_buf[i] == ':')
4950 {
4951 sep_cnt++;
4952
4953 continue;
4954 }
4955
4956 if (sep_cnt == 2) sep2_len++;
4957 if (sep_cnt == 3) sep3_len++;
4958 }
4959
4960 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4961
4962 return 0;
4963 }
4964
4965 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4966 {
4967 char *pos = NULL;
4968 int len = 0;
4969
4970 int sep_cnt = 0;
4971
4972 for (int i = 0; i < line_len; i++)
4973 {
4974 if (line_buf[i] == ':')
4975 {
4976 sep_cnt++;
4977
4978 continue;
4979 }
4980
4981 if (data.hash_mode == 1000)
4982 {
4983 if (sep_cnt == 3)
4984 {
4985 if (pos == NULL) pos = line_buf + i;
4986
4987 len++;
4988 }
4989 }
4990 else if (data.hash_mode == 3000)
4991 {
4992 if (sep_cnt == 2)
4993 {
4994 if (pos == NULL) pos = line_buf + i;
4995
4996 len++;
4997 }
4998 }
4999 }
5000
5001 *hashbuf_pos = pos;
5002 *hashbuf_len = len;
5003 }
5004
5005 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5006 {
5007 char *pos = NULL;
5008 int len = 0;
5009
5010 int sep_cnt = 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 == 0)
5022 {
5023 if (pos == NULL) pos = line_buf + i;
5024
5025 len++;
5026 }
5027 }
5028
5029 *userbuf_pos = pos;
5030 *userbuf_len = len;
5031 }
5032
5033 // hlfmt passwd
5034
5035 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
5036 {
5037 int sep_cnt = 0;
5038
5039 char sep5_first = 0;
5040 char sep6_first = 0;
5041
5042 for (int i = 0; i < line_len; i++)
5043 {
5044 if (line_buf[i] == ':')
5045 {
5046 sep_cnt++;
5047
5048 continue;
5049 }
5050
5051 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5052 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5053 }
5054
5055 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5056
5057 return 0;
5058 }
5059
5060 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5061 {
5062 char *pos = NULL;
5063 int len = 0;
5064
5065 int sep_cnt = 0;
5066
5067 for (int i = 0; i < line_len; i++)
5068 {
5069 if (line_buf[i] == ':')
5070 {
5071 sep_cnt++;
5072
5073 continue;
5074 }
5075
5076 if (sep_cnt == 1)
5077 {
5078 if (pos == NULL) pos = line_buf + i;
5079
5080 len++;
5081 }
5082 }
5083
5084 *hashbuf_pos = pos;
5085 *hashbuf_len = len;
5086 }
5087
5088 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5089 {
5090 char *pos = NULL;
5091 int len = 0;
5092
5093 int sep_cnt = 0;
5094
5095 for (int i = 0; i < line_len; i++)
5096 {
5097 if (line_buf[i] == ':')
5098 {
5099 sep_cnt++;
5100
5101 continue;
5102 }
5103
5104 if (sep_cnt == 0)
5105 {
5106 if (pos == NULL) pos = line_buf + i;
5107
5108 len++;
5109 }
5110 }
5111
5112 *userbuf_pos = pos;
5113 *userbuf_len = len;
5114 }
5115
5116 // hlfmt shadow
5117
5118 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
5119 {
5120 int sep_cnt = 0;
5121
5122 for (int i = 0; i < line_len; i++)
5123 {
5124 if (line_buf[i] == ':') sep_cnt++;
5125 }
5126
5127 if (sep_cnt == 8) return 1;
5128
5129 return 0;
5130 }
5131
5132 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5133 {
5134 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5135 }
5136
5137 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5138 {
5139 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5140 }
5141
5142 // hlfmt main
5143
5144 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5145 {
5146 switch (hashfile_format)
5147 {
5148 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5149 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5150 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5151 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5152 }
5153 }
5154
5155 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5156 {
5157 switch (hashfile_format)
5158 {
5159 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5160 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5161 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5162 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5163 }
5164 }
5165
5166 static uint hlfmt_detect (FILE *fp, uint max_check)
5167 {
5168 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5169
5170 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5171 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5172
5173 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5174
5175 uint num_check = 0;
5176
5177 while (!feof (fp))
5178 {
5179 char line_buf[BUFSIZ] = { 0 };
5180
5181 int line_len = fgetl (fp, line_buf);
5182
5183 if (line_len == 0) continue;
5184
5185 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5186 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5187 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5188
5189 if (num_check == max_check) break;
5190
5191 num_check++;
5192 }
5193
5194 uint hashlist_format = HLFMT_HASHCAT;
5195
5196 for (int i = 1; i < HLFMTS_CNT; i++)
5197 {
5198 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5199
5200 hashlist_format = i;
5201 }
5202
5203 free (formats_cnt);
5204
5205 return hashlist_format;
5206 }
5207
5208 /**
5209 * some further helper function
5210 */
5211
5212 // wrapper around mymalloc for ADL
5213
5214 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5215 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5216 {
5217 return mymalloc (iSize);
5218 }
5219 #endif
5220
5221 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)
5222 {
5223 u64 collisions = 0;
5224
5225 const uint dgst_pos0 = data.dgst_pos0;
5226 const uint dgst_pos1 = data.dgst_pos1;
5227 const uint dgst_pos2 = data.dgst_pos2;
5228 const uint dgst_pos3 = data.dgst_pos3;
5229
5230 memset (bitmap_a, 0, bitmap_size);
5231 memset (bitmap_b, 0, bitmap_size);
5232 memset (bitmap_c, 0, bitmap_size);
5233 memset (bitmap_d, 0, bitmap_size);
5234
5235 for (uint i = 0; i < digests_cnt; i++)
5236 {
5237 uint *digest_ptr = (uint *) digests_buf_ptr;
5238
5239 digests_buf_ptr += dgst_size;
5240
5241 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5242 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5243 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5244 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5245
5246 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5247 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5248 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5249 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5250
5251 if (bitmap_a[idx0] & val0) collisions++;
5252 if (bitmap_b[idx1] & val1) collisions++;
5253 if (bitmap_c[idx2] & val2) collisions++;
5254 if (bitmap_d[idx3] & val3) collisions++;
5255
5256 bitmap_a[idx0] |= val0;
5257 bitmap_b[idx1] |= val1;
5258 bitmap_c[idx2] |= val2;
5259 bitmap_d[idx3] |= val3;
5260
5261 if (collisions >= collisions_max) return 0x7fffffff;
5262 }
5263
5264 return collisions;
5265 }
5266
5267 /**
5268 * main
5269 */
5270
5271 int main (int argc, char **argv)
5272 {
5273 /**
5274 * To help users a bit
5275 */
5276
5277 char *compute = getenv ("COMPUTE");
5278
5279 if (compute)
5280 {
5281 static char display[100];
5282
5283 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5284
5285 putenv (display);
5286 }
5287 else
5288 {
5289 if (getenv ("DISPLAY") == NULL)
5290 putenv ((char *) "DISPLAY=:0");
5291 }
5292
5293 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5294 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5295
5296 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5297 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5298
5299 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5300 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5301
5302 /**
5303 * Real init
5304 */
5305
5306 memset (&data, 0, sizeof (hc_global_data_t));
5307
5308 time_t proc_start;
5309
5310 time (&proc_start);
5311
5312 data.proc_start = proc_start;
5313
5314 int myargc = argc;
5315 char **myargv = argv;
5316
5317 hc_thread_mutex_init (mux_dispatcher);
5318 hc_thread_mutex_init (mux_counter);
5319 hc_thread_mutex_init (mux_display);
5320 hc_thread_mutex_init (mux_adl);
5321
5322 /**
5323 * commandline parameters
5324 */
5325
5326 uint usage = USAGE;
5327 uint version = VERSION;
5328 uint quiet = QUIET;
5329 uint benchmark = BENCHMARK;
5330 uint benchmark_repeats = BENCHMARK_REPEATS;
5331 uint show = SHOW;
5332 uint left = LEFT;
5333 uint username = USERNAME;
5334 uint remove = REMOVE;
5335 uint remove_timer = REMOVE_TIMER;
5336 u64 skip = SKIP;
5337 u64 limit = LIMIT;
5338 uint keyspace = KEYSPACE;
5339 uint potfile_disable = POTFILE_DISABLE;
5340 uint debug_mode = DEBUG_MODE;
5341 char *debug_file = NULL;
5342 char *induction_dir = NULL;
5343 char *outfile_check_dir = NULL;
5344 uint force = FORCE;
5345 uint runtime = RUNTIME;
5346 uint hash_mode = HASH_MODE;
5347 uint attack_mode = ATTACK_MODE;
5348 uint markov_disable = MARKOV_DISABLE;
5349 uint markov_classic = MARKOV_CLASSIC;
5350 uint markov_threshold = MARKOV_THRESHOLD;
5351 char *markov_hcstat = NULL;
5352 char *outfile = NULL;
5353 uint outfile_format = OUTFILE_FORMAT;
5354 uint outfile_autohex = OUTFILE_AUTOHEX;
5355 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5356 uint restore = RESTORE;
5357 uint restore_timer = RESTORE_TIMER;
5358 uint restore_disable = RESTORE_DISABLE;
5359 uint status = STATUS;
5360 uint status_timer = STATUS_TIMER;
5361 uint status_automat = STATUS_AUTOMAT;
5362 uint loopback = LOOPBACK;
5363 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5364 char *session = NULL;
5365 uint hex_charset = HEX_CHARSET;
5366 uint hex_salt = HEX_SALT;
5367 uint hex_wordlist = HEX_WORDLIST;
5368 uint rp_gen = RP_GEN;
5369 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5370 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5371 uint rp_gen_seed = RP_GEN_SEED;
5372 char *rule_buf_l = (char *) RULE_BUF_L;
5373 char *rule_buf_r = (char *) RULE_BUF_R;
5374 uint increment = INCREMENT;
5375 uint increment_min = INCREMENT_MIN;
5376 uint increment_max = INCREMENT_MAX;
5377 char *cpu_affinity = NULL;
5378 OCL_PTR *ocl = NULL;
5379 char *opencl_devices = NULL;
5380 char *opencl_platforms = NULL;
5381 char *opencl_device_types = NULL;
5382 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5383 char *truecrypt_keyfiles = NULL;
5384 uint workload_profile = WORKLOAD_PROFILE;
5385 uint kernel_accel = KERNEL_ACCEL;
5386 uint kernel_loops = KERNEL_LOOPS;
5387 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5388 #ifdef HAVE_HWMON
5389 uint gpu_temp_abort = GPU_TEMP_ABORT;
5390 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5391 #ifdef HAVE_ADL
5392 uint powertune_enable = POWERTUNE_ENABLE;
5393 #endif
5394 #endif
5395 uint logfile_disable = LOGFILE_DISABLE;
5396 uint segment_size = SEGMENT_SIZE;
5397 uint scrypt_tmto = SCRYPT_TMTO;
5398 char separator = SEPARATOR;
5399 uint bitmap_min = BITMAP_MIN;
5400 uint bitmap_max = BITMAP_MAX;
5401 char *custom_charset_1 = NULL;
5402 char *custom_charset_2 = NULL;
5403 char *custom_charset_3 = NULL;
5404 char *custom_charset_4 = NULL;
5405
5406 #define IDX_HELP 'h'
5407 #define IDX_VERSION 'V'
5408 #define IDX_VERSION_LOWER 'v'
5409 #define IDX_QUIET 0xff02
5410 #define IDX_SHOW 0xff03
5411 #define IDX_LEFT 0xff04
5412 #define IDX_REMOVE 0xff05
5413 #define IDX_REMOVE_TIMER 0xff37
5414 #define IDX_SKIP 's'
5415 #define IDX_LIMIT 'l'
5416 #define IDX_KEYSPACE 0xff35
5417 #define IDX_POTFILE_DISABLE 0xff06
5418 #define IDX_DEBUG_MODE 0xff43
5419 #define IDX_DEBUG_FILE 0xff44
5420 #define IDX_INDUCTION_DIR 0xff46
5421 #define IDX_OUTFILE_CHECK_DIR 0xff47
5422 #define IDX_USERNAME 0xff07
5423 #define IDX_FORCE 0xff08
5424 #define IDX_RUNTIME 0xff09
5425 #define IDX_BENCHMARK 'b'
5426 #define IDX_BENCHMARK_REPEATS 0xff78
5427 #define IDX_HASH_MODE 'm'
5428 #define IDX_ATTACK_MODE 'a'
5429 #define IDX_RP_FILE 'r'
5430 #define IDX_RP_GEN 'g'
5431 #define IDX_RP_GEN_FUNC_MIN 0xff10
5432 #define IDX_RP_GEN_FUNC_MAX 0xff11
5433 #define IDX_RP_GEN_SEED 0xff34
5434 #define IDX_RULE_BUF_L 'j'
5435 #define IDX_RULE_BUF_R 'k'
5436 #define IDX_INCREMENT 'i'
5437 #define IDX_INCREMENT_MIN 0xff12
5438 #define IDX_INCREMENT_MAX 0xff13
5439 #define IDX_OUTFILE 'o'
5440 #define IDX_OUTFILE_FORMAT 0xff14
5441 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5442 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5443 #define IDX_RESTORE 0xff15
5444 #define IDX_RESTORE_DISABLE 0xff27
5445 #define IDX_STATUS 0xff17
5446 #define IDX_STATUS_TIMER 0xff18
5447 #define IDX_STATUS_AUTOMAT 0xff50
5448 #define IDX_LOOPBACK 0xff38
5449 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5450 #define IDX_SESSION 0xff19
5451 #define IDX_HEX_CHARSET 0xff20
5452 #define IDX_HEX_SALT 0xff21
5453 #define IDX_HEX_WORDLIST 0xff40
5454 #define IDX_MARKOV_DISABLE 0xff22
5455 #define IDX_MARKOV_CLASSIC 0xff23
5456 #define IDX_MARKOV_THRESHOLD 't'
5457 #define IDX_MARKOV_HCSTAT 0xff24
5458 #define IDX_CPU_AFFINITY 0xff25
5459 #define IDX_OPENCL_DEVICES 'd'
5460 #define IDX_OPENCL_PLATFORMS 0xff72
5461 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5462 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5463 #define IDX_WORKLOAD_PROFILE 'w'
5464 #define IDX_KERNEL_ACCEL 'n'
5465 #define IDX_KERNEL_LOOPS 'u'
5466 #define IDX_GPU_TEMP_DISABLE 0xff29
5467 #define IDX_GPU_TEMP_ABORT 0xff30
5468 #define IDX_GPU_TEMP_RETAIN 0xff31
5469 #define IDX_POWERTUNE_ENABLE 0xff41
5470 #define IDX_LOGFILE_DISABLE 0xff51
5471 #define IDX_TRUECRYPT_KEYFILES 0xff52
5472 #define IDX_SCRYPT_TMTO 0xff61
5473 #define IDX_SEGMENT_SIZE 'c'
5474 #define IDX_SEPARATOR 'p'
5475 #define IDX_BITMAP_MIN 0xff70
5476 #define IDX_BITMAP_MAX 0xff71
5477 #define IDX_CUSTOM_CHARSET_1 '1'
5478 #define IDX_CUSTOM_CHARSET_2 '2'
5479 #define IDX_CUSTOM_CHARSET_3 '3'
5480 #define IDX_CUSTOM_CHARSET_4 '4'
5481
5482 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5483
5484 struct option long_options[] =
5485 {
5486 {"help", no_argument, 0, IDX_HELP},
5487 {"version", no_argument, 0, IDX_VERSION},
5488 {"quiet", no_argument, 0, IDX_QUIET},
5489 {"show", no_argument, 0, IDX_SHOW},
5490 {"left", no_argument, 0, IDX_LEFT},
5491 {"username", no_argument, 0, IDX_USERNAME},
5492 {"remove", no_argument, 0, IDX_REMOVE},
5493 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5494 {"skip", required_argument, 0, IDX_SKIP},
5495 {"limit", required_argument, 0, IDX_LIMIT},
5496 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5497 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5498 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5499 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5500 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5501 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5502 {"force", no_argument, 0, IDX_FORCE},
5503 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5504 {"benchmark-repeats", required_argument, 0, IDX_BENCHMARK_REPEATS},
5505 {"restore", no_argument, 0, IDX_RESTORE},
5506 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5507 {"status", no_argument, 0, IDX_STATUS},
5508 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5509 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5510 {"loopback", no_argument, 0, IDX_LOOPBACK},
5511 {"weak-hash-threshold",
5512 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5513 {"session", required_argument, 0, IDX_SESSION},
5514 {"runtime", required_argument, 0, IDX_RUNTIME},
5515 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5516 {"generate-rules-func-min",
5517 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5518 {"generate-rules-func-max",
5519 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5520 {"generate-rules-seed",
5521 required_argument, 0, IDX_RP_GEN_SEED},
5522 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5523 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5524 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5525 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5526 {"rules-file", required_argument, 0, IDX_RP_FILE},
5527 {"outfile", required_argument, 0, IDX_OUTFILE},
5528 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5529 {"outfile-autohex-disable",
5530 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5531 {"outfile-check-timer",
5532 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5533 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5534 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5535 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5536 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5537 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5538 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5539 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5540 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5541 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5542 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5543 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5544 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5545 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5546 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5547 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5548 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5549 #ifdef HAVE_HWMON
5550 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5551 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5552 #ifdef HAVE_ADL
5553 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5554 #endif
5555 #endif // HAVE_HWMON
5556 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5557 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5558 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5559 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5560 // deprecated
5561 {"seperator", required_argument, 0, IDX_SEPARATOR},
5562 {"separator", required_argument, 0, IDX_SEPARATOR},
5563 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5564 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5565 {"increment", no_argument, 0, IDX_INCREMENT},
5566 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5567 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5568 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5569 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5570 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5571 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5572
5573 {0, 0, 0, 0}
5574 };
5575
5576 uint rp_files_cnt = 0;
5577
5578 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5579
5580 int option_index = 0;
5581 int c = -1;
5582
5583 optind = 1;
5584 optopt = 0;
5585
5586 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5587 {
5588 switch (c)
5589 {
5590 case IDX_HELP: usage = 1; break;
5591 case IDX_VERSION:
5592 case IDX_VERSION_LOWER: version = 1; break;
5593 case IDX_RESTORE: restore = 1; break;
5594 case IDX_SESSION: session = optarg; break;
5595 case IDX_SHOW: show = 1; break;
5596 case IDX_LEFT: left = 1; break;
5597 case '?': return (-1);
5598 }
5599 }
5600
5601 if (optopt != 0)
5602 {
5603 log_error ("ERROR: Invalid argument specified");
5604
5605 return (-1);
5606 }
5607
5608 /**
5609 * exit functions
5610 */
5611
5612 if (version)
5613 {
5614 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5615
5616 return (0);
5617 }
5618
5619 if (usage)
5620 {
5621 usage_big_print (PROGNAME);
5622
5623 return (0);
5624 }
5625
5626 /**
5627 * session needs to be set, always!
5628 */
5629
5630 if (session == NULL) session = (char *) PROGNAME;
5631
5632 /**
5633 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5634 */
5635
5636 char *exec_path = get_exec_path ();
5637
5638 #ifdef LINUX
5639
5640 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5641 char *resolved_exec_path = realpath (exec_path, NULL);
5642
5643 char *install_dir = get_install_dir (resolved_exec_path);
5644 char *profile_dir = NULL;
5645 char *session_dir = NULL;
5646 char *shared_dir = NULL;
5647
5648 if (strcmp (install_dir, resolved_install_folder) == 0)
5649 {
5650 struct passwd *pw = getpwuid (getuid ());
5651
5652 const char *homedir = pw->pw_dir;
5653
5654 profile_dir = get_profile_dir (homedir);
5655 session_dir = get_session_dir (profile_dir);
5656 shared_dir = strdup (SHARED_FOLDER);
5657
5658 mkdir (profile_dir, 0700);
5659 mkdir (session_dir, 0700);
5660 }
5661 else
5662 {
5663 profile_dir = install_dir;
5664 session_dir = install_dir;
5665 shared_dir = install_dir;
5666 }
5667
5668 myfree (resolved_install_folder);
5669 myfree (resolved_exec_path);
5670
5671 #else
5672
5673 char *install_dir = get_install_dir (exec_path);
5674 char *profile_dir = install_dir;
5675 char *session_dir = install_dir;
5676 char *shared_dir = install_dir;
5677
5678 #endif
5679
5680 data.install_dir = install_dir;
5681 data.profile_dir = profile_dir;
5682 data.session_dir = session_dir;
5683 data.shared_dir = shared_dir;
5684
5685 myfree (exec_path);
5686
5687 /**
5688 * kernel cache, we need to make sure folder exist
5689 */
5690
5691 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5692
5693 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5694
5695 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5696
5697 mkdir (kernels_folder, 0700);
5698
5699 myfree (kernels_folder);
5700
5701 /**
5702 * session
5703 */
5704
5705 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5706
5707 data.session = session;
5708
5709 char *eff_restore_file = (char *) mymalloc (session_size);
5710 char *new_restore_file = (char *) mymalloc (session_size);
5711
5712 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5713 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5714
5715 data.eff_restore_file = eff_restore_file;
5716 data.new_restore_file = new_restore_file;
5717
5718 if (((show == 1) || (left == 1)) && (restore == 1))
5719 {
5720 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5721 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5722
5723 return (-1);
5724 }
5725
5726 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5727 if ((show == 1) || (left == 1))
5728 {
5729 restore_disable = 1;
5730
5731 restore = 0;
5732 }
5733
5734 data.restore_disable = restore_disable;
5735
5736 restore_data_t *rd = init_restore (argc, argv);
5737
5738 data.rd = rd;
5739
5740 /**
5741 * restore file
5742 */
5743
5744 if (restore == 1)
5745 {
5746 read_restore (eff_restore_file, rd);
5747
5748 if (rd->version_bin < RESTORE_MIN)
5749 {
5750 log_error ("ERROR: Incompatible restore-file version");
5751
5752 return (-1);
5753 }
5754
5755 myargc = rd->argc;
5756 myargv = rd->argv;
5757
5758 #ifdef _POSIX
5759 rd->pid = getpid ();
5760 #elif _WIN
5761 rd->pid = GetCurrentProcessId ();
5762 #endif
5763 }
5764
5765 uint hash_mode_chgd = 0;
5766 uint runtime_chgd = 0;
5767 uint kernel_loops_chgd = 0;
5768 uint kernel_accel_chgd = 0;
5769 uint attack_mode_chgd = 0;
5770 uint outfile_format_chgd = 0;
5771 uint rp_gen_seed_chgd = 0;
5772 uint remove_timer_chgd = 0;
5773 uint increment_min_chgd = 0;
5774 uint increment_max_chgd = 0;
5775 uint workload_profile_chgd = 0;
5776 uint opencl_vector_width_chgd = 0;
5777
5778 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5779 uint gpu_temp_retain_chgd = 0;
5780 uint gpu_temp_abort_chgd = 0;
5781 #endif
5782
5783 optind = 1;
5784 optopt = 0;
5785 option_index = 0;
5786
5787 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5788 {
5789 switch (c)
5790 {
5791 //case IDX_HELP: usage = 1; break;
5792 //case IDX_VERSION: version = 1; break;
5793 //case IDX_RESTORE: restore = 1; break;
5794 case IDX_QUIET: quiet = 1; break;
5795 //case IDX_SHOW: show = 1; break;
5796 case IDX_SHOW: break;
5797 //case IDX_LEFT: left = 1; break;
5798 case IDX_LEFT: break;
5799 case IDX_USERNAME: username = 1; break;
5800 case IDX_REMOVE: remove = 1; break;
5801 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5802 remove_timer_chgd = 1; break;
5803 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5804 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5805 case IDX_DEBUG_FILE: debug_file = optarg; break;
5806 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5807 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5808 case IDX_FORCE: force = 1; break;
5809 case IDX_SKIP: skip = atoll (optarg); break;
5810 case IDX_LIMIT: limit = atoll (optarg); break;
5811 case IDX_KEYSPACE: keyspace = 1; break;
5812 case IDX_BENCHMARK: benchmark = 1; break;
5813 case IDX_BENCHMARK_REPEATS: benchmark_repeats = atoi (optarg); break;
5814 case IDX_RESTORE: break;
5815 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5816 case IDX_STATUS: status = 1; break;
5817 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5818 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5819 case IDX_LOOPBACK: loopback = 1; break;
5820 case IDX_WEAK_HASH_THRESHOLD:
5821 weak_hash_threshold = atoi (optarg); break;
5822 //case IDX_SESSION: session = optarg; break;
5823 case IDX_SESSION: break;
5824 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5825 hash_mode_chgd = 1; break;
5826 case IDX_RUNTIME: runtime = atoi (optarg);
5827 runtime_chgd = 1; break;
5828 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5829 attack_mode_chgd = 1; break;
5830 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5831 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5832 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5833 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5834 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5835 rp_gen_seed_chgd = 1; break;
5836 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5837 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5838 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5839 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5840 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5841 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5842 case IDX_OUTFILE: outfile = optarg; break;
5843 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5844 outfile_format_chgd = 1; break;
5845 case IDX_OUTFILE_AUTOHEX_DISABLE:
5846 outfile_autohex = 0; break;
5847 case IDX_OUTFILE_CHECK_TIMER:
5848 outfile_check_timer = atoi (optarg); break;
5849 case IDX_HEX_CHARSET: hex_charset = 1; break;
5850 case IDX_HEX_SALT: hex_salt = 1; break;
5851 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5852 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5853 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5854 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5855 case IDX_OPENCL_DEVICE_TYPES:
5856 opencl_device_types = optarg; break;
5857 case IDX_OPENCL_VECTOR_WIDTH:
5858 opencl_vector_width = atoi (optarg);
5859 opencl_vector_width_chgd = 1; break;
5860 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5861 workload_profile_chgd = 1; break;
5862 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5863 kernel_accel_chgd = 1; break;
5864 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5865 kernel_loops_chgd = 1; break;
5866 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5867 #ifdef HAVE_HWMON
5868 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5869 #ifdef HAVE_ADL
5870 gpu_temp_abort_chgd = 1;
5871 #endif
5872 break;
5873 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5874 #ifdef HAVE_ADL
5875 gpu_temp_retain_chgd = 1;
5876 #endif
5877 break;
5878 #ifdef HAVE_ADL
5879 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5880 #endif
5881 #endif // HAVE_HWMON
5882 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5883 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5884 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5885 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5886 case IDX_SEPARATOR: separator = optarg[0]; break;
5887 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5888 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5889 case IDX_INCREMENT: increment = 1; break;
5890 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5891 increment_min_chgd = 1; break;
5892 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5893 increment_max_chgd = 1; break;
5894 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5895 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5896 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5897 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5898
5899 default:
5900 log_error ("ERROR: Invalid argument specified");
5901 return (-1);
5902 }
5903 }
5904
5905 if (optopt != 0)
5906 {
5907 log_error ("ERROR: Invalid argument specified");
5908
5909 return (-1);
5910 }
5911
5912 /**
5913 * Inform user things getting started,
5914 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5915 * - we do not need to check algorithm_pos
5916 */
5917
5918 if (quiet == 0)
5919 {
5920 if (benchmark == 1)
5921 {
5922 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5923
5924 log_info ("");
5925 }
5926 else if (restore == 1)
5927 {
5928 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5929
5930 log_info ("");
5931 }
5932 else
5933 {
5934 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5935
5936 log_info ("");
5937 }
5938 }
5939
5940 /**
5941 * sanity check
5942 */
5943
5944 if (attack_mode > 7)
5945 {
5946 log_error ("ERROR: Invalid attack-mode specified");
5947
5948 return (-1);
5949 }
5950
5951 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5952 {
5953 log_error ("ERROR: Invalid runtime specified");
5954
5955 return (-1);
5956 }
5957
5958 if (hash_mode_chgd && hash_mode > 13100) // just added to remove compiler warnings for hash_mode_chgd
5959 {
5960 log_error ("ERROR: Invalid hash-type specified");
5961
5962 return (-1);
5963 }
5964
5965 // renamed hash modes
5966
5967 if (hash_mode_chgd)
5968 {
5969 int n = -1;
5970
5971 switch (hash_mode)
5972 {
5973 case 123: n = 124;
5974 break;
5975 }
5976
5977 if (n >= 0)
5978 {
5979 log_error ("Old -m specified, use -m %d instead", n);
5980
5981 return (-1);
5982 }
5983 }
5984
5985 if (username == 1)
5986 {
5987 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5988 {
5989 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5990
5991 return (-1);
5992 }
5993 }
5994
5995 if (outfile_format > 16)
5996 {
5997 log_error ("ERROR: Invalid outfile-format specified");
5998
5999 return (-1);
6000 }
6001
6002 if (left == 1)
6003 {
6004 if (outfile_format_chgd == 1)
6005 {
6006 if (outfile_format > 1)
6007 {
6008 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6009
6010 return (-1);
6011 }
6012 }
6013 else
6014 {
6015 outfile_format = OUTFILE_FMT_HASH;
6016 }
6017 }
6018
6019 if (show == 1)
6020 {
6021 if (outfile_format_chgd == 1)
6022 {
6023 if ((outfile_format > 7) && (outfile_format < 16))
6024 {
6025 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6026
6027 return (-1);
6028 }
6029 }
6030 }
6031
6032 if (increment_min < INCREMENT_MIN)
6033 {
6034 log_error ("ERROR: Invalid increment-min specified");
6035
6036 return (-1);
6037 }
6038
6039 if (increment_max > INCREMENT_MAX)
6040 {
6041 log_error ("ERROR: Invalid increment-max specified");
6042
6043 return (-1);
6044 }
6045
6046 if (increment_min > increment_max)
6047 {
6048 log_error ("ERROR: Invalid increment-min specified");
6049
6050 return (-1);
6051 }
6052
6053 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6054 {
6055 log_error ("ERROR: increment is not allowed in attack-mode 0");
6056
6057 return (-1);
6058 }
6059
6060 if ((increment == 0) && (increment_min_chgd == 1))
6061 {
6062 log_error ("ERROR: increment-min is only supported together with increment switch");
6063
6064 return (-1);
6065 }
6066
6067 if ((increment == 0) && (increment_max_chgd == 1))
6068 {
6069 log_error ("ERROR: increment-max is only supported together with increment switch");
6070
6071 return (-1);
6072 }
6073
6074 if (rp_files_cnt && rp_gen)
6075 {
6076 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6077
6078 return (-1);
6079 }
6080
6081 if (rp_files_cnt || rp_gen)
6082 {
6083 if (attack_mode != ATTACK_MODE_STRAIGHT)
6084 {
6085 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6086
6087 return (-1);
6088 }
6089 }
6090
6091 if (rp_gen_func_min > rp_gen_func_max)
6092 {
6093 log_error ("ERROR: Invalid rp-gen-func-min specified");
6094
6095 return (-1);
6096 }
6097
6098 if (kernel_accel_chgd == 1)
6099 {
6100 if (kernel_accel < 1)
6101 {
6102 log_error ("ERROR: Invalid kernel-accel specified");
6103
6104 return (-1);
6105 }
6106
6107 if (kernel_accel > 1024)
6108 {
6109 log_error ("ERROR: Invalid kernel-accel specified");
6110
6111 return (-1);
6112 }
6113 }
6114
6115 if (kernel_loops_chgd == 1)
6116 {
6117 if (kernel_loops < 1)
6118 {
6119 log_error ("ERROR: Invalid kernel-loops specified");
6120
6121 return (-1);
6122 }
6123
6124 if (kernel_loops > 1024)
6125 {
6126 log_error ("ERROR: Invalid kernel-loops specified");
6127
6128 return (-1);
6129 }
6130 }
6131
6132 if ((workload_profile < 1) || (workload_profile > 3))
6133 {
6134 log_error ("ERROR: workload-profile %i not available", workload_profile);
6135
6136 return (-1);
6137 }
6138
6139 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6140 {
6141 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6142
6143 return (-1);
6144 }
6145
6146 if (show == 1 || left == 1)
6147 {
6148 attack_mode = ATTACK_MODE_NONE;
6149
6150 if (remove == 1)
6151 {
6152 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6153
6154 return (-1);
6155 }
6156
6157 if (potfile_disable == 1)
6158 {
6159 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6160
6161 return (-1);
6162 }
6163 }
6164
6165 uint attack_kern = ATTACK_KERN_NONE;
6166
6167 switch (attack_mode)
6168 {
6169 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6170 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6171 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6172 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6173 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6174 }
6175
6176 if (benchmark == 0)
6177 {
6178 if (keyspace == 1)
6179 {
6180 int num_additional_params = 1;
6181
6182 if (attack_kern == ATTACK_KERN_COMBI)
6183 {
6184 num_additional_params = 2;
6185 }
6186
6187 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6188
6189 if (keyspace_wordlist_specified == 0) optind--;
6190 }
6191
6192 if (attack_kern == ATTACK_KERN_NONE)
6193 {
6194 if ((optind + 1) != myargc)
6195 {
6196 usage_mini_print (myargv[0]);
6197
6198 return (-1);
6199 }
6200 }
6201 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6202 {
6203 if ((optind + 1) > myargc)
6204 {
6205 usage_mini_print (myargv[0]);
6206
6207 return (-1);
6208 }
6209 }
6210 else if (attack_kern == ATTACK_KERN_COMBI)
6211 {
6212 if ((optind + 3) != myargc)
6213 {
6214 usage_mini_print (myargv[0]);
6215
6216 return (-1);
6217 }
6218 }
6219 else if (attack_kern == ATTACK_KERN_BF)
6220 {
6221 if ((optind + 1) > myargc)
6222 {
6223 usage_mini_print (myargv[0]);
6224
6225 return (-1);
6226 }
6227 }
6228 else
6229 {
6230 usage_mini_print (myargv[0]);
6231
6232 return (-1);
6233 }
6234 }
6235 else
6236 {
6237 if (myargv[optind] != 0)
6238 {
6239 log_error ("ERROR: Invalid argument for benchmark mode specified");
6240
6241 return (-1);
6242 }
6243
6244 if (attack_mode_chgd == 1)
6245 {
6246 if (attack_mode != ATTACK_MODE_BF)
6247 {
6248 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6249
6250 return (-1);
6251 }
6252 }
6253 }
6254
6255 if (skip != 0 && limit != 0)
6256 {
6257 limit += skip;
6258 }
6259
6260 if (keyspace == 1)
6261 {
6262 if (show == 1)
6263 {
6264 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6265
6266 return (-1);
6267 }
6268 else if (left == 1)
6269 {
6270 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6271
6272 return (-1);
6273 }
6274
6275 potfile_disable = 1;
6276
6277 restore_disable = 1;
6278
6279 restore = 0;
6280
6281 weak_hash_threshold = 0;
6282
6283 quiet = 1;
6284 }
6285
6286 if (remove_timer_chgd == 1)
6287 {
6288 if (remove == 0)
6289 {
6290 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6291
6292 return (-1);
6293 }
6294
6295 if (remove_timer < 1)
6296 {
6297 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6298
6299 return (-1);
6300 }
6301 }
6302
6303 if (loopback == 1)
6304 {
6305 if (attack_mode == ATTACK_MODE_BF)
6306 {
6307 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6308
6309 return (-1);
6310 }
6311 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6312 {
6313 if ((rp_files_cnt == 0) && (rp_gen == 0))
6314 {
6315 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6316
6317 return (-1);
6318 }
6319 }
6320 }
6321
6322 if (debug_mode > 0)
6323 {
6324 if (attack_mode != ATTACK_MODE_STRAIGHT)
6325 {
6326 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6327
6328 return (-1);
6329 }
6330
6331 if ((rp_files_cnt == 0) && (rp_gen == 0))
6332 {
6333 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6334
6335 return (-1);
6336 }
6337 }
6338
6339 if (debug_mode > 4)
6340 {
6341 log_error ("ERROR: Invalid debug-mode specified");
6342
6343 return (-1);
6344 }
6345
6346 if (debug_file != NULL)
6347 {
6348 if (debug_mode < 1)
6349 {
6350 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6351
6352 return (-1);
6353 }
6354 }
6355
6356 if (induction_dir != NULL)
6357 {
6358 if (attack_mode == ATTACK_MODE_BF)
6359 {
6360 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6361
6362 return (-1);
6363 }
6364 }
6365
6366 if (attack_mode != ATTACK_MODE_STRAIGHT)
6367 {
6368 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6369 {
6370 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6371
6372 return (-1);
6373 }
6374
6375 weak_hash_threshold = 0;
6376 }
6377
6378 /**
6379 * induction directory
6380 */
6381
6382 char *induction_directory = NULL;
6383
6384 if (attack_mode != ATTACK_MODE_BF)
6385 {
6386 if (induction_dir == NULL)
6387 {
6388 induction_directory = (char *) mymalloc (session_size);
6389
6390 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6391
6392 // create induction folder if it does not already exist
6393
6394 if (keyspace == 0)
6395 {
6396 if (rmdir (induction_directory) == -1)
6397 {
6398 if (errno == ENOENT)
6399 {
6400 // good, we can ignore
6401 }
6402 else if (errno == ENOTEMPTY)
6403 {
6404 char *induction_directory_mv = (char *) mymalloc (session_size);
6405
6406 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6407
6408 if (rename (induction_directory, induction_directory_mv) != 0)
6409 {
6410 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6411
6412 return (-1);
6413 }
6414 }
6415 else
6416 {
6417 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6418
6419 return (-1);
6420 }
6421 }
6422
6423 if (mkdir (induction_directory, 0700) == -1)
6424 {
6425 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6426
6427 return (-1);
6428 }
6429 }
6430 }
6431 else
6432 {
6433 induction_directory = induction_dir;
6434 }
6435 }
6436
6437 data.induction_directory = induction_directory;
6438
6439 /**
6440 * loopback
6441 */
6442
6443 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6444
6445 char *loopback_file = (char *) mymalloc (loopback_size);
6446
6447 /**
6448 * tuning db
6449 */
6450
6451 char tuning_db_file[256] = { 0 };
6452
6453 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6454
6455 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6456
6457 /**
6458 * outfile-check directory
6459 */
6460
6461 char *outfile_check_directory = NULL;
6462
6463 if (outfile_check_dir == NULL)
6464 {
6465 outfile_check_directory = (char *) mymalloc (session_size);
6466
6467 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6468 }
6469 else
6470 {
6471 outfile_check_directory = outfile_check_dir;
6472 }
6473
6474 data.outfile_check_directory = outfile_check_directory;
6475
6476 if (keyspace == 0)
6477 {
6478 struct stat outfile_check_stat;
6479
6480 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6481 {
6482 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6483
6484 if (is_dir == 0)
6485 {
6486 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6487
6488 return (-1);
6489 }
6490 }
6491 else if (outfile_check_dir == NULL)
6492 {
6493 if (mkdir (outfile_check_directory, 0700) == -1)
6494 {
6495 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6496
6497 return (-1);
6498 }
6499 }
6500 }
6501
6502 /**
6503 * special other stuff
6504 */
6505
6506 if (hash_mode == 9710)
6507 {
6508 outfile_format = 5;
6509 outfile_format_chgd = 1;
6510 }
6511
6512 if (hash_mode == 9810)
6513 {
6514 outfile_format = 5;
6515 outfile_format_chgd = 1;
6516 }
6517
6518 if (hash_mode == 10410)
6519 {
6520 outfile_format = 5;
6521 outfile_format_chgd = 1;
6522 }
6523
6524 /**
6525 * store stuff
6526 */
6527
6528 data.hash_mode = hash_mode;
6529 data.restore = restore;
6530 data.restore_timer = restore_timer;
6531 data.restore_disable = restore_disable;
6532 data.status = status;
6533 data.status_timer = status_timer;
6534 data.status_automat = status_automat;
6535 data.loopback = loopback;
6536 data.runtime = runtime;
6537 data.remove = remove;
6538 data.remove_timer = remove_timer;
6539 data.debug_mode = debug_mode;
6540 data.debug_file = debug_file;
6541 data.username = username;
6542 data.quiet = quiet;
6543 data.outfile = outfile;
6544 data.outfile_format = outfile_format;
6545 data.outfile_autohex = outfile_autohex;
6546 data.hex_charset = hex_charset;
6547 data.hex_salt = hex_salt;
6548 data.hex_wordlist = hex_wordlist;
6549 data.separator = separator;
6550 data.rp_files = rp_files;
6551 data.rp_files_cnt = rp_files_cnt;
6552 data.rp_gen = rp_gen;
6553 data.rp_gen_seed = rp_gen_seed;
6554 data.force = force;
6555 data.benchmark = benchmark;
6556 data.benchmark_repeats = benchmark_repeats;
6557 data.skip = skip;
6558 data.limit = limit;
6559 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6560 data.powertune_enable = powertune_enable;
6561 #endif
6562 data.logfile_disable = logfile_disable;
6563 data.truecrypt_keyfiles = truecrypt_keyfiles;
6564 data.scrypt_tmto = scrypt_tmto;
6565 data.workload_profile = workload_profile;
6566
6567 /**
6568 * cpu affinity
6569 */
6570
6571 if (cpu_affinity)
6572 {
6573 set_cpu_affinity (cpu_affinity);
6574 }
6575
6576 if (rp_gen_seed_chgd == 0)
6577 {
6578 srand (proc_start);
6579 }
6580 else
6581 {
6582 srand (rp_gen_seed);
6583 }
6584
6585 /**
6586 * logfile init
6587 */
6588
6589 if (logfile_disable == 0)
6590 {
6591 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6592
6593 char *logfile = (char *) mymalloc (logfile_size);
6594
6595 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6596
6597 data.logfile = logfile;
6598
6599 char *topid = logfile_generate_topid ();
6600
6601 data.topid = topid;
6602 }
6603
6604 // logfile_append() checks for logfile_disable internally to make it easier from here
6605
6606 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6607 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6608 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6609 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6610 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6611 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6612 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6613 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6614 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6615 #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));
6616
6617 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6618 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6619 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6620 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6621 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6622 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6623 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6624 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6625
6626 logfile_top_msg ("START");
6627
6628 logfile_top_uint (attack_mode);
6629 logfile_top_uint (attack_kern);
6630 logfile_top_uint (benchmark);
6631 logfile_top_uint (benchmark_repeats);
6632 logfile_top_uint (bitmap_min);
6633 logfile_top_uint (bitmap_max);
6634 logfile_top_uint (debug_mode);
6635 logfile_top_uint (force);
6636 logfile_top_uint (kernel_accel);
6637 logfile_top_uint (kernel_loops);
6638 logfile_top_uint (gpu_temp_disable);
6639 #ifdef HAVE_HWMON
6640 logfile_top_uint (gpu_temp_abort);
6641 logfile_top_uint (gpu_temp_retain);
6642 #endif
6643 logfile_top_uint (hash_mode);
6644 logfile_top_uint (hex_charset);
6645 logfile_top_uint (hex_salt);
6646 logfile_top_uint (hex_wordlist);
6647 logfile_top_uint (increment);
6648 logfile_top_uint (increment_max);
6649 logfile_top_uint (increment_min);
6650 logfile_top_uint (keyspace);
6651 logfile_top_uint (left);
6652 logfile_top_uint (logfile_disable);
6653 logfile_top_uint (loopback);
6654 logfile_top_uint (markov_classic);
6655 logfile_top_uint (markov_disable);
6656 logfile_top_uint (markov_threshold);
6657 logfile_top_uint (outfile_autohex);
6658 logfile_top_uint (outfile_check_timer);
6659 logfile_top_uint (outfile_format);
6660 logfile_top_uint (potfile_disable);
6661 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6662 logfile_top_uint (powertune_enable);
6663 #endif
6664 logfile_top_uint (scrypt_tmto);
6665 logfile_top_uint (quiet);
6666 logfile_top_uint (remove);
6667 logfile_top_uint (remove_timer);
6668 logfile_top_uint (restore);
6669 logfile_top_uint (restore_disable);
6670 logfile_top_uint (restore_timer);
6671 logfile_top_uint (rp_gen);
6672 logfile_top_uint (rp_gen_func_max);
6673 logfile_top_uint (rp_gen_func_min);
6674 logfile_top_uint (rp_gen_seed);
6675 logfile_top_uint (runtime);
6676 logfile_top_uint (segment_size);
6677 logfile_top_uint (show);
6678 logfile_top_uint (status);
6679 logfile_top_uint (status_automat);
6680 logfile_top_uint (status_timer);
6681 logfile_top_uint (usage);
6682 logfile_top_uint (username);
6683 logfile_top_uint (version);
6684 logfile_top_uint (weak_hash_threshold);
6685 logfile_top_uint (workload_profile);
6686 logfile_top_uint64 (limit);
6687 logfile_top_uint64 (skip);
6688 logfile_top_char (separator);
6689 logfile_top_string (cpu_affinity);
6690 logfile_top_string (custom_charset_1);
6691 logfile_top_string (custom_charset_2);
6692 logfile_top_string (custom_charset_3);
6693 logfile_top_string (custom_charset_4);
6694 logfile_top_string (debug_file);
6695 logfile_top_string (opencl_devices);
6696 logfile_top_string (opencl_platforms);
6697 logfile_top_string (opencl_device_types);
6698 logfile_top_uint (opencl_vector_width);
6699 logfile_top_string (induction_dir);
6700 logfile_top_string (markov_hcstat);
6701 logfile_top_string (outfile);
6702 logfile_top_string (outfile_check_dir);
6703 logfile_top_string (rule_buf_l);
6704 logfile_top_string (rule_buf_r);
6705 logfile_top_string (session);
6706 logfile_top_string (truecrypt_keyfiles);
6707
6708 /**
6709 * Init OpenCL library loader
6710 */
6711
6712 if (keyspace == 0)
6713 {
6714 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6715
6716 ocl_init (ocl);
6717
6718 data.ocl = ocl;
6719 }
6720
6721 /**
6722 * OpenCL platform selection
6723 */
6724
6725 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6726
6727 /**
6728 * OpenCL device selection
6729 */
6730
6731 u32 devices_filter = setup_devices_filter (opencl_devices);
6732
6733 /**
6734 * OpenCL device type selection
6735 */
6736
6737 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6738
6739 /**
6740 * benchmark
6741 */
6742
6743 if (benchmark == 1)
6744 {
6745 /**
6746 * disable useless stuff for benchmark
6747 */
6748
6749 status_timer = 0;
6750 restore_timer = 0;
6751 restore_disable = 1;
6752 potfile_disable = 1;
6753 weak_hash_threshold = 0;
6754 gpu_temp_disable = 1;
6755
6756 data.status_timer = status_timer;
6757 data.restore_timer = restore_timer;
6758 data.restore_disable = restore_disable;
6759
6760 /**
6761 * force attack mode to be bruteforce
6762 */
6763
6764 attack_mode = ATTACK_MODE_BF;
6765 attack_kern = ATTACK_KERN_BF;
6766
6767 if (workload_profile_chgd == 0)
6768 {
6769 workload_profile = 3;
6770
6771 data.workload_profile = workload_profile;
6772 }
6773 }
6774
6775 /**
6776 * config
6777 */
6778
6779 uint hash_type = 0;
6780 uint salt_type = 0;
6781 uint attack_exec = 0;
6782 uint opts_type = 0;
6783 uint kern_type = 0;
6784 uint dgst_size = 0;
6785 uint esalt_size = 0;
6786 uint opti_type = 0;
6787 uint dgst_pos0 = -1;
6788 uint dgst_pos1 = -1;
6789 uint dgst_pos2 = -1;
6790 uint dgst_pos3 = -1;
6791
6792 int (*parse_func) (char *, uint, hash_t *);
6793 int (*sort_by_digest) (const void *, const void *);
6794
6795 uint algorithm_pos = 0;
6796 uint algorithm_max = 1;
6797
6798 uint *algorithms = default_benchmark_algorithms;
6799
6800 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6801
6802 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6803 {
6804 /*
6805 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6806 * the following algos are skipped entirely
6807 */
6808
6809 if (algorithm_pos > 0)
6810 {
6811 local_free (rd);
6812
6813 rd = init_restore (argc, argv);
6814
6815 data.rd = rd;
6816 }
6817
6818 /**
6819 * update hash_mode in case of multihash benchmark
6820 */
6821
6822 if (benchmark == 1)
6823 {
6824 if (hash_mode_chgd == 0)
6825 {
6826 hash_mode = algorithms[algorithm_pos];
6827
6828 data.hash_mode = hash_mode;
6829 }
6830
6831 quiet = 1;
6832
6833 data.quiet = quiet;
6834 }
6835
6836 switch (hash_mode)
6837 {
6838 case 0: hash_type = HASH_TYPE_MD5;
6839 salt_type = SALT_TYPE_NONE;
6840 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6841 opts_type = OPTS_TYPE_PT_GENERATE_LE
6842 | OPTS_TYPE_PT_ADD80
6843 | OPTS_TYPE_PT_ADDBITS14;
6844 kern_type = KERN_TYPE_MD5;
6845 dgst_size = DGST_SIZE_4_4;
6846 parse_func = md5_parse_hash;
6847 sort_by_digest = sort_by_digest_4_4;
6848 opti_type = OPTI_TYPE_ZERO_BYTE
6849 | OPTI_TYPE_PRECOMPUTE_INIT
6850 | OPTI_TYPE_PRECOMPUTE_MERKLE
6851 | OPTI_TYPE_MEET_IN_MIDDLE
6852 | OPTI_TYPE_EARLY_SKIP
6853 | OPTI_TYPE_NOT_ITERATED
6854 | OPTI_TYPE_NOT_SALTED
6855 | OPTI_TYPE_RAW_HASH;
6856 dgst_pos0 = 0;
6857 dgst_pos1 = 3;
6858 dgst_pos2 = 2;
6859 dgst_pos3 = 1;
6860 break;
6861
6862 case 10: hash_type = HASH_TYPE_MD5;
6863 salt_type = SALT_TYPE_INTERN;
6864 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6865 opts_type = OPTS_TYPE_PT_GENERATE_LE
6866 | OPTS_TYPE_ST_ADD80
6867 | OPTS_TYPE_ST_ADDBITS14;
6868 kern_type = KERN_TYPE_MD5_PWSLT;
6869 dgst_size = DGST_SIZE_4_4;
6870 parse_func = md5s_parse_hash;
6871 sort_by_digest = sort_by_digest_4_4;
6872 opti_type = OPTI_TYPE_ZERO_BYTE
6873 | OPTI_TYPE_PRECOMPUTE_INIT
6874 | OPTI_TYPE_PRECOMPUTE_MERKLE
6875 | OPTI_TYPE_MEET_IN_MIDDLE
6876 | OPTI_TYPE_EARLY_SKIP
6877 | OPTI_TYPE_NOT_ITERATED
6878 | OPTI_TYPE_APPENDED_SALT
6879 | OPTI_TYPE_RAW_HASH;
6880 dgst_pos0 = 0;
6881 dgst_pos1 = 3;
6882 dgst_pos2 = 2;
6883 dgst_pos3 = 1;
6884 break;
6885
6886 case 11: hash_type = HASH_TYPE_MD5;
6887 salt_type = SALT_TYPE_INTERN;
6888 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6889 opts_type = OPTS_TYPE_PT_GENERATE_LE
6890 | OPTS_TYPE_ST_ADD80
6891 | OPTS_TYPE_ST_ADDBITS14;
6892 kern_type = KERN_TYPE_MD5_PWSLT;
6893 dgst_size = DGST_SIZE_4_4;
6894 parse_func = joomla_parse_hash;
6895 sort_by_digest = sort_by_digest_4_4;
6896 opti_type = OPTI_TYPE_ZERO_BYTE
6897 | OPTI_TYPE_PRECOMPUTE_INIT
6898 | OPTI_TYPE_PRECOMPUTE_MERKLE
6899 | OPTI_TYPE_MEET_IN_MIDDLE
6900 | OPTI_TYPE_EARLY_SKIP
6901 | OPTI_TYPE_NOT_ITERATED
6902 | OPTI_TYPE_APPENDED_SALT
6903 | OPTI_TYPE_RAW_HASH;
6904 dgst_pos0 = 0;
6905 dgst_pos1 = 3;
6906 dgst_pos2 = 2;
6907 dgst_pos3 = 1;
6908 break;
6909
6910 case 12: hash_type = HASH_TYPE_MD5;
6911 salt_type = SALT_TYPE_INTERN;
6912 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6913 opts_type = OPTS_TYPE_PT_GENERATE_LE
6914 | OPTS_TYPE_ST_ADD80
6915 | OPTS_TYPE_ST_ADDBITS14;
6916 kern_type = KERN_TYPE_MD5_PWSLT;
6917 dgst_size = DGST_SIZE_4_4;
6918 parse_func = postgresql_parse_hash;
6919 sort_by_digest = sort_by_digest_4_4;
6920 opti_type = OPTI_TYPE_ZERO_BYTE
6921 | OPTI_TYPE_PRECOMPUTE_INIT
6922 | OPTI_TYPE_PRECOMPUTE_MERKLE
6923 | OPTI_TYPE_MEET_IN_MIDDLE
6924 | OPTI_TYPE_EARLY_SKIP
6925 | OPTI_TYPE_NOT_ITERATED
6926 | OPTI_TYPE_APPENDED_SALT
6927 | OPTI_TYPE_RAW_HASH;
6928 dgst_pos0 = 0;
6929 dgst_pos1 = 3;
6930 dgst_pos2 = 2;
6931 dgst_pos3 = 1;
6932 break;
6933
6934 case 20: hash_type = HASH_TYPE_MD5;
6935 salt_type = SALT_TYPE_INTERN;
6936 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6937 opts_type = OPTS_TYPE_PT_GENERATE_LE
6938 | OPTS_TYPE_PT_ADD80
6939 | OPTS_TYPE_PT_ADDBITS14;
6940 kern_type = KERN_TYPE_MD5_SLTPW;
6941 dgst_size = DGST_SIZE_4_4;
6942 parse_func = md5s_parse_hash;
6943 sort_by_digest = sort_by_digest_4_4;
6944 opti_type = OPTI_TYPE_ZERO_BYTE
6945 | OPTI_TYPE_PRECOMPUTE_INIT
6946 | OPTI_TYPE_PRECOMPUTE_MERKLE
6947 | OPTI_TYPE_EARLY_SKIP
6948 | OPTI_TYPE_NOT_ITERATED
6949 | OPTI_TYPE_PREPENDED_SALT
6950 | OPTI_TYPE_RAW_HASH;
6951 dgst_pos0 = 0;
6952 dgst_pos1 = 3;
6953 dgst_pos2 = 2;
6954 dgst_pos3 = 1;
6955 break;
6956
6957 case 21: hash_type = HASH_TYPE_MD5;
6958 salt_type = SALT_TYPE_INTERN;
6959 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6960 opts_type = OPTS_TYPE_PT_GENERATE_LE
6961 | OPTS_TYPE_PT_ADD80
6962 | OPTS_TYPE_PT_ADDBITS14;
6963 kern_type = KERN_TYPE_MD5_SLTPW;
6964 dgst_size = DGST_SIZE_4_4;
6965 parse_func = osc_parse_hash;
6966 sort_by_digest = sort_by_digest_4_4;
6967 opti_type = OPTI_TYPE_ZERO_BYTE
6968 | OPTI_TYPE_PRECOMPUTE_INIT
6969 | OPTI_TYPE_PRECOMPUTE_MERKLE
6970 | OPTI_TYPE_EARLY_SKIP
6971 | OPTI_TYPE_NOT_ITERATED
6972 | OPTI_TYPE_PREPENDED_SALT
6973 | OPTI_TYPE_RAW_HASH;
6974 dgst_pos0 = 0;
6975 dgst_pos1 = 3;
6976 dgst_pos2 = 2;
6977 dgst_pos3 = 1;
6978 break;
6979
6980 case 22: hash_type = HASH_TYPE_MD5;
6981 salt_type = SALT_TYPE_EMBEDDED;
6982 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6983 opts_type = OPTS_TYPE_PT_GENERATE_LE
6984 | OPTS_TYPE_PT_ADD80
6985 | OPTS_TYPE_PT_ADDBITS14;
6986 kern_type = KERN_TYPE_MD5_SLTPW;
6987 dgst_size = DGST_SIZE_4_4;
6988 parse_func = netscreen_parse_hash;
6989 sort_by_digest = sort_by_digest_4_4;
6990 opti_type = OPTI_TYPE_ZERO_BYTE
6991 | OPTI_TYPE_PRECOMPUTE_INIT
6992 | OPTI_TYPE_PRECOMPUTE_MERKLE
6993 | OPTI_TYPE_EARLY_SKIP
6994 | OPTI_TYPE_NOT_ITERATED
6995 | OPTI_TYPE_PREPENDED_SALT
6996 | OPTI_TYPE_RAW_HASH;
6997 dgst_pos0 = 0;
6998 dgst_pos1 = 3;
6999 dgst_pos2 = 2;
7000 dgst_pos3 = 1;
7001 break;
7002
7003 case 23: hash_type = HASH_TYPE_MD5;
7004 salt_type = SALT_TYPE_EMBEDDED;
7005 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7006 opts_type = OPTS_TYPE_PT_GENERATE_LE
7007 | OPTS_TYPE_PT_ADD80
7008 | OPTS_TYPE_PT_ADDBITS14;
7009 kern_type = KERN_TYPE_MD5_SLTPW;
7010 dgst_size = DGST_SIZE_4_4;
7011 parse_func = skype_parse_hash;
7012 sort_by_digest = sort_by_digest_4_4;
7013 opti_type = OPTI_TYPE_ZERO_BYTE
7014 | OPTI_TYPE_PRECOMPUTE_INIT
7015 | OPTI_TYPE_PRECOMPUTE_MERKLE
7016 | OPTI_TYPE_EARLY_SKIP
7017 | OPTI_TYPE_NOT_ITERATED
7018 | OPTI_TYPE_PREPENDED_SALT
7019 | OPTI_TYPE_RAW_HASH;
7020 dgst_pos0 = 0;
7021 dgst_pos1 = 3;
7022 dgst_pos2 = 2;
7023 dgst_pos3 = 1;
7024 break;
7025
7026 case 30: hash_type = HASH_TYPE_MD5;
7027 salt_type = SALT_TYPE_INTERN;
7028 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7029 opts_type = OPTS_TYPE_PT_GENERATE_LE
7030 | OPTS_TYPE_PT_UNICODE
7031 | OPTS_TYPE_ST_ADD80
7032 | OPTS_TYPE_ST_ADDBITS14;
7033 kern_type = KERN_TYPE_MD5_PWUSLT;
7034 dgst_size = DGST_SIZE_4_4;
7035 parse_func = md5s_parse_hash;
7036 sort_by_digest = sort_by_digest_4_4;
7037 opti_type = OPTI_TYPE_ZERO_BYTE
7038 | OPTI_TYPE_PRECOMPUTE_INIT
7039 | OPTI_TYPE_PRECOMPUTE_MERKLE
7040 | OPTI_TYPE_MEET_IN_MIDDLE
7041 | OPTI_TYPE_EARLY_SKIP
7042 | OPTI_TYPE_NOT_ITERATED
7043 | OPTI_TYPE_APPENDED_SALT
7044 | OPTI_TYPE_RAW_HASH;
7045 dgst_pos0 = 0;
7046 dgst_pos1 = 3;
7047 dgst_pos2 = 2;
7048 dgst_pos3 = 1;
7049 break;
7050
7051 case 40: hash_type = HASH_TYPE_MD5;
7052 salt_type = SALT_TYPE_INTERN;
7053 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7054 opts_type = OPTS_TYPE_PT_GENERATE_LE
7055 | OPTS_TYPE_PT_ADD80
7056 | OPTS_TYPE_PT_ADDBITS14
7057 | OPTS_TYPE_PT_UNICODE;
7058 kern_type = KERN_TYPE_MD5_SLTPWU;
7059 dgst_size = DGST_SIZE_4_4;
7060 parse_func = md5s_parse_hash;
7061 sort_by_digest = sort_by_digest_4_4;
7062 opti_type = OPTI_TYPE_ZERO_BYTE
7063 | OPTI_TYPE_PRECOMPUTE_INIT
7064 | OPTI_TYPE_PRECOMPUTE_MERKLE
7065 | OPTI_TYPE_EARLY_SKIP
7066 | OPTI_TYPE_NOT_ITERATED
7067 | OPTI_TYPE_PREPENDED_SALT
7068 | OPTI_TYPE_RAW_HASH;
7069 dgst_pos0 = 0;
7070 dgst_pos1 = 3;
7071 dgst_pos2 = 2;
7072 dgst_pos3 = 1;
7073 break;
7074
7075 case 50: hash_type = HASH_TYPE_MD5;
7076 salt_type = SALT_TYPE_INTERN;
7077 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7078 opts_type = OPTS_TYPE_PT_GENERATE_LE
7079 | OPTS_TYPE_ST_ADD80
7080 | OPTS_TYPE_ST_ADDBITS14;
7081 kern_type = KERN_TYPE_HMACMD5_PW;
7082 dgst_size = DGST_SIZE_4_4;
7083 parse_func = hmacmd5_parse_hash;
7084 sort_by_digest = sort_by_digest_4_4;
7085 opti_type = OPTI_TYPE_ZERO_BYTE
7086 | OPTI_TYPE_NOT_ITERATED;
7087 dgst_pos0 = 0;
7088 dgst_pos1 = 3;
7089 dgst_pos2 = 2;
7090 dgst_pos3 = 1;
7091 break;
7092
7093 case 60: hash_type = HASH_TYPE_MD5;
7094 salt_type = SALT_TYPE_INTERN;
7095 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7096 opts_type = OPTS_TYPE_PT_GENERATE_LE
7097 | OPTS_TYPE_PT_ADD80
7098 | OPTS_TYPE_PT_ADDBITS14;
7099 kern_type = KERN_TYPE_HMACMD5_SLT;
7100 dgst_size = DGST_SIZE_4_4;
7101 parse_func = hmacmd5_parse_hash;
7102 sort_by_digest = sort_by_digest_4_4;
7103 opti_type = OPTI_TYPE_ZERO_BYTE
7104 | OPTI_TYPE_NOT_ITERATED;
7105 dgst_pos0 = 0;
7106 dgst_pos1 = 3;
7107 dgst_pos2 = 2;
7108 dgst_pos3 = 1;
7109 break;
7110
7111 case 100: hash_type = HASH_TYPE_SHA1;
7112 salt_type = SALT_TYPE_NONE;
7113 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7114 opts_type = OPTS_TYPE_PT_GENERATE_BE
7115 | OPTS_TYPE_PT_ADD80
7116 | OPTS_TYPE_PT_ADDBITS15;
7117 kern_type = KERN_TYPE_SHA1;
7118 dgst_size = DGST_SIZE_4_5;
7119 parse_func = sha1_parse_hash;
7120 sort_by_digest = sort_by_digest_4_5;
7121 opti_type = OPTI_TYPE_ZERO_BYTE
7122 | OPTI_TYPE_PRECOMPUTE_INIT
7123 | OPTI_TYPE_PRECOMPUTE_MERKLE
7124 | OPTI_TYPE_EARLY_SKIP
7125 | OPTI_TYPE_NOT_ITERATED
7126 | OPTI_TYPE_NOT_SALTED
7127 | OPTI_TYPE_RAW_HASH;
7128 dgst_pos0 = 3;
7129 dgst_pos1 = 4;
7130 dgst_pos2 = 2;
7131 dgst_pos3 = 1;
7132 break;
7133
7134 case 101: hash_type = HASH_TYPE_SHA1;
7135 salt_type = SALT_TYPE_NONE;
7136 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7137 opts_type = OPTS_TYPE_PT_GENERATE_BE
7138 | OPTS_TYPE_PT_ADD80
7139 | OPTS_TYPE_PT_ADDBITS15;
7140 kern_type = KERN_TYPE_SHA1;
7141 dgst_size = DGST_SIZE_4_5;
7142 parse_func = sha1b64_parse_hash;
7143 sort_by_digest = sort_by_digest_4_5;
7144 opti_type = OPTI_TYPE_ZERO_BYTE
7145 | OPTI_TYPE_PRECOMPUTE_INIT
7146 | OPTI_TYPE_PRECOMPUTE_MERKLE
7147 | OPTI_TYPE_EARLY_SKIP
7148 | OPTI_TYPE_NOT_ITERATED
7149 | OPTI_TYPE_NOT_SALTED
7150 | OPTI_TYPE_RAW_HASH;
7151 dgst_pos0 = 3;
7152 dgst_pos1 = 4;
7153 dgst_pos2 = 2;
7154 dgst_pos3 = 1;
7155 break;
7156
7157 case 110: hash_type = HASH_TYPE_SHA1;
7158 salt_type = SALT_TYPE_INTERN;
7159 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7160 opts_type = OPTS_TYPE_PT_GENERATE_BE
7161 | OPTS_TYPE_ST_ADD80
7162 | OPTS_TYPE_ST_ADDBITS15;
7163 kern_type = KERN_TYPE_SHA1_PWSLT;
7164 dgst_size = DGST_SIZE_4_5;
7165 parse_func = sha1s_parse_hash;
7166 sort_by_digest = sort_by_digest_4_5;
7167 opti_type = OPTI_TYPE_ZERO_BYTE
7168 | OPTI_TYPE_PRECOMPUTE_INIT
7169 | OPTI_TYPE_PRECOMPUTE_MERKLE
7170 | OPTI_TYPE_EARLY_SKIP
7171 | OPTI_TYPE_NOT_ITERATED
7172 | OPTI_TYPE_APPENDED_SALT
7173 | OPTI_TYPE_RAW_HASH;
7174 dgst_pos0 = 3;
7175 dgst_pos1 = 4;
7176 dgst_pos2 = 2;
7177 dgst_pos3 = 1;
7178 break;
7179
7180 case 111: hash_type = HASH_TYPE_SHA1;
7181 salt_type = SALT_TYPE_EMBEDDED;
7182 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7183 opts_type = OPTS_TYPE_PT_GENERATE_BE
7184 | OPTS_TYPE_ST_ADD80
7185 | OPTS_TYPE_ST_ADDBITS15;
7186 kern_type = KERN_TYPE_SHA1_PWSLT;
7187 dgst_size = DGST_SIZE_4_5;
7188 parse_func = sha1b64s_parse_hash;
7189 sort_by_digest = sort_by_digest_4_5;
7190 opti_type = OPTI_TYPE_ZERO_BYTE
7191 | OPTI_TYPE_PRECOMPUTE_INIT
7192 | OPTI_TYPE_PRECOMPUTE_MERKLE
7193 | OPTI_TYPE_EARLY_SKIP
7194 | OPTI_TYPE_NOT_ITERATED
7195 | OPTI_TYPE_APPENDED_SALT
7196 | OPTI_TYPE_RAW_HASH;
7197 dgst_pos0 = 3;
7198 dgst_pos1 = 4;
7199 dgst_pos2 = 2;
7200 dgst_pos3 = 1;
7201 break;
7202
7203 case 112: hash_type = HASH_TYPE_SHA1;
7204 salt_type = SALT_TYPE_INTERN;
7205 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7206 opts_type = OPTS_TYPE_PT_GENERATE_BE
7207 | OPTS_TYPE_ST_ADD80
7208 | OPTS_TYPE_ST_ADDBITS15
7209 | OPTS_TYPE_ST_HEX;
7210 kern_type = KERN_TYPE_SHA1_PWSLT;
7211 dgst_size = DGST_SIZE_4_5;
7212 parse_func = oracles_parse_hash;
7213 sort_by_digest = sort_by_digest_4_5;
7214 opti_type = OPTI_TYPE_ZERO_BYTE
7215 | OPTI_TYPE_PRECOMPUTE_INIT
7216 | OPTI_TYPE_PRECOMPUTE_MERKLE
7217 | OPTI_TYPE_EARLY_SKIP
7218 | OPTI_TYPE_NOT_ITERATED
7219 | OPTI_TYPE_APPENDED_SALT
7220 | OPTI_TYPE_RAW_HASH;
7221 dgst_pos0 = 3;
7222 dgst_pos1 = 4;
7223 dgst_pos2 = 2;
7224 dgst_pos3 = 1;
7225 break;
7226
7227 case 120: hash_type = HASH_TYPE_SHA1;
7228 salt_type = SALT_TYPE_INTERN;
7229 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7230 opts_type = OPTS_TYPE_PT_GENERATE_BE
7231 | OPTS_TYPE_PT_ADD80
7232 | OPTS_TYPE_PT_ADDBITS15;
7233 kern_type = KERN_TYPE_SHA1_SLTPW;
7234 dgst_size = DGST_SIZE_4_5;
7235 parse_func = sha1s_parse_hash;
7236 sort_by_digest = sort_by_digest_4_5;
7237 opti_type = OPTI_TYPE_ZERO_BYTE
7238 | OPTI_TYPE_PRECOMPUTE_INIT
7239 | OPTI_TYPE_PRECOMPUTE_MERKLE
7240 | OPTI_TYPE_EARLY_SKIP
7241 | OPTI_TYPE_NOT_ITERATED
7242 | OPTI_TYPE_PREPENDED_SALT
7243 | OPTI_TYPE_RAW_HASH;
7244 dgst_pos0 = 3;
7245 dgst_pos1 = 4;
7246 dgst_pos2 = 2;
7247 dgst_pos3 = 1;
7248 break;
7249
7250 case 121: hash_type = HASH_TYPE_SHA1;
7251 salt_type = SALT_TYPE_INTERN;
7252 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7253 opts_type = OPTS_TYPE_PT_GENERATE_BE
7254 | OPTS_TYPE_PT_ADD80
7255 | OPTS_TYPE_PT_ADDBITS15
7256 | OPTS_TYPE_ST_LOWER;
7257 kern_type = KERN_TYPE_SHA1_SLTPW;
7258 dgst_size = DGST_SIZE_4_5;
7259 parse_func = smf_parse_hash;
7260 sort_by_digest = sort_by_digest_4_5;
7261 opti_type = OPTI_TYPE_ZERO_BYTE
7262 | OPTI_TYPE_PRECOMPUTE_INIT
7263 | OPTI_TYPE_PRECOMPUTE_MERKLE
7264 | OPTI_TYPE_EARLY_SKIP
7265 | OPTI_TYPE_NOT_ITERATED
7266 | OPTI_TYPE_PREPENDED_SALT
7267 | OPTI_TYPE_RAW_HASH;
7268 dgst_pos0 = 3;
7269 dgst_pos1 = 4;
7270 dgst_pos2 = 2;
7271 dgst_pos3 = 1;
7272 break;
7273
7274 case 122: hash_type = HASH_TYPE_SHA1;
7275 salt_type = SALT_TYPE_EMBEDDED;
7276 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7277 opts_type = OPTS_TYPE_PT_GENERATE_BE
7278 | OPTS_TYPE_PT_ADD80
7279 | OPTS_TYPE_PT_ADDBITS15
7280 | OPTS_TYPE_ST_HEX;
7281 kern_type = KERN_TYPE_SHA1_SLTPW;
7282 dgst_size = DGST_SIZE_4_5;
7283 parse_func = osx1_parse_hash;
7284 sort_by_digest = sort_by_digest_4_5;
7285 opti_type = OPTI_TYPE_ZERO_BYTE
7286 | OPTI_TYPE_PRECOMPUTE_INIT
7287 | OPTI_TYPE_PRECOMPUTE_MERKLE
7288 | OPTI_TYPE_EARLY_SKIP
7289 | OPTI_TYPE_NOT_ITERATED
7290 | OPTI_TYPE_PREPENDED_SALT
7291 | OPTI_TYPE_RAW_HASH;
7292 dgst_pos0 = 3;
7293 dgst_pos1 = 4;
7294 dgst_pos2 = 2;
7295 dgst_pos3 = 1;
7296 break;
7297
7298 case 124: hash_type = HASH_TYPE_SHA1;
7299 salt_type = SALT_TYPE_EMBEDDED;
7300 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7301 opts_type = OPTS_TYPE_PT_GENERATE_BE
7302 | OPTS_TYPE_PT_ADD80
7303 | OPTS_TYPE_PT_ADDBITS15;
7304 kern_type = KERN_TYPE_SHA1_SLTPW;
7305 dgst_size = DGST_SIZE_4_5;
7306 parse_func = djangosha1_parse_hash;
7307 sort_by_digest = sort_by_digest_4_5;
7308 opti_type = OPTI_TYPE_ZERO_BYTE
7309 | OPTI_TYPE_PRECOMPUTE_INIT
7310 | OPTI_TYPE_PRECOMPUTE_MERKLE
7311 | OPTI_TYPE_EARLY_SKIP
7312 | OPTI_TYPE_NOT_ITERATED
7313 | OPTI_TYPE_PREPENDED_SALT
7314 | OPTI_TYPE_RAW_HASH;
7315 dgst_pos0 = 3;
7316 dgst_pos1 = 4;
7317 dgst_pos2 = 2;
7318 dgst_pos3 = 1;
7319 break;
7320
7321 case 130: hash_type = HASH_TYPE_SHA1;
7322 salt_type = SALT_TYPE_INTERN;
7323 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7324 opts_type = OPTS_TYPE_PT_GENERATE_BE
7325 | OPTS_TYPE_PT_UNICODE
7326 | OPTS_TYPE_ST_ADD80
7327 | OPTS_TYPE_ST_ADDBITS15;
7328 kern_type = KERN_TYPE_SHA1_PWUSLT;
7329 dgst_size = DGST_SIZE_4_5;
7330 parse_func = sha1s_parse_hash;
7331 sort_by_digest = sort_by_digest_4_5;
7332 opti_type = OPTI_TYPE_ZERO_BYTE
7333 | OPTI_TYPE_PRECOMPUTE_INIT
7334 | OPTI_TYPE_PRECOMPUTE_MERKLE
7335 | OPTI_TYPE_EARLY_SKIP
7336 | OPTI_TYPE_NOT_ITERATED
7337 | OPTI_TYPE_APPENDED_SALT
7338 | OPTI_TYPE_RAW_HASH;
7339 dgst_pos0 = 3;
7340 dgst_pos1 = 4;
7341 dgst_pos2 = 2;
7342 dgst_pos3 = 1;
7343 break;
7344
7345 case 131: hash_type = HASH_TYPE_SHA1;
7346 salt_type = SALT_TYPE_EMBEDDED;
7347 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7348 opts_type = OPTS_TYPE_PT_GENERATE_BE
7349 | OPTS_TYPE_PT_UNICODE
7350 | OPTS_TYPE_PT_UPPER
7351 | OPTS_TYPE_ST_ADD80
7352 | OPTS_TYPE_ST_ADDBITS15
7353 | OPTS_TYPE_ST_HEX;
7354 kern_type = KERN_TYPE_SHA1_PWUSLT;
7355 dgst_size = DGST_SIZE_4_5;
7356 parse_func = mssql2000_parse_hash;
7357 sort_by_digest = sort_by_digest_4_5;
7358 opti_type = OPTI_TYPE_ZERO_BYTE
7359 | OPTI_TYPE_PRECOMPUTE_INIT
7360 | OPTI_TYPE_PRECOMPUTE_MERKLE
7361 | OPTI_TYPE_EARLY_SKIP
7362 | OPTI_TYPE_NOT_ITERATED
7363 | OPTI_TYPE_APPENDED_SALT
7364 | OPTI_TYPE_RAW_HASH;
7365 dgst_pos0 = 3;
7366 dgst_pos1 = 4;
7367 dgst_pos2 = 2;
7368 dgst_pos3 = 1;
7369 break;
7370
7371 case 132: hash_type = HASH_TYPE_SHA1;
7372 salt_type = SALT_TYPE_EMBEDDED;
7373 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7374 opts_type = OPTS_TYPE_PT_GENERATE_BE
7375 | OPTS_TYPE_PT_UNICODE
7376 | OPTS_TYPE_ST_ADD80
7377 | OPTS_TYPE_ST_ADDBITS15
7378 | OPTS_TYPE_ST_HEX;
7379 kern_type = KERN_TYPE_SHA1_PWUSLT;
7380 dgst_size = DGST_SIZE_4_5;
7381 parse_func = mssql2005_parse_hash;
7382 sort_by_digest = sort_by_digest_4_5;
7383 opti_type = OPTI_TYPE_ZERO_BYTE
7384 | OPTI_TYPE_PRECOMPUTE_INIT
7385 | OPTI_TYPE_PRECOMPUTE_MERKLE
7386 | OPTI_TYPE_EARLY_SKIP
7387 | OPTI_TYPE_NOT_ITERATED
7388 | OPTI_TYPE_APPENDED_SALT
7389 | OPTI_TYPE_RAW_HASH;
7390 dgst_pos0 = 3;
7391 dgst_pos1 = 4;
7392 dgst_pos2 = 2;
7393 dgst_pos3 = 1;
7394 break;
7395
7396 case 133: hash_type = HASH_TYPE_SHA1;
7397 salt_type = SALT_TYPE_EMBEDDED;
7398 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7399 opts_type = OPTS_TYPE_PT_GENERATE_BE
7400 | OPTS_TYPE_PT_UNICODE
7401 | OPTS_TYPE_ST_ADD80
7402 | OPTS_TYPE_ST_ADDBITS15;
7403 kern_type = KERN_TYPE_SHA1_PWUSLT;
7404 dgst_size = DGST_SIZE_4_5;
7405 parse_func = peoplesoft_parse_hash;
7406 sort_by_digest = sort_by_digest_4_5;
7407 opti_type = OPTI_TYPE_ZERO_BYTE
7408 | OPTI_TYPE_PRECOMPUTE_INIT
7409 | OPTI_TYPE_PRECOMPUTE_MERKLE
7410 | OPTI_TYPE_EARLY_SKIP
7411 | OPTI_TYPE_NOT_ITERATED
7412 | OPTI_TYPE_APPENDED_SALT
7413 | OPTI_TYPE_RAW_HASH;
7414 dgst_pos0 = 3;
7415 dgst_pos1 = 4;
7416 dgst_pos2 = 2;
7417 dgst_pos3 = 1;
7418 break;
7419
7420 case 140: hash_type = HASH_TYPE_SHA1;
7421 salt_type = SALT_TYPE_INTERN;
7422 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7423 opts_type = OPTS_TYPE_PT_GENERATE_BE
7424 | OPTS_TYPE_PT_ADD80
7425 | OPTS_TYPE_PT_ADDBITS15
7426 | OPTS_TYPE_PT_UNICODE;
7427 kern_type = KERN_TYPE_SHA1_SLTPWU;
7428 dgst_size = DGST_SIZE_4_5;
7429 parse_func = sha1s_parse_hash;
7430 sort_by_digest = sort_by_digest_4_5;
7431 opti_type = OPTI_TYPE_ZERO_BYTE
7432 | OPTI_TYPE_PRECOMPUTE_INIT
7433 | OPTI_TYPE_PRECOMPUTE_MERKLE
7434 | OPTI_TYPE_EARLY_SKIP
7435 | OPTI_TYPE_NOT_ITERATED
7436 | OPTI_TYPE_PREPENDED_SALT
7437 | OPTI_TYPE_RAW_HASH;
7438 dgst_pos0 = 3;
7439 dgst_pos1 = 4;
7440 dgst_pos2 = 2;
7441 dgst_pos3 = 1;
7442 break;
7443
7444 case 141: hash_type = HASH_TYPE_SHA1;
7445 salt_type = SALT_TYPE_EMBEDDED;
7446 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7447 opts_type = OPTS_TYPE_PT_GENERATE_BE
7448 | OPTS_TYPE_PT_ADD80
7449 | OPTS_TYPE_PT_ADDBITS15
7450 | OPTS_TYPE_PT_UNICODE
7451 | OPTS_TYPE_ST_BASE64;
7452 kern_type = KERN_TYPE_SHA1_SLTPWU;
7453 dgst_size = DGST_SIZE_4_5;
7454 parse_func = episerver_parse_hash;
7455 sort_by_digest = sort_by_digest_4_5;
7456 opti_type = OPTI_TYPE_ZERO_BYTE
7457 | OPTI_TYPE_PRECOMPUTE_INIT
7458 | OPTI_TYPE_PRECOMPUTE_MERKLE
7459 | OPTI_TYPE_EARLY_SKIP
7460 | OPTI_TYPE_NOT_ITERATED
7461 | OPTI_TYPE_PREPENDED_SALT
7462 | OPTI_TYPE_RAW_HASH;
7463 dgst_pos0 = 3;
7464 dgst_pos1 = 4;
7465 dgst_pos2 = 2;
7466 dgst_pos3 = 1;
7467 break;
7468
7469 case 150: hash_type = HASH_TYPE_SHA1;
7470 salt_type = SALT_TYPE_INTERN;
7471 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7472 opts_type = OPTS_TYPE_PT_GENERATE_BE
7473 | OPTS_TYPE_ST_ADD80
7474 | OPTS_TYPE_ST_ADDBITS15;
7475 kern_type = KERN_TYPE_HMACSHA1_PW;
7476 dgst_size = DGST_SIZE_4_5;
7477 parse_func = hmacsha1_parse_hash;
7478 sort_by_digest = sort_by_digest_4_5;
7479 opti_type = OPTI_TYPE_ZERO_BYTE
7480 | OPTI_TYPE_NOT_ITERATED;
7481 dgst_pos0 = 3;
7482 dgst_pos1 = 4;
7483 dgst_pos2 = 2;
7484 dgst_pos3 = 1;
7485 break;
7486
7487 case 160: hash_type = HASH_TYPE_SHA1;
7488 salt_type = SALT_TYPE_INTERN;
7489 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7490 opts_type = OPTS_TYPE_PT_GENERATE_BE
7491 | OPTS_TYPE_PT_ADD80
7492 | OPTS_TYPE_PT_ADDBITS15;
7493 kern_type = KERN_TYPE_HMACSHA1_SLT;
7494 dgst_size = DGST_SIZE_4_5;
7495 parse_func = hmacsha1_parse_hash;
7496 sort_by_digest = sort_by_digest_4_5;
7497 opti_type = OPTI_TYPE_ZERO_BYTE
7498 | OPTI_TYPE_NOT_ITERATED;
7499 dgst_pos0 = 3;
7500 dgst_pos1 = 4;
7501 dgst_pos2 = 2;
7502 dgst_pos3 = 1;
7503 break;
7504
7505 case 190: hash_type = HASH_TYPE_SHA1;
7506 salt_type = SALT_TYPE_NONE;
7507 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7508 opts_type = OPTS_TYPE_PT_GENERATE_BE
7509 | OPTS_TYPE_PT_ADD80
7510 | OPTS_TYPE_PT_ADDBITS15;
7511 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7512 dgst_size = DGST_SIZE_4_5;
7513 parse_func = sha1linkedin_parse_hash;
7514 sort_by_digest = sort_by_digest_4_5;
7515 opti_type = OPTI_TYPE_ZERO_BYTE
7516 | OPTI_TYPE_PRECOMPUTE_INIT
7517 | OPTI_TYPE_EARLY_SKIP
7518 | OPTI_TYPE_NOT_ITERATED
7519 | OPTI_TYPE_NOT_SALTED;
7520 dgst_pos0 = 0;
7521 dgst_pos1 = 4;
7522 dgst_pos2 = 3;
7523 dgst_pos3 = 2;
7524 break;
7525
7526 case 200: hash_type = HASH_TYPE_MYSQL;
7527 salt_type = SALT_TYPE_NONE;
7528 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7529 opts_type = 0;
7530 kern_type = KERN_TYPE_MYSQL;
7531 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7532 parse_func = mysql323_parse_hash;
7533 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7534 opti_type = OPTI_TYPE_ZERO_BYTE;
7535 dgst_pos0 = 0;
7536 dgst_pos1 = 1;
7537 dgst_pos2 = 2;
7538 dgst_pos3 = 3;
7539 break;
7540
7541 case 300: hash_type = HASH_TYPE_SHA1;
7542 salt_type = SALT_TYPE_NONE;
7543 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7544 opts_type = OPTS_TYPE_PT_GENERATE_BE
7545 | OPTS_TYPE_PT_ADD80
7546 | OPTS_TYPE_PT_ADDBITS15;
7547 kern_type = KERN_TYPE_MYSQL41;
7548 dgst_size = DGST_SIZE_4_5;
7549 parse_func = sha1_parse_hash;
7550 sort_by_digest = sort_by_digest_4_5;
7551 opti_type = OPTI_TYPE_ZERO_BYTE
7552 | OPTI_TYPE_PRECOMPUTE_INIT
7553 | OPTI_TYPE_PRECOMPUTE_MERKLE
7554 | OPTI_TYPE_EARLY_SKIP
7555 | OPTI_TYPE_NOT_ITERATED
7556 | OPTI_TYPE_NOT_SALTED;
7557 dgst_pos0 = 3;
7558 dgst_pos1 = 4;
7559 dgst_pos2 = 2;
7560 dgst_pos3 = 1;
7561 break;
7562
7563 case 400: hash_type = HASH_TYPE_MD5;
7564 salt_type = SALT_TYPE_EMBEDDED;
7565 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7566 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7567 kern_type = KERN_TYPE_PHPASS;
7568 dgst_size = DGST_SIZE_4_4;
7569 parse_func = phpass_parse_hash;
7570 sort_by_digest = sort_by_digest_4_4;
7571 opti_type = OPTI_TYPE_ZERO_BYTE;
7572 dgst_pos0 = 0;
7573 dgst_pos1 = 1;
7574 dgst_pos2 = 2;
7575 dgst_pos3 = 3;
7576 break;
7577
7578 case 500: hash_type = HASH_TYPE_MD5;
7579 salt_type = SALT_TYPE_EMBEDDED;
7580 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7581 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7582 kern_type = KERN_TYPE_MD5CRYPT;
7583 dgst_size = DGST_SIZE_4_4;
7584 parse_func = md5crypt_parse_hash;
7585 sort_by_digest = sort_by_digest_4_4;
7586 opti_type = OPTI_TYPE_ZERO_BYTE;
7587 dgst_pos0 = 0;
7588 dgst_pos1 = 1;
7589 dgst_pos2 = 2;
7590 dgst_pos3 = 3;
7591 break;
7592
7593 case 501: hash_type = HASH_TYPE_MD5;
7594 salt_type = SALT_TYPE_EMBEDDED;
7595 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7596 opts_type = OPTS_TYPE_PT_GENERATE_LE
7597 | OPTS_TYPE_HASH_COPY;
7598 kern_type = KERN_TYPE_MD5CRYPT;
7599 dgst_size = DGST_SIZE_4_4;
7600 parse_func = juniper_parse_hash;
7601 sort_by_digest = sort_by_digest_4_4;
7602 opti_type = OPTI_TYPE_ZERO_BYTE;
7603 dgst_pos0 = 0;
7604 dgst_pos1 = 1;
7605 dgst_pos2 = 2;
7606 dgst_pos3 = 3;
7607 break;
7608
7609 case 900: hash_type = HASH_TYPE_MD4;
7610 salt_type = SALT_TYPE_NONE;
7611 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7612 opts_type = OPTS_TYPE_PT_GENERATE_LE
7613 | OPTS_TYPE_PT_ADD80
7614 | OPTS_TYPE_PT_ADDBITS14;
7615 kern_type = KERN_TYPE_MD4;
7616 dgst_size = DGST_SIZE_4_4;
7617 parse_func = md4_parse_hash;
7618 sort_by_digest = sort_by_digest_4_4;
7619 opti_type = OPTI_TYPE_ZERO_BYTE
7620 | OPTI_TYPE_PRECOMPUTE_INIT
7621 | OPTI_TYPE_PRECOMPUTE_MERKLE
7622 | OPTI_TYPE_MEET_IN_MIDDLE
7623 | OPTI_TYPE_EARLY_SKIP
7624 | OPTI_TYPE_NOT_ITERATED
7625 | OPTI_TYPE_NOT_SALTED
7626 | OPTI_TYPE_RAW_HASH;
7627 dgst_pos0 = 0;
7628 dgst_pos1 = 3;
7629 dgst_pos2 = 2;
7630 dgst_pos3 = 1;
7631 break;
7632
7633 case 1000: hash_type = HASH_TYPE_MD4;
7634 salt_type = SALT_TYPE_NONE;
7635 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7636 opts_type = OPTS_TYPE_PT_GENERATE_LE
7637 | OPTS_TYPE_PT_ADD80
7638 | OPTS_TYPE_PT_ADDBITS14
7639 | OPTS_TYPE_PT_UNICODE;
7640 kern_type = KERN_TYPE_MD4_PWU;
7641 dgst_size = DGST_SIZE_4_4;
7642 parse_func = md4_parse_hash;
7643 sort_by_digest = sort_by_digest_4_4;
7644 opti_type = OPTI_TYPE_ZERO_BYTE
7645 | OPTI_TYPE_PRECOMPUTE_INIT
7646 | OPTI_TYPE_PRECOMPUTE_MERKLE
7647 | OPTI_TYPE_MEET_IN_MIDDLE
7648 | OPTI_TYPE_EARLY_SKIP
7649 | OPTI_TYPE_NOT_ITERATED
7650 | OPTI_TYPE_NOT_SALTED
7651 | OPTI_TYPE_RAW_HASH;
7652 dgst_pos0 = 0;
7653 dgst_pos1 = 3;
7654 dgst_pos2 = 2;
7655 dgst_pos3 = 1;
7656 break;
7657
7658 case 1100: hash_type = HASH_TYPE_MD4;
7659 salt_type = SALT_TYPE_INTERN;
7660 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7661 opts_type = OPTS_TYPE_PT_GENERATE_LE
7662 | OPTS_TYPE_PT_ADD80
7663 | OPTS_TYPE_PT_ADDBITS14
7664 | OPTS_TYPE_PT_UNICODE
7665 | OPTS_TYPE_ST_ADD80
7666 | OPTS_TYPE_ST_UNICODE
7667 | OPTS_TYPE_ST_LOWER;
7668 kern_type = KERN_TYPE_MD44_PWUSLT;
7669 dgst_size = DGST_SIZE_4_4;
7670 parse_func = dcc_parse_hash;
7671 sort_by_digest = sort_by_digest_4_4;
7672 opti_type = OPTI_TYPE_ZERO_BYTE
7673 | OPTI_TYPE_PRECOMPUTE_INIT
7674 | OPTI_TYPE_PRECOMPUTE_MERKLE
7675 | OPTI_TYPE_EARLY_SKIP
7676 | OPTI_TYPE_NOT_ITERATED;
7677 dgst_pos0 = 0;
7678 dgst_pos1 = 3;
7679 dgst_pos2 = 2;
7680 dgst_pos3 = 1;
7681 break;
7682
7683 case 1400: hash_type = HASH_TYPE_SHA256;
7684 salt_type = SALT_TYPE_NONE;
7685 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7686 opts_type = OPTS_TYPE_PT_GENERATE_BE
7687 | OPTS_TYPE_PT_ADD80
7688 | OPTS_TYPE_PT_ADDBITS15;
7689 kern_type = KERN_TYPE_SHA256;
7690 dgst_size = DGST_SIZE_4_8;
7691 parse_func = sha256_parse_hash;
7692 sort_by_digest = sort_by_digest_4_8;
7693 opti_type = OPTI_TYPE_ZERO_BYTE
7694 | OPTI_TYPE_PRECOMPUTE_INIT
7695 | OPTI_TYPE_PRECOMPUTE_MERKLE
7696 | OPTI_TYPE_EARLY_SKIP
7697 | OPTI_TYPE_NOT_ITERATED
7698 | OPTI_TYPE_NOT_SALTED
7699 | OPTI_TYPE_RAW_HASH;
7700 dgst_pos0 = 3;
7701 dgst_pos1 = 7;
7702 dgst_pos2 = 2;
7703 dgst_pos3 = 6;
7704 break;
7705
7706 case 1410: hash_type = HASH_TYPE_SHA256;
7707 salt_type = SALT_TYPE_INTERN;
7708 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7709 opts_type = OPTS_TYPE_PT_GENERATE_BE
7710 | OPTS_TYPE_ST_ADD80
7711 | OPTS_TYPE_ST_ADDBITS15;
7712 kern_type = KERN_TYPE_SHA256_PWSLT;
7713 dgst_size = DGST_SIZE_4_8;
7714 parse_func = sha256s_parse_hash;
7715 sort_by_digest = sort_by_digest_4_8;
7716 opti_type = OPTI_TYPE_ZERO_BYTE
7717 | OPTI_TYPE_PRECOMPUTE_INIT
7718 | OPTI_TYPE_PRECOMPUTE_MERKLE
7719 | OPTI_TYPE_EARLY_SKIP
7720 | OPTI_TYPE_NOT_ITERATED
7721 | OPTI_TYPE_APPENDED_SALT
7722 | OPTI_TYPE_RAW_HASH;
7723 dgst_pos0 = 3;
7724 dgst_pos1 = 7;
7725 dgst_pos2 = 2;
7726 dgst_pos3 = 6;
7727 break;
7728
7729 case 1420: hash_type = HASH_TYPE_SHA256;
7730 salt_type = SALT_TYPE_INTERN;
7731 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7732 opts_type = OPTS_TYPE_PT_GENERATE_BE
7733 | OPTS_TYPE_PT_ADD80
7734 | OPTS_TYPE_PT_ADDBITS15;
7735 kern_type = KERN_TYPE_SHA256_SLTPW;
7736 dgst_size = DGST_SIZE_4_8;
7737 parse_func = sha256s_parse_hash;
7738 sort_by_digest = sort_by_digest_4_8;
7739 opti_type = OPTI_TYPE_ZERO_BYTE
7740 | OPTI_TYPE_PRECOMPUTE_INIT
7741 | OPTI_TYPE_PRECOMPUTE_MERKLE
7742 | OPTI_TYPE_EARLY_SKIP
7743 | OPTI_TYPE_NOT_ITERATED
7744 | OPTI_TYPE_PREPENDED_SALT
7745 | OPTI_TYPE_RAW_HASH;
7746 dgst_pos0 = 3;
7747 dgst_pos1 = 7;
7748 dgst_pos2 = 2;
7749 dgst_pos3 = 6;
7750 break;
7751
7752 case 1421: hash_type = HASH_TYPE_SHA256;
7753 salt_type = SALT_TYPE_EMBEDDED;
7754 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7755 opts_type = OPTS_TYPE_PT_GENERATE_BE
7756 | OPTS_TYPE_PT_ADD80
7757 | OPTS_TYPE_PT_ADDBITS15;
7758 kern_type = KERN_TYPE_SHA256_SLTPW;
7759 dgst_size = DGST_SIZE_4_8;
7760 parse_func = hmailserver_parse_hash;
7761 sort_by_digest = sort_by_digest_4_8;
7762 opti_type = OPTI_TYPE_ZERO_BYTE
7763 | OPTI_TYPE_PRECOMPUTE_INIT
7764 | OPTI_TYPE_PRECOMPUTE_MERKLE
7765 | OPTI_TYPE_EARLY_SKIP
7766 | OPTI_TYPE_NOT_ITERATED
7767 | OPTI_TYPE_PREPENDED_SALT
7768 | OPTI_TYPE_RAW_HASH;
7769 dgst_pos0 = 3;
7770 dgst_pos1 = 7;
7771 dgst_pos2 = 2;
7772 dgst_pos3 = 6;
7773 break;
7774
7775 case 1430: hash_type = HASH_TYPE_SHA256;
7776 salt_type = SALT_TYPE_INTERN;
7777 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7778 opts_type = OPTS_TYPE_PT_GENERATE_BE
7779 | OPTS_TYPE_PT_UNICODE
7780 | OPTS_TYPE_ST_ADD80
7781 | OPTS_TYPE_ST_ADDBITS15;
7782 kern_type = KERN_TYPE_SHA256_PWUSLT;
7783 dgst_size = DGST_SIZE_4_8;
7784 parse_func = sha256s_parse_hash;
7785 sort_by_digest = sort_by_digest_4_8;
7786 opti_type = OPTI_TYPE_ZERO_BYTE
7787 | OPTI_TYPE_PRECOMPUTE_INIT
7788 | OPTI_TYPE_PRECOMPUTE_MERKLE
7789 | OPTI_TYPE_EARLY_SKIP
7790 | OPTI_TYPE_NOT_ITERATED
7791 | OPTI_TYPE_APPENDED_SALT
7792 | OPTI_TYPE_RAW_HASH;
7793 dgst_pos0 = 3;
7794 dgst_pos1 = 7;
7795 dgst_pos2 = 2;
7796 dgst_pos3 = 6;
7797 break;
7798
7799 case 1440: hash_type = HASH_TYPE_SHA256;
7800 salt_type = SALT_TYPE_INTERN;
7801 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7802 opts_type = OPTS_TYPE_PT_GENERATE_BE
7803 | OPTS_TYPE_PT_ADD80
7804 | OPTS_TYPE_PT_ADDBITS15
7805 | OPTS_TYPE_PT_UNICODE;
7806 kern_type = KERN_TYPE_SHA256_SLTPWU;
7807 dgst_size = DGST_SIZE_4_8;
7808 parse_func = sha256s_parse_hash;
7809 sort_by_digest = sort_by_digest_4_8;
7810 opti_type = OPTI_TYPE_ZERO_BYTE
7811 | OPTI_TYPE_PRECOMPUTE_INIT
7812 | OPTI_TYPE_PRECOMPUTE_MERKLE
7813 | OPTI_TYPE_EARLY_SKIP
7814 | OPTI_TYPE_NOT_ITERATED
7815 | OPTI_TYPE_PREPENDED_SALT
7816 | OPTI_TYPE_RAW_HASH;
7817 dgst_pos0 = 3;
7818 dgst_pos1 = 7;
7819 dgst_pos2 = 2;
7820 dgst_pos3 = 6;
7821 break;
7822
7823 case 1441: hash_type = HASH_TYPE_SHA256;
7824 salt_type = SALT_TYPE_EMBEDDED;
7825 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7826 opts_type = OPTS_TYPE_PT_GENERATE_BE
7827 | OPTS_TYPE_PT_ADD80
7828 | OPTS_TYPE_PT_ADDBITS15
7829 | OPTS_TYPE_PT_UNICODE
7830 | OPTS_TYPE_ST_BASE64;
7831 kern_type = KERN_TYPE_SHA256_SLTPWU;
7832 dgst_size = DGST_SIZE_4_8;
7833 parse_func = episerver4_parse_hash;
7834 sort_by_digest = sort_by_digest_4_8;
7835 opti_type = OPTI_TYPE_ZERO_BYTE
7836 | OPTI_TYPE_PRECOMPUTE_INIT
7837 | OPTI_TYPE_PRECOMPUTE_MERKLE
7838 | OPTI_TYPE_EARLY_SKIP
7839 | OPTI_TYPE_NOT_ITERATED
7840 | OPTI_TYPE_PREPENDED_SALT
7841 | OPTI_TYPE_RAW_HASH;
7842 dgst_pos0 = 3;
7843 dgst_pos1 = 7;
7844 dgst_pos2 = 2;
7845 dgst_pos3 = 6;
7846 break;
7847
7848 case 1450: hash_type = HASH_TYPE_SHA256;
7849 salt_type = SALT_TYPE_INTERN;
7850 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7851 opts_type = OPTS_TYPE_PT_GENERATE_BE
7852 | OPTS_TYPE_ST_ADD80;
7853 kern_type = KERN_TYPE_HMACSHA256_PW;
7854 dgst_size = DGST_SIZE_4_8;
7855 parse_func = hmacsha256_parse_hash;
7856 sort_by_digest = sort_by_digest_4_8;
7857 opti_type = OPTI_TYPE_ZERO_BYTE
7858 | OPTI_TYPE_NOT_ITERATED;
7859 dgst_pos0 = 3;
7860 dgst_pos1 = 7;
7861 dgst_pos2 = 2;
7862 dgst_pos3 = 6;
7863 break;
7864
7865 case 1460: hash_type = HASH_TYPE_SHA256;
7866 salt_type = SALT_TYPE_INTERN;
7867 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7868 opts_type = OPTS_TYPE_PT_GENERATE_BE
7869 | OPTS_TYPE_PT_ADD80
7870 | OPTS_TYPE_PT_ADDBITS15;
7871 kern_type = KERN_TYPE_HMACSHA256_SLT;
7872 dgst_size = DGST_SIZE_4_8;
7873 parse_func = hmacsha256_parse_hash;
7874 sort_by_digest = sort_by_digest_4_8;
7875 opti_type = OPTI_TYPE_ZERO_BYTE
7876 | OPTI_TYPE_NOT_ITERATED;
7877 dgst_pos0 = 3;
7878 dgst_pos1 = 7;
7879 dgst_pos2 = 2;
7880 dgst_pos3 = 6;
7881 break;
7882
7883 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7884 salt_type = SALT_TYPE_EMBEDDED;
7885 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7886 opts_type = OPTS_TYPE_PT_GENERATE_LE
7887 | OPTS_TYPE_PT_BITSLICE;
7888 kern_type = KERN_TYPE_DESCRYPT;
7889 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7890 parse_func = descrypt_parse_hash;
7891 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7892 opti_type = OPTI_TYPE_ZERO_BYTE
7893 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7894 dgst_pos0 = 0;
7895 dgst_pos1 = 1;
7896 dgst_pos2 = 2;
7897 dgst_pos3 = 3;
7898 break;
7899
7900 case 1600: hash_type = HASH_TYPE_MD5;
7901 salt_type = SALT_TYPE_EMBEDDED;
7902 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7903 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7904 kern_type = KERN_TYPE_APR1CRYPT;
7905 dgst_size = DGST_SIZE_4_4;
7906 parse_func = md5apr1_parse_hash;
7907 sort_by_digest = sort_by_digest_4_4;
7908 opti_type = OPTI_TYPE_ZERO_BYTE;
7909 dgst_pos0 = 0;
7910 dgst_pos1 = 1;
7911 dgst_pos2 = 2;
7912 dgst_pos3 = 3;
7913 break;
7914
7915 case 1700: hash_type = HASH_TYPE_SHA512;
7916 salt_type = SALT_TYPE_NONE;
7917 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7918 opts_type = OPTS_TYPE_PT_GENERATE_BE
7919 | OPTS_TYPE_PT_ADD80
7920 | OPTS_TYPE_PT_ADDBITS15;
7921 kern_type = KERN_TYPE_SHA512;
7922 dgst_size = DGST_SIZE_8_8;
7923 parse_func = sha512_parse_hash;
7924 sort_by_digest = sort_by_digest_8_8;
7925 opti_type = OPTI_TYPE_ZERO_BYTE
7926 | OPTI_TYPE_PRECOMPUTE_INIT
7927 | OPTI_TYPE_PRECOMPUTE_MERKLE
7928 | OPTI_TYPE_EARLY_SKIP
7929 | OPTI_TYPE_NOT_ITERATED
7930 | OPTI_TYPE_NOT_SALTED
7931 | OPTI_TYPE_USES_BITS_64
7932 | OPTI_TYPE_RAW_HASH;
7933 dgst_pos0 = 14;
7934 dgst_pos1 = 15;
7935 dgst_pos2 = 6;
7936 dgst_pos3 = 7;
7937 break;
7938
7939 case 1710: hash_type = HASH_TYPE_SHA512;
7940 salt_type = SALT_TYPE_INTERN;
7941 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7942 opts_type = OPTS_TYPE_PT_GENERATE_BE
7943 | OPTS_TYPE_ST_ADD80
7944 | OPTS_TYPE_ST_ADDBITS15;
7945 kern_type = KERN_TYPE_SHA512_PWSLT;
7946 dgst_size = DGST_SIZE_8_8;
7947 parse_func = sha512s_parse_hash;
7948 sort_by_digest = sort_by_digest_8_8;
7949 opti_type = OPTI_TYPE_ZERO_BYTE
7950 | OPTI_TYPE_PRECOMPUTE_INIT
7951 | OPTI_TYPE_PRECOMPUTE_MERKLE
7952 | OPTI_TYPE_EARLY_SKIP
7953 | OPTI_TYPE_NOT_ITERATED
7954 | OPTI_TYPE_APPENDED_SALT
7955 | OPTI_TYPE_USES_BITS_64
7956 | OPTI_TYPE_RAW_HASH;
7957 dgst_pos0 = 14;
7958 dgst_pos1 = 15;
7959 dgst_pos2 = 6;
7960 dgst_pos3 = 7;
7961 break;
7962
7963 case 1711: hash_type = HASH_TYPE_SHA512;
7964 salt_type = SALT_TYPE_EMBEDDED;
7965 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7966 opts_type = OPTS_TYPE_PT_GENERATE_BE
7967 | OPTS_TYPE_ST_ADD80
7968 | OPTS_TYPE_ST_ADDBITS15;
7969 kern_type = KERN_TYPE_SHA512_PWSLT;
7970 dgst_size = DGST_SIZE_8_8;
7971 parse_func = sha512b64s_parse_hash;
7972 sort_by_digest = sort_by_digest_8_8;
7973 opti_type = OPTI_TYPE_ZERO_BYTE
7974 | OPTI_TYPE_PRECOMPUTE_INIT
7975 | OPTI_TYPE_PRECOMPUTE_MERKLE
7976 | OPTI_TYPE_EARLY_SKIP
7977 | OPTI_TYPE_NOT_ITERATED
7978 | OPTI_TYPE_APPENDED_SALT
7979 | OPTI_TYPE_USES_BITS_64
7980 | OPTI_TYPE_RAW_HASH;
7981 dgst_pos0 = 14;
7982 dgst_pos1 = 15;
7983 dgst_pos2 = 6;
7984 dgst_pos3 = 7;
7985 break;
7986
7987 case 1720: hash_type = HASH_TYPE_SHA512;
7988 salt_type = SALT_TYPE_INTERN;
7989 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7990 opts_type = OPTS_TYPE_PT_GENERATE_BE
7991 | OPTS_TYPE_PT_ADD80
7992 | OPTS_TYPE_PT_ADDBITS15;
7993 kern_type = KERN_TYPE_SHA512_SLTPW;
7994 dgst_size = DGST_SIZE_8_8;
7995 parse_func = sha512s_parse_hash;
7996 sort_by_digest = sort_by_digest_8_8;
7997 opti_type = OPTI_TYPE_ZERO_BYTE
7998 | OPTI_TYPE_PRECOMPUTE_INIT
7999 | OPTI_TYPE_PRECOMPUTE_MERKLE
8000 | OPTI_TYPE_EARLY_SKIP
8001 | OPTI_TYPE_NOT_ITERATED
8002 | OPTI_TYPE_PREPENDED_SALT
8003 | OPTI_TYPE_USES_BITS_64
8004 | OPTI_TYPE_RAW_HASH;
8005 dgst_pos0 = 14;
8006 dgst_pos1 = 15;
8007 dgst_pos2 = 6;
8008 dgst_pos3 = 7;
8009 break;
8010
8011 case 1722: hash_type = HASH_TYPE_SHA512;
8012 salt_type = SALT_TYPE_EMBEDDED;
8013 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8014 opts_type = OPTS_TYPE_PT_GENERATE_BE
8015 | OPTS_TYPE_PT_ADD80
8016 | OPTS_TYPE_PT_ADDBITS15
8017 | OPTS_TYPE_ST_HEX;
8018 kern_type = KERN_TYPE_SHA512_SLTPW;
8019 dgst_size = DGST_SIZE_8_8;
8020 parse_func = osx512_parse_hash;
8021 sort_by_digest = sort_by_digest_8_8;
8022 opti_type = OPTI_TYPE_ZERO_BYTE
8023 | OPTI_TYPE_PRECOMPUTE_INIT
8024 | OPTI_TYPE_PRECOMPUTE_MERKLE
8025 | OPTI_TYPE_EARLY_SKIP
8026 | OPTI_TYPE_NOT_ITERATED
8027 | OPTI_TYPE_PREPENDED_SALT
8028 | OPTI_TYPE_USES_BITS_64
8029 | OPTI_TYPE_RAW_HASH;
8030 dgst_pos0 = 14;
8031 dgst_pos1 = 15;
8032 dgst_pos2 = 6;
8033 dgst_pos3 = 7;
8034 break;
8035
8036 case 1730: hash_type = HASH_TYPE_SHA512;
8037 salt_type = SALT_TYPE_INTERN;
8038 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8039 opts_type = OPTS_TYPE_PT_GENERATE_BE
8040 | OPTS_TYPE_PT_UNICODE
8041 | OPTS_TYPE_ST_ADD80
8042 | OPTS_TYPE_ST_ADDBITS15;
8043 kern_type = KERN_TYPE_SHA512_PWSLTU;
8044 dgst_size = DGST_SIZE_8_8;
8045 parse_func = sha512s_parse_hash;
8046 sort_by_digest = sort_by_digest_8_8;
8047 opti_type = OPTI_TYPE_ZERO_BYTE
8048 | OPTI_TYPE_PRECOMPUTE_INIT
8049 | OPTI_TYPE_PRECOMPUTE_MERKLE
8050 | OPTI_TYPE_EARLY_SKIP
8051 | OPTI_TYPE_NOT_ITERATED
8052 | OPTI_TYPE_APPENDED_SALT
8053 | OPTI_TYPE_USES_BITS_64
8054 | OPTI_TYPE_RAW_HASH;
8055 dgst_pos0 = 14;
8056 dgst_pos1 = 15;
8057 dgst_pos2 = 6;
8058 dgst_pos3 = 7;
8059 break;
8060
8061 case 1731: hash_type = HASH_TYPE_SHA512;
8062 salt_type = SALT_TYPE_EMBEDDED;
8063 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8064 opts_type = OPTS_TYPE_PT_GENERATE_BE
8065 | OPTS_TYPE_PT_UNICODE
8066 | OPTS_TYPE_ST_ADD80
8067 | OPTS_TYPE_ST_ADDBITS15
8068 | OPTS_TYPE_ST_HEX;
8069 kern_type = KERN_TYPE_SHA512_PWSLTU;
8070 dgst_size = DGST_SIZE_8_8;
8071 parse_func = mssql2012_parse_hash;
8072 sort_by_digest = sort_by_digest_8_8;
8073 opti_type = OPTI_TYPE_ZERO_BYTE
8074 | OPTI_TYPE_PRECOMPUTE_INIT
8075 | OPTI_TYPE_PRECOMPUTE_MERKLE
8076 | OPTI_TYPE_EARLY_SKIP
8077 | OPTI_TYPE_NOT_ITERATED
8078 | OPTI_TYPE_APPENDED_SALT
8079 | OPTI_TYPE_USES_BITS_64
8080 | OPTI_TYPE_RAW_HASH;
8081 dgst_pos0 = 14;
8082 dgst_pos1 = 15;
8083 dgst_pos2 = 6;
8084 dgst_pos3 = 7;
8085 break;
8086
8087 case 1740: hash_type = HASH_TYPE_SHA512;
8088 salt_type = SALT_TYPE_INTERN;
8089 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8090 opts_type = OPTS_TYPE_PT_GENERATE_BE
8091 | OPTS_TYPE_PT_ADD80
8092 | OPTS_TYPE_PT_ADDBITS15
8093 | OPTS_TYPE_PT_UNICODE;
8094 kern_type = KERN_TYPE_SHA512_SLTPWU;
8095 dgst_size = DGST_SIZE_8_8;
8096 parse_func = sha512s_parse_hash;
8097 sort_by_digest = sort_by_digest_8_8;
8098 opti_type = OPTI_TYPE_ZERO_BYTE
8099 | OPTI_TYPE_PRECOMPUTE_INIT
8100 | OPTI_TYPE_PRECOMPUTE_MERKLE
8101 | OPTI_TYPE_EARLY_SKIP
8102 | OPTI_TYPE_NOT_ITERATED
8103 | OPTI_TYPE_PREPENDED_SALT
8104 | OPTI_TYPE_USES_BITS_64
8105 | OPTI_TYPE_RAW_HASH;
8106 dgst_pos0 = 14;
8107 dgst_pos1 = 15;
8108 dgst_pos2 = 6;
8109 dgst_pos3 = 7;
8110 break;
8111
8112 case 1750: hash_type = HASH_TYPE_SHA512;
8113 salt_type = SALT_TYPE_INTERN;
8114 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8115 opts_type = OPTS_TYPE_PT_GENERATE_BE
8116 | OPTS_TYPE_ST_ADD80;
8117 kern_type = KERN_TYPE_HMACSHA512_PW;
8118 dgst_size = DGST_SIZE_8_8;
8119 parse_func = hmacsha512_parse_hash;
8120 sort_by_digest = sort_by_digest_8_8;
8121 opti_type = OPTI_TYPE_ZERO_BYTE
8122 | OPTI_TYPE_USES_BITS_64
8123 | OPTI_TYPE_NOT_ITERATED;
8124 dgst_pos0 = 14;
8125 dgst_pos1 = 15;
8126 dgst_pos2 = 6;
8127 dgst_pos3 = 7;
8128 break;
8129
8130 case 1760: hash_type = HASH_TYPE_SHA512;
8131 salt_type = SALT_TYPE_INTERN;
8132 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8133 opts_type = OPTS_TYPE_PT_GENERATE_BE
8134 | OPTS_TYPE_PT_ADD80
8135 | OPTS_TYPE_PT_ADDBITS15;
8136 kern_type = KERN_TYPE_HMACSHA512_SLT;
8137 dgst_size = DGST_SIZE_8_8;
8138 parse_func = hmacsha512_parse_hash;
8139 sort_by_digest = sort_by_digest_8_8;
8140 opti_type = OPTI_TYPE_ZERO_BYTE
8141 | OPTI_TYPE_USES_BITS_64
8142 | OPTI_TYPE_NOT_ITERATED;
8143 dgst_pos0 = 14;
8144 dgst_pos1 = 15;
8145 dgst_pos2 = 6;
8146 dgst_pos3 = 7;
8147 break;
8148
8149 case 1800: hash_type = HASH_TYPE_SHA512;
8150 salt_type = SALT_TYPE_EMBEDDED;
8151 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8152 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8153 kern_type = KERN_TYPE_SHA512CRYPT;
8154 dgst_size = DGST_SIZE_8_8;
8155 parse_func = sha512crypt_parse_hash;
8156 sort_by_digest = sort_by_digest_8_8;
8157 opti_type = OPTI_TYPE_ZERO_BYTE
8158 | OPTI_TYPE_USES_BITS_64;
8159 dgst_pos0 = 0;
8160 dgst_pos1 = 1;
8161 dgst_pos2 = 2;
8162 dgst_pos3 = 3;
8163 break;
8164
8165 case 2100: hash_type = HASH_TYPE_DCC2;
8166 salt_type = SALT_TYPE_EMBEDDED;
8167 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8168 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8169 | OPTS_TYPE_ST_LOWER
8170 | OPTS_TYPE_ST_UNICODE;
8171 kern_type = KERN_TYPE_DCC2;
8172 dgst_size = DGST_SIZE_4_4;
8173 parse_func = dcc2_parse_hash;
8174 sort_by_digest = sort_by_digest_4_4;
8175 opti_type = OPTI_TYPE_ZERO_BYTE;
8176 dgst_pos0 = 0;
8177 dgst_pos1 = 1;
8178 dgst_pos2 = 2;
8179 dgst_pos3 = 3;
8180 break;
8181
8182 case 2400: hash_type = HASH_TYPE_MD5;
8183 salt_type = SALT_TYPE_NONE;
8184 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8185 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8186 kern_type = KERN_TYPE_MD5PIX;
8187 dgst_size = DGST_SIZE_4_4;
8188 parse_func = md5pix_parse_hash;
8189 sort_by_digest = sort_by_digest_4_4;
8190 opti_type = OPTI_TYPE_ZERO_BYTE
8191 | OPTI_TYPE_PRECOMPUTE_INIT
8192 | OPTI_TYPE_PRECOMPUTE_MERKLE
8193 | OPTI_TYPE_EARLY_SKIP
8194 | OPTI_TYPE_NOT_ITERATED
8195 | OPTI_TYPE_NOT_SALTED;
8196 dgst_pos0 = 0;
8197 dgst_pos1 = 3;
8198 dgst_pos2 = 2;
8199 dgst_pos3 = 1;
8200 break;
8201
8202 case 2410: hash_type = HASH_TYPE_MD5;
8203 salt_type = SALT_TYPE_INTERN;
8204 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8205 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8206 kern_type = KERN_TYPE_MD5ASA;
8207 dgst_size = DGST_SIZE_4_4;
8208 parse_func = md5asa_parse_hash;
8209 sort_by_digest = sort_by_digest_4_4;
8210 opti_type = OPTI_TYPE_ZERO_BYTE
8211 | OPTI_TYPE_PRECOMPUTE_INIT
8212 | OPTI_TYPE_PRECOMPUTE_MERKLE
8213 | OPTI_TYPE_EARLY_SKIP
8214 | OPTI_TYPE_NOT_ITERATED;
8215 dgst_pos0 = 0;
8216 dgst_pos1 = 3;
8217 dgst_pos2 = 2;
8218 dgst_pos3 = 1;
8219 break;
8220
8221 case 2500: hash_type = HASH_TYPE_WPA;
8222 salt_type = SALT_TYPE_EMBEDDED;
8223 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8224 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8225 kern_type = KERN_TYPE_WPA;
8226 dgst_size = DGST_SIZE_4_4;
8227 parse_func = wpa_parse_hash;
8228 sort_by_digest = sort_by_digest_4_4;
8229 opti_type = OPTI_TYPE_ZERO_BYTE;
8230 dgst_pos0 = 0;
8231 dgst_pos1 = 1;
8232 dgst_pos2 = 2;
8233 dgst_pos3 = 3;
8234 break;
8235
8236 case 2600: hash_type = HASH_TYPE_MD5;
8237 salt_type = SALT_TYPE_VIRTUAL;
8238 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8239 opts_type = OPTS_TYPE_PT_GENERATE_LE
8240 | OPTS_TYPE_PT_ADD80
8241 | OPTS_TYPE_PT_ADDBITS14
8242 | OPTS_TYPE_ST_ADD80;
8243 kern_type = KERN_TYPE_MD55_PWSLT1;
8244 dgst_size = DGST_SIZE_4_4;
8245 parse_func = md5md5_parse_hash;
8246 sort_by_digest = sort_by_digest_4_4;
8247 opti_type = OPTI_TYPE_ZERO_BYTE
8248 | OPTI_TYPE_PRECOMPUTE_INIT
8249 | OPTI_TYPE_PRECOMPUTE_MERKLE
8250 | OPTI_TYPE_EARLY_SKIP;
8251 dgst_pos0 = 0;
8252 dgst_pos1 = 3;
8253 dgst_pos2 = 2;
8254 dgst_pos3 = 1;
8255 break;
8256
8257 case 2611: hash_type = HASH_TYPE_MD5;
8258 salt_type = SALT_TYPE_INTERN;
8259 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8260 opts_type = OPTS_TYPE_PT_GENERATE_LE
8261 | OPTS_TYPE_PT_ADD80
8262 | OPTS_TYPE_PT_ADDBITS14
8263 | OPTS_TYPE_ST_ADD80;
8264 kern_type = KERN_TYPE_MD55_PWSLT1;
8265 dgst_size = DGST_SIZE_4_4;
8266 parse_func = vb3_parse_hash;
8267 sort_by_digest = sort_by_digest_4_4;
8268 opti_type = OPTI_TYPE_ZERO_BYTE
8269 | OPTI_TYPE_PRECOMPUTE_INIT
8270 | OPTI_TYPE_PRECOMPUTE_MERKLE
8271 | OPTI_TYPE_EARLY_SKIP;
8272 dgst_pos0 = 0;
8273 dgst_pos1 = 3;
8274 dgst_pos2 = 2;
8275 dgst_pos3 = 1;
8276 break;
8277
8278 case 2612: hash_type = HASH_TYPE_MD5;
8279 salt_type = SALT_TYPE_EMBEDDED;
8280 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8281 opts_type = OPTS_TYPE_PT_GENERATE_LE
8282 | OPTS_TYPE_PT_ADD80
8283 | OPTS_TYPE_PT_ADDBITS14
8284 | OPTS_TYPE_ST_ADD80
8285 | OPTS_TYPE_ST_HEX;
8286 kern_type = KERN_TYPE_MD55_PWSLT1;
8287 dgst_size = DGST_SIZE_4_4;
8288 parse_func = phps_parse_hash;
8289 sort_by_digest = sort_by_digest_4_4;
8290 opti_type = OPTI_TYPE_ZERO_BYTE
8291 | OPTI_TYPE_PRECOMPUTE_INIT
8292 | OPTI_TYPE_PRECOMPUTE_MERKLE
8293 | OPTI_TYPE_EARLY_SKIP;
8294 dgst_pos0 = 0;
8295 dgst_pos1 = 3;
8296 dgst_pos2 = 2;
8297 dgst_pos3 = 1;
8298 break;
8299
8300 case 2711: hash_type = HASH_TYPE_MD5;
8301 salt_type = SALT_TYPE_INTERN;
8302 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8303 opts_type = OPTS_TYPE_PT_GENERATE_LE
8304 | OPTS_TYPE_PT_ADD80
8305 | OPTS_TYPE_PT_ADDBITS14
8306 | OPTS_TYPE_ST_ADD80;
8307 kern_type = KERN_TYPE_MD55_PWSLT2;
8308 dgst_size = DGST_SIZE_4_4;
8309 parse_func = vb30_parse_hash;
8310 sort_by_digest = sort_by_digest_4_4;
8311 opti_type = OPTI_TYPE_ZERO_BYTE
8312 | OPTI_TYPE_PRECOMPUTE_INIT
8313 | OPTI_TYPE_EARLY_SKIP;
8314 dgst_pos0 = 0;
8315 dgst_pos1 = 3;
8316 dgst_pos2 = 2;
8317 dgst_pos3 = 1;
8318 break;
8319
8320 case 2811: hash_type = HASH_TYPE_MD5;
8321 salt_type = SALT_TYPE_INTERN;
8322 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8323 opts_type = OPTS_TYPE_PT_GENERATE_LE
8324 | OPTS_TYPE_PT_ADD80
8325 | OPTS_TYPE_PT_ADDBITS14;
8326 kern_type = KERN_TYPE_MD55_SLTPW;
8327 dgst_size = DGST_SIZE_4_4;
8328 parse_func = ipb2_parse_hash;
8329 sort_by_digest = sort_by_digest_4_4;
8330 opti_type = OPTI_TYPE_ZERO_BYTE
8331 | OPTI_TYPE_PRECOMPUTE_INIT
8332 | OPTI_TYPE_EARLY_SKIP;
8333 dgst_pos0 = 0;
8334 dgst_pos1 = 3;
8335 dgst_pos2 = 2;
8336 dgst_pos3 = 1;
8337 break;
8338
8339 case 3000: hash_type = HASH_TYPE_LM;
8340 salt_type = SALT_TYPE_NONE;
8341 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8342 opts_type = OPTS_TYPE_PT_GENERATE_LE
8343 | OPTS_TYPE_PT_UPPER
8344 | OPTS_TYPE_PT_BITSLICE;
8345 kern_type = KERN_TYPE_LM;
8346 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8347 parse_func = lm_parse_hash;
8348 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8349 opti_type = OPTI_TYPE_ZERO_BYTE
8350 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8351 dgst_pos0 = 0;
8352 dgst_pos1 = 1;
8353 dgst_pos2 = 2;
8354 dgst_pos3 = 3;
8355 break;
8356
8357 case 3100: hash_type = HASH_TYPE_ORACLEH;
8358 salt_type = SALT_TYPE_INTERN;
8359 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8360 opts_type = OPTS_TYPE_PT_GENERATE_LE
8361 | OPTS_TYPE_PT_UPPER
8362 | OPTS_TYPE_ST_UPPER;
8363 kern_type = KERN_TYPE_ORACLEH;
8364 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8365 parse_func = oracleh_parse_hash;
8366 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8367 opti_type = OPTI_TYPE_ZERO_BYTE;
8368 dgst_pos0 = 0;
8369 dgst_pos1 = 1;
8370 dgst_pos2 = 2;
8371 dgst_pos3 = 3;
8372 break;
8373
8374 case 3200: hash_type = HASH_TYPE_BCRYPT;
8375 salt_type = SALT_TYPE_EMBEDDED;
8376 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8377 opts_type = OPTS_TYPE_PT_GENERATE_LE
8378 | OPTS_TYPE_ST_GENERATE_LE;
8379 kern_type = KERN_TYPE_BCRYPT;
8380 dgst_size = DGST_SIZE_4_6;
8381 parse_func = bcrypt_parse_hash;
8382 sort_by_digest = sort_by_digest_4_6;
8383 opti_type = OPTI_TYPE_ZERO_BYTE;
8384 dgst_pos0 = 0;
8385 dgst_pos1 = 1;
8386 dgst_pos2 = 2;
8387 dgst_pos3 = 3;
8388 break;
8389
8390 case 3710: hash_type = HASH_TYPE_MD5;
8391 salt_type = SALT_TYPE_INTERN;
8392 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8393 opts_type = OPTS_TYPE_PT_GENERATE_LE
8394 | OPTS_TYPE_PT_ADD80
8395 | OPTS_TYPE_PT_ADDBITS14;
8396 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8397 dgst_size = DGST_SIZE_4_4;
8398 parse_func = md5s_parse_hash;
8399 sort_by_digest = sort_by_digest_4_4;
8400 opti_type = OPTI_TYPE_ZERO_BYTE
8401 | OPTI_TYPE_PRECOMPUTE_INIT
8402 | OPTI_TYPE_PRECOMPUTE_MERKLE
8403 | OPTI_TYPE_EARLY_SKIP;
8404 dgst_pos0 = 0;
8405 dgst_pos1 = 3;
8406 dgst_pos2 = 2;
8407 dgst_pos3 = 1;
8408 break;
8409
8410 case 3711: hash_type = HASH_TYPE_MD5;
8411 salt_type = SALT_TYPE_EMBEDDED;
8412 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8413 opts_type = OPTS_TYPE_PT_GENERATE_LE
8414 | OPTS_TYPE_PT_ADD80
8415 | OPTS_TYPE_PT_ADDBITS14;
8416 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8417 dgst_size = DGST_SIZE_4_4;
8418 parse_func = mediawiki_b_parse_hash;
8419 sort_by_digest = sort_by_digest_4_4;
8420 opti_type = OPTI_TYPE_ZERO_BYTE
8421 | OPTI_TYPE_PRECOMPUTE_INIT
8422 | OPTI_TYPE_PRECOMPUTE_MERKLE
8423 | OPTI_TYPE_EARLY_SKIP;
8424 dgst_pos0 = 0;
8425 dgst_pos1 = 3;
8426 dgst_pos2 = 2;
8427 dgst_pos3 = 1;
8428 break;
8429
8430 case 3800: hash_type = HASH_TYPE_MD5;
8431 salt_type = SALT_TYPE_INTERN;
8432 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8433 opts_type = OPTS_TYPE_PT_GENERATE_LE
8434 | OPTS_TYPE_ST_ADDBITS14;
8435 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8436 dgst_size = DGST_SIZE_4_4;
8437 parse_func = md5s_parse_hash;
8438 sort_by_digest = sort_by_digest_4_4;
8439 opti_type = OPTI_TYPE_ZERO_BYTE
8440 | OPTI_TYPE_PRECOMPUTE_INIT
8441 | OPTI_TYPE_PRECOMPUTE_MERKLE
8442 | OPTI_TYPE_EARLY_SKIP
8443 | OPTI_TYPE_NOT_ITERATED
8444 | OPTI_TYPE_RAW_HASH;
8445 dgst_pos0 = 0;
8446 dgst_pos1 = 3;
8447 dgst_pos2 = 2;
8448 dgst_pos3 = 1;
8449 break;
8450
8451 case 4300: hash_type = HASH_TYPE_MD5;
8452 salt_type = SALT_TYPE_VIRTUAL;
8453 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8454 opts_type = OPTS_TYPE_PT_GENERATE_LE
8455 | OPTS_TYPE_PT_ADD80
8456 | OPTS_TYPE_PT_ADDBITS14
8457 | OPTS_TYPE_ST_ADD80;
8458 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8459 dgst_size = DGST_SIZE_4_4;
8460 parse_func = md5md5_parse_hash;
8461 sort_by_digest = sort_by_digest_4_4;
8462 opti_type = OPTI_TYPE_ZERO_BYTE
8463 | OPTI_TYPE_PRECOMPUTE_INIT
8464 | OPTI_TYPE_PRECOMPUTE_MERKLE
8465 | OPTI_TYPE_EARLY_SKIP;
8466 dgst_pos0 = 0;
8467 dgst_pos1 = 3;
8468 dgst_pos2 = 2;
8469 dgst_pos3 = 1;
8470 break;
8471
8472
8473 case 4400: hash_type = HASH_TYPE_MD5;
8474 salt_type = SALT_TYPE_NONE;
8475 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8476 opts_type = OPTS_TYPE_PT_GENERATE_BE
8477 | OPTS_TYPE_PT_ADD80
8478 | OPTS_TYPE_PT_ADDBITS15;
8479 kern_type = KERN_TYPE_MD5_SHA1;
8480 dgst_size = DGST_SIZE_4_4;
8481 parse_func = md5_parse_hash;
8482 sort_by_digest = sort_by_digest_4_4;
8483 opti_type = OPTI_TYPE_ZERO_BYTE
8484 | OPTI_TYPE_PRECOMPUTE_INIT
8485 | OPTI_TYPE_PRECOMPUTE_MERKLE
8486 | OPTI_TYPE_EARLY_SKIP
8487 | OPTI_TYPE_NOT_ITERATED
8488 | OPTI_TYPE_NOT_SALTED
8489 | OPTI_TYPE_RAW_HASH;
8490 dgst_pos0 = 0;
8491 dgst_pos1 = 3;
8492 dgst_pos2 = 2;
8493 dgst_pos3 = 1;
8494 break;
8495
8496 case 4500: hash_type = HASH_TYPE_SHA1;
8497 salt_type = SALT_TYPE_NONE;
8498 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8499 opts_type = OPTS_TYPE_PT_GENERATE_BE
8500 | OPTS_TYPE_PT_ADD80
8501 | OPTS_TYPE_PT_ADDBITS15;
8502 kern_type = KERN_TYPE_SHA11;
8503 dgst_size = DGST_SIZE_4_5;
8504 parse_func = sha1_parse_hash;
8505 sort_by_digest = sort_by_digest_4_5;
8506 opti_type = OPTI_TYPE_ZERO_BYTE
8507 | OPTI_TYPE_PRECOMPUTE_INIT
8508 | OPTI_TYPE_PRECOMPUTE_MERKLE
8509 | OPTI_TYPE_EARLY_SKIP
8510 | OPTI_TYPE_NOT_SALTED;
8511 dgst_pos0 = 3;
8512 dgst_pos1 = 4;
8513 dgst_pos2 = 2;
8514 dgst_pos3 = 1;
8515 break;
8516
8517 case 4700: hash_type = HASH_TYPE_SHA1;
8518 salt_type = SALT_TYPE_NONE;
8519 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8520 opts_type = OPTS_TYPE_PT_GENERATE_LE
8521 | OPTS_TYPE_PT_ADD80
8522 | OPTS_TYPE_PT_ADDBITS14;
8523 kern_type = KERN_TYPE_SHA1_MD5;
8524 dgst_size = DGST_SIZE_4_5;
8525 parse_func = sha1_parse_hash;
8526 sort_by_digest = sort_by_digest_4_5;
8527 opti_type = OPTI_TYPE_ZERO_BYTE
8528 | OPTI_TYPE_PRECOMPUTE_INIT
8529 | OPTI_TYPE_PRECOMPUTE_MERKLE
8530 | OPTI_TYPE_EARLY_SKIP
8531 | OPTI_TYPE_NOT_ITERATED
8532 | OPTI_TYPE_NOT_SALTED
8533 | OPTI_TYPE_RAW_HASH;
8534 dgst_pos0 = 3;
8535 dgst_pos1 = 4;
8536 dgst_pos2 = 2;
8537 dgst_pos3 = 1;
8538 break;
8539
8540 case 4800: hash_type = HASH_TYPE_MD5;
8541 salt_type = SALT_TYPE_EMBEDDED;
8542 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8543 opts_type = OPTS_TYPE_PT_GENERATE_LE
8544 | OPTS_TYPE_PT_ADDBITS14;
8545 kern_type = KERN_TYPE_MD5_CHAP;
8546 dgst_size = DGST_SIZE_4_4;
8547 parse_func = chap_parse_hash;
8548 sort_by_digest = sort_by_digest_4_4;
8549 opti_type = OPTI_TYPE_ZERO_BYTE
8550 | OPTI_TYPE_PRECOMPUTE_INIT
8551 | OPTI_TYPE_PRECOMPUTE_MERKLE
8552 | OPTI_TYPE_MEET_IN_MIDDLE
8553 | OPTI_TYPE_EARLY_SKIP
8554 | OPTI_TYPE_NOT_ITERATED
8555 | OPTI_TYPE_RAW_HASH;
8556 dgst_pos0 = 0;
8557 dgst_pos1 = 3;
8558 dgst_pos2 = 2;
8559 dgst_pos3 = 1;
8560 break;
8561
8562 case 4900: hash_type = HASH_TYPE_SHA1;
8563 salt_type = SALT_TYPE_INTERN;
8564 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8565 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8566 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8567 dgst_size = DGST_SIZE_4_5;
8568 parse_func = sha1s_parse_hash;
8569 sort_by_digest = sort_by_digest_4_5;
8570 opti_type = OPTI_TYPE_ZERO_BYTE
8571 | OPTI_TYPE_PRECOMPUTE_INIT
8572 | OPTI_TYPE_PRECOMPUTE_MERKLE
8573 | OPTI_TYPE_EARLY_SKIP;
8574 dgst_pos0 = 3;
8575 dgst_pos1 = 4;
8576 dgst_pos2 = 2;
8577 dgst_pos3 = 1;
8578 break;
8579
8580 case 5000: hash_type = HASH_TYPE_KECCAK;
8581 salt_type = SALT_TYPE_EMBEDDED;
8582 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8583 opts_type = OPTS_TYPE_PT_GENERATE_LE
8584 | OPTS_TYPE_PT_ADD01;
8585 kern_type = KERN_TYPE_KECCAK;
8586 dgst_size = DGST_SIZE_8_25;
8587 parse_func = keccak_parse_hash;
8588 sort_by_digest = sort_by_digest_8_25;
8589 opti_type = OPTI_TYPE_ZERO_BYTE
8590 | OPTI_TYPE_USES_BITS_64
8591 | OPTI_TYPE_RAW_HASH;
8592 dgst_pos0 = 2;
8593 dgst_pos1 = 3;
8594 dgst_pos2 = 4;
8595 dgst_pos3 = 5;
8596 break;
8597
8598 case 5100: hash_type = HASH_TYPE_MD5H;
8599 salt_type = SALT_TYPE_NONE;
8600 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8601 opts_type = OPTS_TYPE_PT_GENERATE_LE
8602 | OPTS_TYPE_PT_ADD80
8603 | OPTS_TYPE_PT_ADDBITS14;
8604 kern_type = KERN_TYPE_MD5H;
8605 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8606 parse_func = md5half_parse_hash;
8607 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8608 opti_type = OPTI_TYPE_ZERO_BYTE
8609 | OPTI_TYPE_RAW_HASH;
8610 dgst_pos0 = 0;
8611 dgst_pos1 = 1;
8612 dgst_pos2 = 2;
8613 dgst_pos3 = 3;
8614 break;
8615
8616 case 5200: hash_type = HASH_TYPE_SHA256;
8617 salt_type = SALT_TYPE_EMBEDDED;
8618 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8619 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8620 kern_type = KERN_TYPE_PSAFE3;
8621 dgst_size = DGST_SIZE_4_8;
8622 parse_func = psafe3_parse_hash;
8623 sort_by_digest = sort_by_digest_4_8;
8624 opti_type = OPTI_TYPE_ZERO_BYTE;
8625 dgst_pos0 = 0;
8626 dgst_pos1 = 1;
8627 dgst_pos2 = 2;
8628 dgst_pos3 = 3;
8629 break;
8630
8631 case 5300: hash_type = HASH_TYPE_MD5;
8632 salt_type = SALT_TYPE_EMBEDDED;
8633 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8634 opts_type = OPTS_TYPE_PT_GENERATE_LE
8635 | OPTS_TYPE_ST_ADD80;
8636 kern_type = KERN_TYPE_IKEPSK_MD5;
8637 dgst_size = DGST_SIZE_4_4;
8638 parse_func = ikepsk_md5_parse_hash;
8639 sort_by_digest = sort_by_digest_4_4;
8640 opti_type = OPTI_TYPE_ZERO_BYTE;
8641 dgst_pos0 = 0;
8642 dgst_pos1 = 3;
8643 dgst_pos2 = 2;
8644 dgst_pos3 = 1;
8645 break;
8646
8647 case 5400: hash_type = HASH_TYPE_SHA1;
8648 salt_type = SALT_TYPE_EMBEDDED;
8649 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8650 opts_type = OPTS_TYPE_PT_GENERATE_BE
8651 | OPTS_TYPE_ST_ADD80;
8652 kern_type = KERN_TYPE_IKEPSK_SHA1;
8653 dgst_size = DGST_SIZE_4_5;
8654 parse_func = ikepsk_sha1_parse_hash;
8655 sort_by_digest = sort_by_digest_4_5;
8656 opti_type = OPTI_TYPE_ZERO_BYTE;
8657 dgst_pos0 = 3;
8658 dgst_pos1 = 4;
8659 dgst_pos2 = 2;
8660 dgst_pos3 = 1;
8661 break;
8662
8663 case 5500: hash_type = HASH_TYPE_NETNTLM;
8664 salt_type = SALT_TYPE_EMBEDDED;
8665 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8666 opts_type = OPTS_TYPE_PT_GENERATE_LE
8667 | OPTS_TYPE_PT_ADD80
8668 | OPTS_TYPE_PT_ADDBITS14
8669 | OPTS_TYPE_PT_UNICODE
8670 | OPTS_TYPE_ST_HEX;
8671 kern_type = KERN_TYPE_NETNTLMv1;
8672 dgst_size = DGST_SIZE_4_4;
8673 parse_func = netntlmv1_parse_hash;
8674 sort_by_digest = sort_by_digest_4_4;
8675 opti_type = OPTI_TYPE_ZERO_BYTE
8676 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8677 dgst_pos0 = 0;
8678 dgst_pos1 = 1;
8679 dgst_pos2 = 2;
8680 dgst_pos3 = 3;
8681 break;
8682
8683 case 5600: hash_type = HASH_TYPE_MD5;
8684 salt_type = SALT_TYPE_EMBEDDED;
8685 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8686 opts_type = OPTS_TYPE_PT_GENERATE_LE
8687 | OPTS_TYPE_PT_ADD80
8688 | OPTS_TYPE_PT_ADDBITS14
8689 | OPTS_TYPE_PT_UNICODE;
8690 kern_type = KERN_TYPE_NETNTLMv2;
8691 dgst_size = DGST_SIZE_4_4;
8692 parse_func = netntlmv2_parse_hash;
8693 sort_by_digest = sort_by_digest_4_4;
8694 opti_type = OPTI_TYPE_ZERO_BYTE;
8695 dgst_pos0 = 0;
8696 dgst_pos1 = 3;
8697 dgst_pos2 = 2;
8698 dgst_pos3 = 1;
8699 break;
8700
8701 case 5700: hash_type = HASH_TYPE_SHA256;
8702 salt_type = SALT_TYPE_NONE;
8703 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8704 opts_type = OPTS_TYPE_PT_GENERATE_BE
8705 | OPTS_TYPE_PT_ADD80
8706 | OPTS_TYPE_PT_ADDBITS15;
8707 kern_type = KERN_TYPE_SHA256;
8708 dgst_size = DGST_SIZE_4_8;
8709 parse_func = cisco4_parse_hash;
8710 sort_by_digest = sort_by_digest_4_8;
8711 opti_type = OPTI_TYPE_ZERO_BYTE
8712 | OPTI_TYPE_PRECOMPUTE_INIT
8713 | OPTI_TYPE_PRECOMPUTE_MERKLE
8714 | OPTI_TYPE_EARLY_SKIP
8715 | OPTI_TYPE_NOT_ITERATED
8716 | OPTI_TYPE_NOT_SALTED
8717 | OPTI_TYPE_RAW_HASH;
8718 dgst_pos0 = 3;
8719 dgst_pos1 = 7;
8720 dgst_pos2 = 2;
8721 dgst_pos3 = 6;
8722 break;
8723
8724 case 5800: hash_type = HASH_TYPE_SHA1;
8725 salt_type = SALT_TYPE_INTERN;
8726 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8727 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8728 | OPTS_TYPE_ST_ADD80;
8729 kern_type = KERN_TYPE_ANDROIDPIN;
8730 dgst_size = DGST_SIZE_4_5;
8731 parse_func = androidpin_parse_hash;
8732 sort_by_digest = sort_by_digest_4_5;
8733 opti_type = OPTI_TYPE_ZERO_BYTE;
8734 dgst_pos0 = 0;
8735 dgst_pos1 = 1;
8736 dgst_pos2 = 2;
8737 dgst_pos3 = 3;
8738 break;
8739
8740 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8741 salt_type = SALT_TYPE_NONE;
8742 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8743 opts_type = OPTS_TYPE_PT_GENERATE_LE
8744 | OPTS_TYPE_PT_ADD80;
8745 kern_type = KERN_TYPE_RIPEMD160;
8746 dgst_size = DGST_SIZE_4_5;
8747 parse_func = ripemd160_parse_hash;
8748 sort_by_digest = sort_by_digest_4_5;
8749 opti_type = OPTI_TYPE_ZERO_BYTE;
8750 dgst_pos0 = 0;
8751 dgst_pos1 = 1;
8752 dgst_pos2 = 2;
8753 dgst_pos3 = 3;
8754 break;
8755
8756 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8757 salt_type = SALT_TYPE_NONE;
8758 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8759 opts_type = OPTS_TYPE_PT_GENERATE_BE
8760 | OPTS_TYPE_PT_ADD80;
8761 kern_type = KERN_TYPE_WHIRLPOOL;
8762 dgst_size = DGST_SIZE_4_16;
8763 parse_func = whirlpool_parse_hash;
8764 sort_by_digest = sort_by_digest_4_16;
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 6211: 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_XTS512;
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 6212: hash_type = HASH_TYPE_RIPEMD160;
8788 salt_type = SALT_TYPE_EMBEDDED;
8789 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8790 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8791 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8792 dgst_size = DGST_SIZE_4_5;
8793 parse_func = truecrypt_parse_hash_2k;
8794 sort_by_digest = sort_by_digest_4_5;
8795 opti_type = OPTI_TYPE_ZERO_BYTE;
8796 dgst_pos0 = 0;
8797 dgst_pos1 = 1;
8798 dgst_pos2 = 2;
8799 dgst_pos3 = 3;
8800 break;
8801
8802 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8803 salt_type = SALT_TYPE_EMBEDDED;
8804 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8805 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8806 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8807 dgst_size = DGST_SIZE_4_5;
8808 parse_func = truecrypt_parse_hash_2k;
8809 sort_by_digest = sort_by_digest_4_5;
8810 opti_type = OPTI_TYPE_ZERO_BYTE;
8811 dgst_pos0 = 0;
8812 dgst_pos1 = 1;
8813 dgst_pos2 = 2;
8814 dgst_pos3 = 3;
8815 break;
8816
8817 case 6221: hash_type = HASH_TYPE_SHA512;
8818 salt_type = SALT_TYPE_EMBEDDED;
8819 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8820 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8821 kern_type = KERN_TYPE_TCSHA512_XTS512;
8822 dgst_size = DGST_SIZE_8_8;
8823 parse_func = truecrypt_parse_hash_1k;
8824 sort_by_digest = sort_by_digest_8_8;
8825 opti_type = OPTI_TYPE_ZERO_BYTE
8826 | OPTI_TYPE_USES_BITS_64;
8827 dgst_pos0 = 0;
8828 dgst_pos1 = 1;
8829 dgst_pos2 = 2;
8830 dgst_pos3 = 3;
8831 break;
8832
8833 case 6222: hash_type = HASH_TYPE_SHA512;
8834 salt_type = SALT_TYPE_EMBEDDED;
8835 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8836 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8837 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8838 dgst_size = DGST_SIZE_8_8;
8839 parse_func = truecrypt_parse_hash_1k;
8840 sort_by_digest = sort_by_digest_8_8;
8841 opti_type = OPTI_TYPE_ZERO_BYTE
8842 | OPTI_TYPE_USES_BITS_64;
8843 dgst_pos0 = 0;
8844 dgst_pos1 = 1;
8845 dgst_pos2 = 2;
8846 dgst_pos3 = 3;
8847 break;
8848
8849 case 6223: hash_type = HASH_TYPE_SHA512;
8850 salt_type = SALT_TYPE_EMBEDDED;
8851 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8852 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8853 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8854 dgst_size = DGST_SIZE_8_8;
8855 parse_func = truecrypt_parse_hash_1k;
8856 sort_by_digest = sort_by_digest_8_8;
8857 opti_type = OPTI_TYPE_ZERO_BYTE
8858 | OPTI_TYPE_USES_BITS_64;
8859 dgst_pos0 = 0;
8860 dgst_pos1 = 1;
8861 dgst_pos2 = 2;
8862 dgst_pos3 = 3;
8863 break;
8864
8865 case 6231: 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_XTS512;
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 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8881 salt_type = SALT_TYPE_EMBEDDED;
8882 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8883 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8884 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8885 dgst_size = DGST_SIZE_4_8;
8886 parse_func = truecrypt_parse_hash_1k;
8887 sort_by_digest = sort_by_digest_4_8;
8888 opti_type = OPTI_TYPE_ZERO_BYTE;
8889 dgst_pos0 = 0;
8890 dgst_pos1 = 1;
8891 dgst_pos2 = 2;
8892 dgst_pos3 = 3;
8893 break;
8894
8895 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
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_TCWHIRLPOOL_XTS1536;
8900 dgst_size = DGST_SIZE_4_8;
8901 parse_func = truecrypt_parse_hash_1k;
8902 sort_by_digest = sort_by_digest_4_8;
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 6241: 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_XTS512;
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 6242: hash_type = HASH_TYPE_RIPEMD160;
8926 salt_type = SALT_TYPE_EMBEDDED;
8927 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8928 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8929 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8930 dgst_size = DGST_SIZE_4_5;
8931 parse_func = truecrypt_parse_hash_1k;
8932 sort_by_digest = sort_by_digest_4_5;
8933 opti_type = OPTI_TYPE_ZERO_BYTE;
8934 dgst_pos0 = 0;
8935 dgst_pos1 = 1;
8936 dgst_pos2 = 2;
8937 dgst_pos3 = 3;
8938 break;
8939
8940 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8941 salt_type = SALT_TYPE_EMBEDDED;
8942 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8943 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8944 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8945 dgst_size = DGST_SIZE_4_5;
8946 parse_func = truecrypt_parse_hash_1k;
8947 sort_by_digest = sort_by_digest_4_5;
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 6300: hash_type = HASH_TYPE_MD5;
8956 salt_type = SALT_TYPE_EMBEDDED;
8957 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8958 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8959 kern_type = KERN_TYPE_MD5AIX;
8960 dgst_size = DGST_SIZE_4_4;
8961 parse_func = md5aix_parse_hash;
8962 sort_by_digest = sort_by_digest_4_4;
8963 opti_type = OPTI_TYPE_ZERO_BYTE;
8964 dgst_pos0 = 0;
8965 dgst_pos1 = 1;
8966 dgst_pos2 = 2;
8967 dgst_pos3 = 3;
8968 break;
8969
8970 case 6400: hash_type = HASH_TYPE_SHA256;
8971 salt_type = SALT_TYPE_EMBEDDED;
8972 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8973 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8974 kern_type = KERN_TYPE_SHA256AIX;
8975 dgst_size = DGST_SIZE_4_8;
8976 parse_func = sha256aix_parse_hash;
8977 sort_by_digest = sort_by_digest_4_8;
8978 opti_type = OPTI_TYPE_ZERO_BYTE;
8979 dgst_pos0 = 0;
8980 dgst_pos1 = 1;
8981 dgst_pos2 = 2;
8982 dgst_pos3 = 3;
8983 break;
8984
8985 case 6500: hash_type = HASH_TYPE_SHA512;
8986 salt_type = SALT_TYPE_EMBEDDED;
8987 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8988 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8989 kern_type = KERN_TYPE_SHA512AIX;
8990 dgst_size = DGST_SIZE_8_8;
8991 parse_func = sha512aix_parse_hash;
8992 sort_by_digest = sort_by_digest_8_8;
8993 opti_type = OPTI_TYPE_ZERO_BYTE
8994 | OPTI_TYPE_USES_BITS_64;
8995 dgst_pos0 = 0;
8996 dgst_pos1 = 1;
8997 dgst_pos2 = 2;
8998 dgst_pos3 = 3;
8999 break;
9000
9001 case 6600: 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_AGILEKEY;
9006 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9007 parse_func = agilekey_parse_hash;
9008 sort_by_digest = sort_by_digest_4_5;
9009 opti_type = OPTI_TYPE_ZERO_BYTE;
9010 dgst_pos0 = 0;
9011 dgst_pos1 = 1;
9012 dgst_pos2 = 2;
9013 dgst_pos3 = 3;
9014 break;
9015
9016 case 6700: hash_type = HASH_TYPE_SHA1;
9017 salt_type = SALT_TYPE_EMBEDDED;
9018 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9019 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9020 kern_type = KERN_TYPE_SHA1AIX;
9021 dgst_size = DGST_SIZE_4_5;
9022 parse_func = sha1aix_parse_hash;
9023 sort_by_digest = sort_by_digest_4_5;
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 6800: hash_type = HASH_TYPE_AES;
9032 salt_type = SALT_TYPE_EMBEDDED;
9033 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9034 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9035 kern_type = KERN_TYPE_LASTPASS;
9036 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9037 parse_func = lastpass_parse_hash;
9038 sort_by_digest = sort_by_digest_4_8;
9039 opti_type = OPTI_TYPE_ZERO_BYTE;
9040 dgst_pos0 = 0;
9041 dgst_pos1 = 1;
9042 dgst_pos2 = 2;
9043 dgst_pos3 = 3;
9044 break;
9045
9046 case 6900: hash_type = HASH_TYPE_GOST;
9047 salt_type = SALT_TYPE_NONE;
9048 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9049 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9050 kern_type = KERN_TYPE_GOST;
9051 dgst_size = DGST_SIZE_4_8;
9052 parse_func = gost_parse_hash;
9053 sort_by_digest = sort_by_digest_4_8;
9054 opti_type = OPTI_TYPE_ZERO_BYTE;
9055 dgst_pos0 = 0;
9056 dgst_pos1 = 1;
9057 dgst_pos2 = 2;
9058 dgst_pos3 = 3;
9059 break;
9060
9061 case 7100: hash_type = HASH_TYPE_SHA512;
9062 salt_type = SALT_TYPE_EMBEDDED;
9063 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9064 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9065 kern_type = KERN_TYPE_PBKDF2_SHA512;
9066 dgst_size = DGST_SIZE_8_16;
9067 parse_func = sha512osx_parse_hash;
9068 sort_by_digest = sort_by_digest_8_16;
9069 opti_type = OPTI_TYPE_ZERO_BYTE
9070 | OPTI_TYPE_USES_BITS_64;
9071 dgst_pos0 = 0;
9072 dgst_pos1 = 1;
9073 dgst_pos2 = 2;
9074 dgst_pos3 = 3;
9075 break;
9076
9077 case 7200: hash_type = HASH_TYPE_SHA512;
9078 salt_type = SALT_TYPE_EMBEDDED;
9079 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9080 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9081 kern_type = KERN_TYPE_PBKDF2_SHA512;
9082 dgst_size = DGST_SIZE_8_16;
9083 parse_func = sha512grub_parse_hash;
9084 sort_by_digest = sort_by_digest_8_16;
9085 opti_type = OPTI_TYPE_ZERO_BYTE
9086 | OPTI_TYPE_USES_BITS_64;
9087 dgst_pos0 = 0;
9088 dgst_pos1 = 1;
9089 dgst_pos2 = 2;
9090 dgst_pos3 = 3;
9091 break;
9092
9093 case 7300: hash_type = HASH_TYPE_SHA1;
9094 salt_type = SALT_TYPE_EMBEDDED;
9095 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9096 opts_type = OPTS_TYPE_PT_GENERATE_BE
9097 | OPTS_TYPE_ST_ADD80
9098 | OPTS_TYPE_ST_ADDBITS15;
9099 kern_type = KERN_TYPE_RAKP;
9100 dgst_size = DGST_SIZE_4_5;
9101 parse_func = rakp_parse_hash;
9102 sort_by_digest = sort_by_digest_4_5;
9103 opti_type = OPTI_TYPE_ZERO_BYTE
9104 | OPTI_TYPE_NOT_ITERATED;
9105 dgst_pos0 = 3;
9106 dgst_pos1 = 4;
9107 dgst_pos2 = 2;
9108 dgst_pos3 = 1;
9109 break;
9110
9111 case 7400: hash_type = HASH_TYPE_SHA256;
9112 salt_type = SALT_TYPE_EMBEDDED;
9113 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9114 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9115 kern_type = KERN_TYPE_SHA256CRYPT;
9116 dgst_size = DGST_SIZE_4_8;
9117 parse_func = sha256crypt_parse_hash;
9118 sort_by_digest = sort_by_digest_4_8;
9119 opti_type = OPTI_TYPE_ZERO_BYTE;
9120 dgst_pos0 = 0;
9121 dgst_pos1 = 1;
9122 dgst_pos2 = 2;
9123 dgst_pos3 = 3;
9124 break;
9125
9126 case 7500: hash_type = HASH_TYPE_KRB5PA;
9127 salt_type = SALT_TYPE_EMBEDDED;
9128 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9129 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9130 kern_type = KERN_TYPE_KRB5PA;
9131 dgst_size = DGST_SIZE_4_4;
9132 parse_func = krb5pa_parse_hash;
9133 sort_by_digest = sort_by_digest_4_4;
9134 opti_type = OPTI_TYPE_ZERO_BYTE
9135 | OPTI_TYPE_NOT_ITERATED;
9136 dgst_pos0 = 0;
9137 dgst_pos1 = 1;
9138 dgst_pos2 = 2;
9139 dgst_pos3 = 3;
9140 break;
9141
9142 case 7600: hash_type = HASH_TYPE_SHA1;
9143 salt_type = SALT_TYPE_INTERN;
9144 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9145 opts_type = OPTS_TYPE_PT_GENERATE_BE
9146 | OPTS_TYPE_PT_ADD80
9147 | OPTS_TYPE_PT_ADDBITS15;
9148 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9149 dgst_size = DGST_SIZE_4_5;
9150 parse_func = redmine_parse_hash;
9151 sort_by_digest = sort_by_digest_4_5;
9152 opti_type = OPTI_TYPE_ZERO_BYTE
9153 | OPTI_TYPE_PRECOMPUTE_INIT
9154 | OPTI_TYPE_EARLY_SKIP
9155 | OPTI_TYPE_NOT_ITERATED
9156 | OPTI_TYPE_PREPENDED_SALT;
9157 dgst_pos0 = 3;
9158 dgst_pos1 = 4;
9159 dgst_pos2 = 2;
9160 dgst_pos3 = 1;
9161 break;
9162
9163 case 7700: hash_type = HASH_TYPE_SAPB;
9164 salt_type = SALT_TYPE_EMBEDDED;
9165 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9166 opts_type = OPTS_TYPE_PT_GENERATE_LE
9167 | OPTS_TYPE_PT_UPPER
9168 | OPTS_TYPE_ST_UPPER;
9169 kern_type = KERN_TYPE_SAPB;
9170 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9171 parse_func = sapb_parse_hash;
9172 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9173 opti_type = OPTI_TYPE_ZERO_BYTE
9174 | OPTI_TYPE_PRECOMPUTE_INIT
9175 | OPTI_TYPE_NOT_ITERATED;
9176 dgst_pos0 = 0;
9177 dgst_pos1 = 1;
9178 dgst_pos2 = 2;
9179 dgst_pos3 = 3;
9180 break;
9181
9182 case 7800: hash_type = HASH_TYPE_SAPG;
9183 salt_type = SALT_TYPE_EMBEDDED;
9184 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9185 opts_type = OPTS_TYPE_PT_GENERATE_BE
9186 | OPTS_TYPE_ST_ADD80
9187 | OPTS_TYPE_ST_UPPER;
9188 kern_type = KERN_TYPE_SAPG;
9189 dgst_size = DGST_SIZE_4_5;
9190 parse_func = sapg_parse_hash;
9191 sort_by_digest = sort_by_digest_4_5;
9192 opti_type = OPTI_TYPE_ZERO_BYTE
9193 | OPTI_TYPE_PRECOMPUTE_INIT
9194 | OPTI_TYPE_NOT_ITERATED;
9195 dgst_pos0 = 3;
9196 dgst_pos1 = 4;
9197 dgst_pos2 = 2;
9198 dgst_pos3 = 1;
9199 break;
9200
9201 case 7900: hash_type = HASH_TYPE_SHA512;
9202 salt_type = SALT_TYPE_EMBEDDED;
9203 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9204 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9205 kern_type = KERN_TYPE_DRUPAL7;
9206 dgst_size = DGST_SIZE_8_8;
9207 parse_func = drupal7_parse_hash;
9208 sort_by_digest = sort_by_digest_8_8;
9209 opti_type = OPTI_TYPE_ZERO_BYTE
9210 | OPTI_TYPE_USES_BITS_64;
9211 dgst_pos0 = 0;
9212 dgst_pos1 = 1;
9213 dgst_pos2 = 2;
9214 dgst_pos3 = 3;
9215 break;
9216
9217 case 8000: hash_type = HASH_TYPE_SHA256;
9218 salt_type = SALT_TYPE_EMBEDDED;
9219 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9220 opts_type = OPTS_TYPE_PT_GENERATE_BE
9221 | OPTS_TYPE_PT_UNICODE
9222 | OPTS_TYPE_ST_ADD80
9223 | OPTS_TYPE_ST_HEX;
9224 kern_type = KERN_TYPE_SYBASEASE;
9225 dgst_size = DGST_SIZE_4_8;
9226 parse_func = sybasease_parse_hash;
9227 sort_by_digest = sort_by_digest_4_8;
9228 opti_type = OPTI_TYPE_ZERO_BYTE
9229 | OPTI_TYPE_PRECOMPUTE_INIT
9230 | OPTI_TYPE_EARLY_SKIP
9231 | OPTI_TYPE_NOT_ITERATED
9232 | OPTI_TYPE_RAW_HASH;
9233 dgst_pos0 = 3;
9234 dgst_pos1 = 7;
9235 dgst_pos2 = 2;
9236 dgst_pos3 = 6;
9237 break;
9238
9239 case 8100: hash_type = HASH_TYPE_SHA1;
9240 salt_type = SALT_TYPE_EMBEDDED;
9241 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9242 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9243 kern_type = KERN_TYPE_NETSCALER;
9244 dgst_size = DGST_SIZE_4_5;
9245 parse_func = netscaler_parse_hash;
9246 sort_by_digest = sort_by_digest_4_5;
9247 opti_type = OPTI_TYPE_ZERO_BYTE
9248 | OPTI_TYPE_PRECOMPUTE_INIT
9249 | OPTI_TYPE_PRECOMPUTE_MERKLE
9250 | OPTI_TYPE_EARLY_SKIP
9251 | OPTI_TYPE_NOT_ITERATED
9252 | OPTI_TYPE_PREPENDED_SALT
9253 | OPTI_TYPE_RAW_HASH;
9254 dgst_pos0 = 3;
9255 dgst_pos1 = 4;
9256 dgst_pos2 = 2;
9257 dgst_pos3 = 1;
9258 break;
9259
9260 case 8200: hash_type = HASH_TYPE_SHA256;
9261 salt_type = SALT_TYPE_EMBEDDED;
9262 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9263 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9264 kern_type = KERN_TYPE_CLOUDKEY;
9265 dgst_size = DGST_SIZE_4_8;
9266 parse_func = cloudkey_parse_hash;
9267 sort_by_digest = sort_by_digest_4_8;
9268 opti_type = OPTI_TYPE_ZERO_BYTE;
9269 dgst_pos0 = 0;
9270 dgst_pos1 = 1;
9271 dgst_pos2 = 2;
9272 dgst_pos3 = 3;
9273 break;
9274
9275 case 8300: hash_type = HASH_TYPE_SHA1;
9276 salt_type = SALT_TYPE_EMBEDDED;
9277 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9278 opts_type = OPTS_TYPE_PT_GENERATE_LE
9279 | OPTS_TYPE_ST_HEX
9280 | OPTS_TYPE_ST_ADD80;
9281 kern_type = KERN_TYPE_NSEC3;
9282 dgst_size = DGST_SIZE_4_5;
9283 parse_func = nsec3_parse_hash;
9284 sort_by_digest = sort_by_digest_4_5;
9285 opti_type = OPTI_TYPE_ZERO_BYTE;
9286 dgst_pos0 = 3;
9287 dgst_pos1 = 4;
9288 dgst_pos2 = 2;
9289 dgst_pos3 = 1;
9290 break;
9291
9292 case 8400: hash_type = HASH_TYPE_SHA1;
9293 salt_type = SALT_TYPE_INTERN;
9294 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9295 opts_type = OPTS_TYPE_PT_GENERATE_BE
9296 | OPTS_TYPE_PT_ADD80
9297 | OPTS_TYPE_PT_ADDBITS15;
9298 kern_type = KERN_TYPE_WBB3;
9299 dgst_size = DGST_SIZE_4_5;
9300 parse_func = wbb3_parse_hash;
9301 sort_by_digest = sort_by_digest_4_5;
9302 opti_type = OPTI_TYPE_ZERO_BYTE
9303 | OPTI_TYPE_PRECOMPUTE_INIT
9304 | OPTI_TYPE_NOT_ITERATED;
9305 dgst_pos0 = 3;
9306 dgst_pos1 = 4;
9307 dgst_pos2 = 2;
9308 dgst_pos3 = 1;
9309 break;
9310
9311 case 8500: hash_type = HASH_TYPE_DESRACF;
9312 salt_type = SALT_TYPE_EMBEDDED;
9313 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9314 opts_type = OPTS_TYPE_PT_GENERATE_LE
9315 | OPTS_TYPE_ST_UPPER;
9316 kern_type = KERN_TYPE_RACF;
9317 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9318 parse_func = racf_parse_hash;
9319 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9320 opti_type = OPTI_TYPE_ZERO_BYTE
9321 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9322 dgst_pos0 = 0;
9323 dgst_pos1 = 1;
9324 dgst_pos2 = 2;
9325 dgst_pos3 = 3;
9326 break;
9327
9328 case 8600: hash_type = HASH_TYPE_LOTUS5;
9329 salt_type = SALT_TYPE_NONE;
9330 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9331 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9332 kern_type = KERN_TYPE_LOTUS5;
9333 dgst_size = DGST_SIZE_4_4;
9334 parse_func = lotus5_parse_hash;
9335 sort_by_digest = sort_by_digest_4_4;
9336 opti_type = OPTI_TYPE_EARLY_SKIP
9337 | OPTI_TYPE_NOT_ITERATED
9338 | OPTI_TYPE_NOT_SALTED
9339 | OPTI_TYPE_RAW_HASH;
9340 dgst_pos0 = 0;
9341 dgst_pos1 = 1;
9342 dgst_pos2 = 2;
9343 dgst_pos3 = 3;
9344 break;
9345
9346 case 8700: hash_type = HASH_TYPE_LOTUS6;
9347 salt_type = SALT_TYPE_EMBEDDED;
9348 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9349 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9350 kern_type = KERN_TYPE_LOTUS6;
9351 dgst_size = DGST_SIZE_4_4;
9352 parse_func = lotus6_parse_hash;
9353 sort_by_digest = sort_by_digest_4_4;
9354 opti_type = OPTI_TYPE_EARLY_SKIP
9355 | OPTI_TYPE_NOT_ITERATED
9356 | OPTI_TYPE_RAW_HASH;
9357 dgst_pos0 = 0;
9358 dgst_pos1 = 1;
9359 dgst_pos2 = 2;
9360 dgst_pos3 = 3;
9361 break;
9362
9363 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9364 salt_type = SALT_TYPE_EMBEDDED;
9365 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9366 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9367 kern_type = KERN_TYPE_ANDROIDFDE;
9368 dgst_size = DGST_SIZE_4_4;
9369 parse_func = androidfde_parse_hash;
9370 sort_by_digest = sort_by_digest_4_4;
9371 opti_type = OPTI_TYPE_ZERO_BYTE;
9372 dgst_pos0 = 0;
9373 dgst_pos1 = 1;
9374 dgst_pos2 = 2;
9375 dgst_pos3 = 3;
9376 break;
9377
9378 case 8900: hash_type = HASH_TYPE_SCRYPT;
9379 salt_type = SALT_TYPE_EMBEDDED;
9380 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9381 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9382 kern_type = KERN_TYPE_SCRYPT;
9383 dgst_size = DGST_SIZE_4_8;
9384 parse_func = scrypt_parse_hash;
9385 sort_by_digest = sort_by_digest_4_8;
9386 opti_type = OPTI_TYPE_ZERO_BYTE;
9387 dgst_pos0 = 0;
9388 dgst_pos1 = 1;
9389 dgst_pos2 = 2;
9390 dgst_pos3 = 3;
9391 break;
9392
9393 case 9000: hash_type = HASH_TYPE_SHA1;
9394 salt_type = SALT_TYPE_EMBEDDED;
9395 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9396 opts_type = OPTS_TYPE_PT_GENERATE_LE
9397 | OPTS_TYPE_ST_GENERATE_LE;
9398 kern_type = KERN_TYPE_PSAFE2;
9399 dgst_size = DGST_SIZE_4_5;
9400 parse_func = psafe2_parse_hash;
9401 sort_by_digest = sort_by_digest_4_5;
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 9100: hash_type = HASH_TYPE_LOTUS8;
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_LOTUS8;
9414 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9415 parse_func = lotus8_parse_hash;
9416 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
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 9200: hash_type = HASH_TYPE_SHA256;
9425 salt_type = SALT_TYPE_EMBEDDED;
9426 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9427 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9428 kern_type = KERN_TYPE_PBKDF2_SHA256;
9429 dgst_size = DGST_SIZE_4_32;
9430 parse_func = cisco8_parse_hash;
9431 sort_by_digest = sort_by_digest_4_32;
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 9300: hash_type = HASH_TYPE_SCRYPT;
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_SCRYPT;
9444 dgst_size = DGST_SIZE_4_8;
9445 parse_func = cisco9_parse_hash;
9446 sort_by_digest = sort_by_digest_4_8;
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 9400: hash_type = HASH_TYPE_OFFICE2007;
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_OFFICE2007;
9459 dgst_size = DGST_SIZE_4_4;
9460 parse_func = office2007_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 9500: hash_type = HASH_TYPE_OFFICE2010;
9470 salt_type = SALT_TYPE_EMBEDDED;
9471 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9472 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9473 kern_type = KERN_TYPE_OFFICE2010;
9474 dgst_size = DGST_SIZE_4_4;
9475 parse_func = office2010_parse_hash;
9476 sort_by_digest = sort_by_digest_4_4;
9477 opti_type = OPTI_TYPE_ZERO_BYTE;
9478 dgst_pos0 = 0;
9479 dgst_pos1 = 1;
9480 dgst_pos2 = 2;
9481 dgst_pos3 = 3;
9482 break;
9483
9484 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9485 salt_type = SALT_TYPE_EMBEDDED;
9486 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9487 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9488 kern_type = KERN_TYPE_OFFICE2013;
9489 dgst_size = DGST_SIZE_4_4;
9490 parse_func = office2013_parse_hash;
9491 sort_by_digest = sort_by_digest_4_4;
9492 opti_type = OPTI_TYPE_ZERO_BYTE;
9493 dgst_pos0 = 0;
9494 dgst_pos1 = 1;
9495 dgst_pos2 = 2;
9496 dgst_pos3 = 3;
9497 break;
9498
9499 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9500 salt_type = SALT_TYPE_EMBEDDED;
9501 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9502 opts_type = OPTS_TYPE_PT_GENERATE_LE
9503 | OPTS_TYPE_PT_ADD80
9504 | OPTS_TYPE_PT_UNICODE;
9505 kern_type = KERN_TYPE_OLDOFFICE01;
9506 dgst_size = DGST_SIZE_4_4;
9507 parse_func = oldoffice01_parse_hash;
9508 sort_by_digest = sort_by_digest_4_4;
9509 opti_type = OPTI_TYPE_ZERO_BYTE
9510 | OPTI_TYPE_PRECOMPUTE_INIT
9511 | OPTI_TYPE_NOT_ITERATED;
9512 dgst_pos0 = 0;
9513 dgst_pos1 = 1;
9514 dgst_pos2 = 2;
9515 dgst_pos3 = 3;
9516 break;
9517
9518 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9519 salt_type = SALT_TYPE_EMBEDDED;
9520 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9521 opts_type = OPTS_TYPE_PT_GENERATE_LE
9522 | OPTS_TYPE_PT_ADD80;
9523 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9524 dgst_size = DGST_SIZE_4_4;
9525 parse_func = oldoffice01cm1_parse_hash;
9526 sort_by_digest = sort_by_digest_4_4;
9527 opti_type = OPTI_TYPE_ZERO_BYTE
9528 | OPTI_TYPE_PRECOMPUTE_INIT
9529 | OPTI_TYPE_NOT_ITERATED;
9530 dgst_pos0 = 0;
9531 dgst_pos1 = 1;
9532 dgst_pos2 = 2;
9533 dgst_pos3 = 3;
9534 break;
9535
9536 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9537 salt_type = SALT_TYPE_EMBEDDED;
9538 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9539 opts_type = OPTS_TYPE_PT_GENERATE_LE
9540 | OPTS_TYPE_PT_ADD80
9541 | OPTS_TYPE_PT_UNICODE
9542 | OPTS_TYPE_PT_NEVERCRACK;
9543 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9544 dgst_size = DGST_SIZE_4_4;
9545 parse_func = oldoffice01cm2_parse_hash;
9546 sort_by_digest = sort_by_digest_4_4;
9547 opti_type = OPTI_TYPE_ZERO_BYTE
9548 | OPTI_TYPE_PRECOMPUTE_INIT
9549 | OPTI_TYPE_NOT_ITERATED;
9550 dgst_pos0 = 0;
9551 dgst_pos1 = 1;
9552 dgst_pos2 = 2;
9553 dgst_pos3 = 3;
9554 break;
9555
9556 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9557 salt_type = SALT_TYPE_EMBEDDED;
9558 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9559 opts_type = OPTS_TYPE_PT_GENERATE_BE
9560 | OPTS_TYPE_PT_ADD80
9561 | OPTS_TYPE_PT_UNICODE;
9562 kern_type = KERN_TYPE_OLDOFFICE34;
9563 dgst_size = DGST_SIZE_4_4;
9564 parse_func = oldoffice34_parse_hash;
9565 sort_by_digest = sort_by_digest_4_4;
9566 opti_type = OPTI_TYPE_ZERO_BYTE
9567 | OPTI_TYPE_PRECOMPUTE_INIT
9568 | OPTI_TYPE_NOT_ITERATED;
9569 dgst_pos0 = 0;
9570 dgst_pos1 = 1;
9571 dgst_pos2 = 2;
9572 dgst_pos3 = 3;
9573 break;
9574
9575 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9576 salt_type = SALT_TYPE_EMBEDDED;
9577 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9578 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9579 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9580 dgst_size = DGST_SIZE_4_4;
9581 parse_func = oldoffice34cm1_parse_hash;
9582 sort_by_digest = sort_by_digest_4_4;
9583 opti_type = OPTI_TYPE_ZERO_BYTE
9584 | OPTI_TYPE_PRECOMPUTE_INIT
9585 | OPTI_TYPE_NOT_ITERATED;
9586 dgst_pos0 = 0;
9587 dgst_pos1 = 1;
9588 dgst_pos2 = 2;
9589 dgst_pos3 = 3;
9590 break;
9591
9592 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9593 salt_type = SALT_TYPE_EMBEDDED;
9594 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9595 opts_type = OPTS_TYPE_PT_GENERATE_BE
9596 | OPTS_TYPE_PT_ADD80
9597 | OPTS_TYPE_PT_UNICODE
9598 | OPTS_TYPE_PT_NEVERCRACK;
9599 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9600 dgst_size = DGST_SIZE_4_4;
9601 parse_func = oldoffice34cm2_parse_hash;
9602 sort_by_digest = sort_by_digest_4_4;
9603 opti_type = OPTI_TYPE_ZERO_BYTE
9604 | OPTI_TYPE_PRECOMPUTE_INIT
9605 | OPTI_TYPE_NOT_ITERATED;
9606 dgst_pos0 = 0;
9607 dgst_pos1 = 1;
9608 dgst_pos2 = 2;
9609 dgst_pos3 = 3;
9610 break;
9611
9612 case 9900: hash_type = HASH_TYPE_MD5;
9613 salt_type = SALT_TYPE_NONE;
9614 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9615 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9616 kern_type = KERN_TYPE_RADMIN2;
9617 dgst_size = DGST_SIZE_4_4;
9618 parse_func = radmin2_parse_hash;
9619 sort_by_digest = sort_by_digest_4_4;
9620 opti_type = OPTI_TYPE_ZERO_BYTE
9621 | OPTI_TYPE_PRECOMPUTE_INIT
9622 | OPTI_TYPE_EARLY_SKIP
9623 | OPTI_TYPE_NOT_ITERATED
9624 | OPTI_TYPE_NOT_SALTED;
9625 dgst_pos0 = 0;
9626 dgst_pos1 = 3;
9627 dgst_pos2 = 2;
9628 dgst_pos3 = 1;
9629 break;
9630
9631 case 10000: hash_type = HASH_TYPE_SHA256;
9632 salt_type = SALT_TYPE_EMBEDDED;
9633 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9634 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9635 kern_type = KERN_TYPE_PBKDF2_SHA256;
9636 dgst_size = DGST_SIZE_4_32;
9637 parse_func = djangopbkdf2_parse_hash;
9638 sort_by_digest = sort_by_digest_4_32;
9639 opti_type = OPTI_TYPE_ZERO_BYTE;
9640 dgst_pos0 = 0;
9641 dgst_pos1 = 1;
9642 dgst_pos2 = 2;
9643 dgst_pos3 = 3;
9644 break;
9645
9646 case 10100: hash_type = HASH_TYPE_SIPHASH;
9647 salt_type = SALT_TYPE_EMBEDDED;
9648 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9649 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9650 kern_type = KERN_TYPE_SIPHASH;
9651 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9652 parse_func = siphash_parse_hash;
9653 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9654 opti_type = OPTI_TYPE_ZERO_BYTE
9655 | OPTI_TYPE_NOT_ITERATED
9656 | OPTI_TYPE_RAW_HASH;
9657 dgst_pos0 = 0;
9658 dgst_pos1 = 1;
9659 dgst_pos2 = 2;
9660 dgst_pos3 = 3;
9661 break;
9662
9663 case 10200: hash_type = HASH_TYPE_MD5;
9664 salt_type = SALT_TYPE_EMBEDDED;
9665 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9666 opts_type = OPTS_TYPE_PT_GENERATE_LE
9667 | OPTS_TYPE_ST_ADD80
9668 | OPTS_TYPE_ST_ADDBITS14;
9669 kern_type = KERN_TYPE_HMACMD5_PW;
9670 dgst_size = DGST_SIZE_4_4;
9671 parse_func = crammd5_parse_hash;
9672 sort_by_digest = sort_by_digest_4_4;
9673 opti_type = OPTI_TYPE_ZERO_BYTE
9674 | OPTI_TYPE_NOT_ITERATED;
9675 dgst_pos0 = 0;
9676 dgst_pos1 = 3;
9677 dgst_pos2 = 2;
9678 dgst_pos3 = 1;
9679 break;
9680
9681 case 10300: hash_type = HASH_TYPE_SHA1;
9682 salt_type = SALT_TYPE_EMBEDDED;
9683 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9684 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9685 kern_type = KERN_TYPE_SAPH_SHA1;
9686 dgst_size = DGST_SIZE_4_5;
9687 parse_func = saph_sha1_parse_hash;
9688 sort_by_digest = sort_by_digest_4_5;
9689 opti_type = OPTI_TYPE_ZERO_BYTE;
9690 dgst_pos0 = 0;
9691 dgst_pos1 = 1;
9692 dgst_pos2 = 2;
9693 dgst_pos3 = 3;
9694 break;
9695
9696 case 10400: hash_type = HASH_TYPE_PDFU16;
9697 salt_type = SALT_TYPE_EMBEDDED;
9698 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9699 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9700 kern_type = KERN_TYPE_PDF11;
9701 dgst_size = DGST_SIZE_4_4;
9702 parse_func = pdf11_parse_hash;
9703 sort_by_digest = sort_by_digest_4_4;
9704 opti_type = OPTI_TYPE_ZERO_BYTE
9705 | OPTI_TYPE_NOT_ITERATED;
9706 dgst_pos0 = 0;
9707 dgst_pos1 = 1;
9708 dgst_pos2 = 2;
9709 dgst_pos3 = 3;
9710 break;
9711
9712 case 10410: hash_type = HASH_TYPE_PDFU16;
9713 salt_type = SALT_TYPE_EMBEDDED;
9714 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9715 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9716 kern_type = KERN_TYPE_PDF11CM1;
9717 dgst_size = DGST_SIZE_4_4;
9718 parse_func = pdf11cm1_parse_hash;
9719 sort_by_digest = sort_by_digest_4_4;
9720 opti_type = OPTI_TYPE_ZERO_BYTE
9721 | OPTI_TYPE_NOT_ITERATED;
9722 dgst_pos0 = 0;
9723 dgst_pos1 = 1;
9724 dgst_pos2 = 2;
9725 dgst_pos3 = 3;
9726 break;
9727
9728 case 10420: hash_type = HASH_TYPE_PDFU16;
9729 salt_type = SALT_TYPE_EMBEDDED;
9730 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9731 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9732 kern_type = KERN_TYPE_PDF11CM2;
9733 dgst_size = DGST_SIZE_4_4;
9734 parse_func = pdf11cm2_parse_hash;
9735 sort_by_digest = sort_by_digest_4_4;
9736 opti_type = OPTI_TYPE_ZERO_BYTE
9737 | OPTI_TYPE_NOT_ITERATED;
9738 dgst_pos0 = 0;
9739 dgst_pos1 = 1;
9740 dgst_pos2 = 2;
9741 dgst_pos3 = 3;
9742 break;
9743
9744 case 10500: hash_type = HASH_TYPE_PDFU16;
9745 salt_type = SALT_TYPE_EMBEDDED;
9746 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9747 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9748 kern_type = KERN_TYPE_PDF14;
9749 dgst_size = DGST_SIZE_4_4;
9750 parse_func = pdf14_parse_hash;
9751 sort_by_digest = sort_by_digest_4_4;
9752 opti_type = OPTI_TYPE_ZERO_BYTE
9753 | OPTI_TYPE_NOT_ITERATED;
9754 dgst_pos0 = 0;
9755 dgst_pos1 = 1;
9756 dgst_pos2 = 2;
9757 dgst_pos3 = 3;
9758 break;
9759
9760 case 10600: hash_type = HASH_TYPE_SHA256;
9761 salt_type = SALT_TYPE_EMBEDDED;
9762 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9763 opts_type = OPTS_TYPE_PT_GENERATE_BE
9764 | OPTS_TYPE_ST_ADD80
9765 | OPTS_TYPE_ST_ADDBITS15
9766 | OPTS_TYPE_HASH_COPY;
9767 kern_type = KERN_TYPE_SHA256_PWSLT;
9768 dgst_size = DGST_SIZE_4_8;
9769 parse_func = pdf17l3_parse_hash;
9770 sort_by_digest = sort_by_digest_4_8;
9771 opti_type = OPTI_TYPE_ZERO_BYTE
9772 | OPTI_TYPE_PRECOMPUTE_INIT
9773 | OPTI_TYPE_PRECOMPUTE_MERKLE
9774 | OPTI_TYPE_EARLY_SKIP
9775 | OPTI_TYPE_NOT_ITERATED
9776 | OPTI_TYPE_APPENDED_SALT
9777 | OPTI_TYPE_RAW_HASH;
9778 dgst_pos0 = 3;
9779 dgst_pos1 = 7;
9780 dgst_pos2 = 2;
9781 dgst_pos3 = 6;
9782 break;
9783
9784 case 10700: hash_type = HASH_TYPE_PDFU32;
9785 salt_type = SALT_TYPE_EMBEDDED;
9786 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9787 opts_type = OPTS_TYPE_PT_GENERATE_LE
9788 | OPTS_TYPE_HASH_COPY;
9789 kern_type = KERN_TYPE_PDF17L8;
9790 dgst_size = DGST_SIZE_4_8;
9791 parse_func = pdf17l8_parse_hash;
9792 sort_by_digest = sort_by_digest_4_8;
9793 opti_type = OPTI_TYPE_ZERO_BYTE
9794 | OPTI_TYPE_NOT_ITERATED;
9795 dgst_pos0 = 0;
9796 dgst_pos1 = 1;
9797 dgst_pos2 = 2;
9798 dgst_pos3 = 3;
9799 break;
9800
9801 case 10800: hash_type = HASH_TYPE_SHA384;
9802 salt_type = SALT_TYPE_NONE;
9803 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9804 opts_type = OPTS_TYPE_PT_GENERATE_BE
9805 | OPTS_TYPE_PT_ADD80
9806 | OPTS_TYPE_PT_ADDBITS15;
9807 kern_type = KERN_TYPE_SHA384;
9808 dgst_size = DGST_SIZE_8_8;
9809 parse_func = sha384_parse_hash;
9810 sort_by_digest = sort_by_digest_8_8;
9811 opti_type = OPTI_TYPE_ZERO_BYTE
9812 | OPTI_TYPE_PRECOMPUTE_INIT
9813 | OPTI_TYPE_PRECOMPUTE_MERKLE
9814 | OPTI_TYPE_EARLY_SKIP
9815 | OPTI_TYPE_NOT_ITERATED
9816 | OPTI_TYPE_NOT_SALTED
9817 | OPTI_TYPE_USES_BITS_64
9818 | OPTI_TYPE_RAW_HASH;
9819 dgst_pos0 = 6;
9820 dgst_pos1 = 7;
9821 dgst_pos2 = 4;
9822 dgst_pos3 = 5;
9823 break;
9824
9825 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9826 salt_type = SALT_TYPE_EMBEDDED;
9827 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9828 opts_type = OPTS_TYPE_PT_GENERATE_LE
9829 | OPTS_TYPE_ST_BASE64
9830 | OPTS_TYPE_HASH_COPY;
9831 kern_type = KERN_TYPE_PBKDF2_SHA256;
9832 dgst_size = DGST_SIZE_4_32;
9833 parse_func = pbkdf2_sha256_parse_hash;
9834 sort_by_digest = sort_by_digest_4_32;
9835 opti_type = OPTI_TYPE_ZERO_BYTE;
9836 dgst_pos0 = 0;
9837 dgst_pos1 = 1;
9838 dgst_pos2 = 2;
9839 dgst_pos3 = 3;
9840 break;
9841
9842 case 11000: hash_type = HASH_TYPE_MD5;
9843 salt_type = SALT_TYPE_INTERN;
9844 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9845 opts_type = OPTS_TYPE_PT_GENERATE_LE
9846 | OPTS_TYPE_PT_ADD80;
9847 kern_type = KERN_TYPE_PRESTASHOP;
9848 dgst_size = DGST_SIZE_4_4;
9849 parse_func = prestashop_parse_hash;
9850 sort_by_digest = sort_by_digest_4_4;
9851 opti_type = OPTI_TYPE_ZERO_BYTE
9852 | OPTI_TYPE_PRECOMPUTE_INIT
9853 | OPTI_TYPE_NOT_ITERATED
9854 | OPTI_TYPE_PREPENDED_SALT;
9855 dgst_pos0 = 0;
9856 dgst_pos1 = 3;
9857 dgst_pos2 = 2;
9858 dgst_pos3 = 1;
9859 break;
9860
9861 case 11100: hash_type = HASH_TYPE_MD5;
9862 salt_type = SALT_TYPE_EMBEDDED;
9863 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9864 opts_type = OPTS_TYPE_PT_GENERATE_LE
9865 | OPTS_TYPE_ST_ADD80;
9866 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9867 dgst_size = DGST_SIZE_4_4;
9868 parse_func = postgresql_auth_parse_hash;
9869 sort_by_digest = sort_by_digest_4_4;
9870 opti_type = OPTI_TYPE_ZERO_BYTE
9871 | OPTI_TYPE_PRECOMPUTE_INIT
9872 | OPTI_TYPE_PRECOMPUTE_MERKLE
9873 | OPTI_TYPE_EARLY_SKIP;
9874 dgst_pos0 = 0;
9875 dgst_pos1 = 3;
9876 dgst_pos2 = 2;
9877 dgst_pos3 = 1;
9878 break;
9879
9880 case 11200: hash_type = HASH_TYPE_SHA1;
9881 salt_type = SALT_TYPE_EMBEDDED;
9882 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9883 opts_type = OPTS_TYPE_PT_GENERATE_BE
9884 | OPTS_TYPE_PT_ADD80
9885 | OPTS_TYPE_ST_HEX;
9886 kern_type = KERN_TYPE_MYSQL_AUTH;
9887 dgst_size = DGST_SIZE_4_5;
9888 parse_func = mysql_auth_parse_hash;
9889 sort_by_digest = sort_by_digest_4_5;
9890 opti_type = OPTI_TYPE_ZERO_BYTE
9891 | OPTI_TYPE_EARLY_SKIP;
9892 dgst_pos0 = 3;
9893 dgst_pos1 = 4;
9894 dgst_pos2 = 2;
9895 dgst_pos3 = 1;
9896 break;
9897
9898 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9899 salt_type = SALT_TYPE_EMBEDDED;
9900 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9901 opts_type = OPTS_TYPE_PT_GENERATE_LE
9902 | OPTS_TYPE_ST_HEX
9903 | OPTS_TYPE_ST_ADD80;
9904 kern_type = KERN_TYPE_BITCOIN_WALLET;
9905 dgst_size = DGST_SIZE_4_4;
9906 parse_func = bitcoin_wallet_parse_hash;
9907 sort_by_digest = sort_by_digest_4_4;
9908 opti_type = OPTI_TYPE_ZERO_BYTE;
9909 dgst_pos0 = 0;
9910 dgst_pos1 = 1;
9911 dgst_pos2 = 2;
9912 dgst_pos3 = 3;
9913 break;
9914
9915 case 11400: hash_type = HASH_TYPE_MD5;
9916 salt_type = SALT_TYPE_EMBEDDED;
9917 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9918 opts_type = OPTS_TYPE_PT_GENERATE_LE
9919 | OPTS_TYPE_PT_ADD80
9920 | OPTS_TYPE_HASH_COPY;
9921 kern_type = KERN_TYPE_SIP_AUTH;
9922 dgst_size = DGST_SIZE_4_4;
9923 parse_func = sip_auth_parse_hash;
9924 sort_by_digest = sort_by_digest_4_4;
9925 opti_type = OPTI_TYPE_ZERO_BYTE;
9926 dgst_pos0 = 0;
9927 dgst_pos1 = 3;
9928 dgst_pos2 = 2;
9929 dgst_pos3 = 1;
9930 break;
9931
9932 case 11500: hash_type = HASH_TYPE_CRC32;
9933 salt_type = SALT_TYPE_INTERN;
9934 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9935 opts_type = OPTS_TYPE_PT_GENERATE_LE
9936 | OPTS_TYPE_ST_GENERATE_LE
9937 | OPTS_TYPE_ST_HEX;
9938 kern_type = KERN_TYPE_CRC32;
9939 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9940 parse_func = crc32_parse_hash;
9941 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9942 opti_type = OPTI_TYPE_ZERO_BYTE;
9943 dgst_pos0 = 0;
9944 dgst_pos1 = 1;
9945 dgst_pos2 = 2;
9946 dgst_pos3 = 3;
9947 break;
9948
9949 case 11600: hash_type = HASH_TYPE_AES;
9950 salt_type = SALT_TYPE_EMBEDDED;
9951 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9952 opts_type = OPTS_TYPE_PT_GENERATE_LE
9953 | OPTS_TYPE_PT_NEVERCRACK;
9954 kern_type = KERN_TYPE_SEVEN_ZIP;
9955 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9956 parse_func = seven_zip_parse_hash;
9957 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9958 opti_type = OPTI_TYPE_ZERO_BYTE;
9959 dgst_pos0 = 0;
9960 dgst_pos1 = 1;
9961 dgst_pos2 = 2;
9962 dgst_pos3 = 3;
9963 break;
9964
9965 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9966 salt_type = SALT_TYPE_NONE;
9967 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9968 opts_type = OPTS_TYPE_PT_GENERATE_LE
9969 | OPTS_TYPE_PT_ADD01;
9970 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9971 dgst_size = DGST_SIZE_4_8;
9972 parse_func = gost2012sbog_256_parse_hash;
9973 sort_by_digest = sort_by_digest_4_8;
9974 opti_type = OPTI_TYPE_ZERO_BYTE;
9975 dgst_pos0 = 0;
9976 dgst_pos1 = 1;
9977 dgst_pos2 = 2;
9978 dgst_pos3 = 3;
9979 break;
9980
9981 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9982 salt_type = SALT_TYPE_NONE;
9983 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9984 opts_type = OPTS_TYPE_PT_GENERATE_LE
9985 | OPTS_TYPE_PT_ADD01;
9986 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9987 dgst_size = DGST_SIZE_4_16;
9988 parse_func = gost2012sbog_512_parse_hash;
9989 sort_by_digest = sort_by_digest_4_16;
9990 opti_type = OPTI_TYPE_ZERO_BYTE;
9991 dgst_pos0 = 0;
9992 dgst_pos1 = 1;
9993 dgst_pos2 = 2;
9994 dgst_pos3 = 3;
9995 break;
9996
9997 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9998 salt_type = SALT_TYPE_EMBEDDED;
9999 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10000 opts_type = OPTS_TYPE_PT_GENERATE_LE
10001 | OPTS_TYPE_ST_BASE64
10002 | OPTS_TYPE_HASH_COPY;
10003 kern_type = KERN_TYPE_PBKDF2_MD5;
10004 dgst_size = DGST_SIZE_4_32;
10005 parse_func = pbkdf2_md5_parse_hash;
10006 sort_by_digest = sort_by_digest_4_32;
10007 opti_type = OPTI_TYPE_ZERO_BYTE;
10008 dgst_pos0 = 0;
10009 dgst_pos1 = 1;
10010 dgst_pos2 = 2;
10011 dgst_pos3 = 3;
10012 break;
10013
10014 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10015 salt_type = SALT_TYPE_EMBEDDED;
10016 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10017 opts_type = OPTS_TYPE_PT_GENERATE_LE
10018 | OPTS_TYPE_ST_BASE64
10019 | OPTS_TYPE_HASH_COPY;
10020 kern_type = KERN_TYPE_PBKDF2_SHA1;
10021 dgst_size = DGST_SIZE_4_32;
10022 parse_func = pbkdf2_sha1_parse_hash;
10023 sort_by_digest = sort_by_digest_4_32;
10024 opti_type = OPTI_TYPE_ZERO_BYTE;
10025 dgst_pos0 = 0;
10026 dgst_pos1 = 1;
10027 dgst_pos2 = 2;
10028 dgst_pos3 = 3;
10029 break;
10030
10031 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10032 salt_type = SALT_TYPE_EMBEDDED;
10033 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10034 opts_type = OPTS_TYPE_PT_GENERATE_LE
10035 | OPTS_TYPE_ST_BASE64
10036 | OPTS_TYPE_HASH_COPY;
10037 kern_type = KERN_TYPE_PBKDF2_SHA512;
10038 dgst_size = DGST_SIZE_8_16;
10039 parse_func = pbkdf2_sha512_parse_hash;
10040 sort_by_digest = sort_by_digest_8_16;
10041 opti_type = OPTI_TYPE_ZERO_BYTE
10042 | OPTI_TYPE_USES_BITS_64;
10043 dgst_pos0 = 0;
10044 dgst_pos1 = 1;
10045 dgst_pos2 = 2;
10046 dgst_pos3 = 3;
10047 break;
10048
10049 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10050 salt_type = SALT_TYPE_EMBEDDED;
10051 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10052 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10053 kern_type = KERN_TYPE_ECRYPTFS;
10054 dgst_size = DGST_SIZE_8_8;
10055 parse_func = ecryptfs_parse_hash;
10056 sort_by_digest = sort_by_digest_8_8;
10057 opti_type = OPTI_TYPE_ZERO_BYTE
10058 | OPTI_TYPE_USES_BITS_64;
10059 dgst_pos0 = 0;
10060 dgst_pos1 = 1;
10061 dgst_pos2 = 2;
10062 dgst_pos3 = 3;
10063 break;
10064
10065 case 12300: hash_type = HASH_TYPE_ORACLET;
10066 salt_type = SALT_TYPE_EMBEDDED;
10067 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10068 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10069 kern_type = KERN_TYPE_ORACLET;
10070 dgst_size = DGST_SIZE_8_16;
10071 parse_func = oraclet_parse_hash;
10072 sort_by_digest = sort_by_digest_8_16;
10073 opti_type = OPTI_TYPE_ZERO_BYTE
10074 | OPTI_TYPE_USES_BITS_64;
10075 dgst_pos0 = 0;
10076 dgst_pos1 = 1;
10077 dgst_pos2 = 2;
10078 dgst_pos3 = 3;
10079 break;
10080
10081 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10082 salt_type = SALT_TYPE_EMBEDDED;
10083 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10084 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10085 kern_type = KERN_TYPE_BSDICRYPT;
10086 dgst_size = DGST_SIZE_4_4;
10087 parse_func = bsdicrypt_parse_hash;
10088 sort_by_digest = sort_by_digest_4_4;
10089 opti_type = OPTI_TYPE_ZERO_BYTE
10090 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10091 dgst_pos0 = 0;
10092 dgst_pos1 = 1;
10093 dgst_pos2 = 2;
10094 dgst_pos3 = 3;
10095 break;
10096
10097 case 12500: hash_type = HASH_TYPE_RAR3HP;
10098 salt_type = SALT_TYPE_EMBEDDED;
10099 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10100 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10101 kern_type = KERN_TYPE_RAR3;
10102 dgst_size = DGST_SIZE_4_4;
10103 parse_func = rar3hp_parse_hash;
10104 sort_by_digest = sort_by_digest_4_4;
10105 opti_type = OPTI_TYPE_ZERO_BYTE;
10106 dgst_pos0 = 0;
10107 dgst_pos1 = 1;
10108 dgst_pos2 = 2;
10109 dgst_pos3 = 3;
10110 break;
10111
10112 case 12600: hash_type = HASH_TYPE_SHA256;
10113 salt_type = SALT_TYPE_INTERN;
10114 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10115 opts_type = OPTS_TYPE_PT_GENERATE_BE
10116 | OPTS_TYPE_PT_ADD80;
10117 kern_type = KERN_TYPE_CF10;
10118 dgst_size = DGST_SIZE_4_8;
10119 parse_func = cf10_parse_hash;
10120 sort_by_digest = sort_by_digest_4_8;
10121 opti_type = OPTI_TYPE_ZERO_BYTE
10122 | OPTI_TYPE_PRECOMPUTE_INIT
10123 | OPTI_TYPE_EARLY_SKIP
10124 | OPTI_TYPE_NOT_ITERATED;
10125 dgst_pos0 = 3;
10126 dgst_pos1 = 7;
10127 dgst_pos2 = 2;
10128 dgst_pos3 = 6;
10129 break;
10130
10131 case 12700: hash_type = HASH_TYPE_AES;
10132 salt_type = SALT_TYPE_EMBEDDED;
10133 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10134 opts_type = OPTS_TYPE_PT_GENERATE_LE
10135 | OPTS_TYPE_HASH_COPY;
10136 kern_type = KERN_TYPE_MYWALLET;
10137 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10138 parse_func = mywallet_parse_hash;
10139 sort_by_digest = sort_by_digest_4_5;
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 12800: 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_MS_DRSR;
10152 dgst_size = DGST_SIZE_4_8;
10153 parse_func = ms_drsr_parse_hash;
10154 sort_by_digest = sort_by_digest_4_8;
10155 opti_type = OPTI_TYPE_ZERO_BYTE;
10156 dgst_pos0 = 0;
10157 dgst_pos1 = 1;
10158 dgst_pos2 = 2;
10159 dgst_pos3 = 3;
10160 break;
10161
10162 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10163 salt_type = SALT_TYPE_EMBEDDED;
10164 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10165 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10166 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10167 dgst_size = DGST_SIZE_4_8;
10168 parse_func = androidfde_samsung_parse_hash;
10169 sort_by_digest = sort_by_digest_4_8;
10170 opti_type = OPTI_TYPE_ZERO_BYTE;
10171 dgst_pos0 = 0;
10172 dgst_pos1 = 1;
10173 dgst_pos2 = 2;
10174 dgst_pos3 = 3;
10175 break;
10176
10177 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10178 salt_type = SALT_TYPE_EMBEDDED;
10179 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10180 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10181 kern_type = KERN_TYPE_RAR5;
10182 dgst_size = DGST_SIZE_4_4;
10183 parse_func = rar5_parse_hash;
10184 sort_by_digest = sort_by_digest_4_4;
10185 opti_type = OPTI_TYPE_ZERO_BYTE;
10186 dgst_pos0 = 0;
10187 dgst_pos1 = 1;
10188 dgst_pos2 = 2;
10189 dgst_pos3 = 3;
10190 break;
10191
10192 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10193 salt_type = SALT_TYPE_EMBEDDED;
10194 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10195 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10196 kern_type = KERN_TYPE_KRB5TGS;
10197 dgst_size = DGST_SIZE_4_4;
10198 parse_func = krb5tgs_parse_hash;
10199 sort_by_digest = sort_by_digest_4_4;
10200 opti_type = OPTI_TYPE_ZERO_BYTE
10201 | OPTI_TYPE_NOT_ITERATED;
10202 dgst_pos0 = 0;
10203 dgst_pos1 = 1;
10204 dgst_pos2 = 2;
10205 dgst_pos3 = 3;
10206 break;
10207
10208 default: usage_mini_print (PROGNAME); return (-1);
10209 }
10210
10211 /**
10212 * parser
10213 */
10214
10215 data.parse_func = parse_func;
10216
10217 /**
10218 * misc stuff
10219 */
10220
10221 if (hex_salt)
10222 {
10223 if (salt_type == SALT_TYPE_INTERN)
10224 {
10225 opts_type |= OPTS_TYPE_ST_HEX;
10226 }
10227 else
10228 {
10229 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10230
10231 return (-1);
10232 }
10233 }
10234
10235 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10236 | (salt_type == SALT_TYPE_EXTERN)
10237 | (salt_type == SALT_TYPE_EMBEDDED)
10238 | (salt_type == SALT_TYPE_VIRTUAL));
10239
10240 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10241
10242 data.hash_type = hash_type;
10243 data.attack_mode = attack_mode;
10244 data.attack_kern = attack_kern;
10245 data.attack_exec = attack_exec;
10246 data.kern_type = kern_type;
10247 data.opts_type = opts_type;
10248 data.dgst_size = dgst_size;
10249 data.salt_type = salt_type;
10250 data.isSalted = isSalted;
10251 data.sort_by_digest = sort_by_digest;
10252 data.dgst_pos0 = dgst_pos0;
10253 data.dgst_pos1 = dgst_pos1;
10254 data.dgst_pos2 = dgst_pos2;
10255 data.dgst_pos3 = dgst_pos3;
10256
10257 esalt_size = 0;
10258
10259 switch (hash_mode)
10260 {
10261 case 2500: esalt_size = sizeof (wpa_t); break;
10262 case 5300: esalt_size = sizeof (ikepsk_t); break;
10263 case 5400: esalt_size = sizeof (ikepsk_t); break;
10264 case 5500: esalt_size = sizeof (netntlm_t); break;
10265 case 5600: esalt_size = sizeof (netntlm_t); break;
10266 case 6211: esalt_size = sizeof (tc_t); break;
10267 case 6212: esalt_size = sizeof (tc_t); break;
10268 case 6213: esalt_size = sizeof (tc_t); break;
10269 case 6221: esalt_size = sizeof (tc_t); break;
10270 case 6222: esalt_size = sizeof (tc_t); break;
10271 case 6223: esalt_size = sizeof (tc_t); break;
10272 case 6231: esalt_size = sizeof (tc_t); break;
10273 case 6232: esalt_size = sizeof (tc_t); break;
10274 case 6233: esalt_size = sizeof (tc_t); break;
10275 case 6241: esalt_size = sizeof (tc_t); break;
10276 case 6242: esalt_size = sizeof (tc_t); break;
10277 case 6243: esalt_size = sizeof (tc_t); break;
10278 case 6600: esalt_size = sizeof (agilekey_t); break;
10279 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10280 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10281 case 7300: esalt_size = sizeof (rakp_t); break;
10282 case 7500: esalt_size = sizeof (krb5pa_t); break;
10283 case 8200: esalt_size = sizeof (cloudkey_t); break;
10284 case 8800: esalt_size = sizeof (androidfde_t); break;
10285 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10286 case 9400: esalt_size = sizeof (office2007_t); break;
10287 case 9500: esalt_size = sizeof (office2010_t); break;
10288 case 9600: esalt_size = sizeof (office2013_t); break;
10289 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10290 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10291 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10292 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10293 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10294 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10295 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10296 case 10200: esalt_size = sizeof (cram_md5_t); break;
10297 case 10400: esalt_size = sizeof (pdf_t); break;
10298 case 10410: esalt_size = sizeof (pdf_t); break;
10299 case 10420: esalt_size = sizeof (pdf_t); break;
10300 case 10500: esalt_size = sizeof (pdf_t); break;
10301 case 10600: esalt_size = sizeof (pdf_t); break;
10302 case 10700: esalt_size = sizeof (pdf_t); break;
10303 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10304 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10305 case 11400: esalt_size = sizeof (sip_t); break;
10306 case 11600: esalt_size = sizeof (seven_zip_t); break;
10307 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10308 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10309 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10310 case 13000: esalt_size = sizeof (rar5_t); break;
10311 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10312 }
10313
10314 data.esalt_size = esalt_size;
10315
10316 /**
10317 * choose dictionary parser
10318 */
10319
10320 if (hash_type == HASH_TYPE_LM)
10321 {
10322 get_next_word_func = get_next_word_lm;
10323 }
10324 else if (opts_type & OPTS_TYPE_PT_UPPER)
10325 {
10326 get_next_word_func = get_next_word_uc;
10327 }
10328 else
10329 {
10330 get_next_word_func = get_next_word_std;
10331 }
10332
10333 /**
10334 * dictstat
10335 */
10336
10337 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10338
10339 #ifdef _POSIX
10340 size_t dictstat_nmemb = 0;
10341 #endif
10342
10343 #ifdef _WIN
10344 uint dictstat_nmemb = 0;
10345 #endif
10346
10347 char dictstat[256] = { 0 };
10348
10349 FILE *dictstat_fp = NULL;
10350
10351 if (keyspace == 0)
10352 {
10353 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10354
10355 dictstat_fp = fopen (dictstat, "rb");
10356
10357 if (dictstat_fp)
10358 {
10359 #ifdef _POSIX
10360 struct stat tmpstat;
10361
10362 fstat (fileno (dictstat_fp), &tmpstat);
10363 #endif
10364
10365 #ifdef _WIN
10366 struct stat64 tmpstat;
10367
10368 _fstat64 (fileno (dictstat_fp), &tmpstat);
10369 #endif
10370
10371 if (tmpstat.st_mtime < COMPTIME)
10372 {
10373 /* with v0.15 the format changed so we have to ensure user is using a good version
10374 since there is no version-header in the dictstat file */
10375
10376 fclose (dictstat_fp);
10377
10378 unlink (dictstat);
10379 }
10380 else
10381 {
10382 while (!feof (dictstat_fp))
10383 {
10384 dictstat_t d;
10385
10386 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10387
10388 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10389
10390 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10391 {
10392 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10393
10394 return -1;
10395 }
10396 }
10397
10398 fclose (dictstat_fp);
10399 }
10400 }
10401 }
10402
10403 /**
10404 * potfile
10405 */
10406
10407 char potfile[256] = { 0 };
10408
10409 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10410
10411 data.pot_fp = NULL;
10412
10413 FILE *out_fp = NULL;
10414 FILE *pot_fp = NULL;
10415
10416 if (show == 1 || left == 1)
10417 {
10418 pot_fp = fopen (potfile, "rb");
10419
10420 if (pot_fp == NULL)
10421 {
10422 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10423
10424 return (-1);
10425 }
10426
10427 if (outfile != NULL)
10428 {
10429 if ((out_fp = fopen (outfile, "ab")) == NULL)
10430 {
10431 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10432
10433 fclose (pot_fp);
10434
10435 return (-1);
10436 }
10437 }
10438 else
10439 {
10440 out_fp = stdout;
10441 }
10442 }
10443 else
10444 {
10445 if (potfile_disable == 0)
10446 {
10447 pot_fp = fopen (potfile, "ab");
10448
10449 if (pot_fp == NULL)
10450 {
10451 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10452
10453 return (-1);
10454 }
10455
10456 data.pot_fp = pot_fp;
10457 }
10458 }
10459
10460 pot_t *pot = NULL;
10461
10462 uint pot_cnt = 0;
10463 uint pot_avail = 0;
10464
10465 if (show == 1 || left == 1)
10466 {
10467 SUPPRESS_OUTPUT = 1;
10468
10469 pot_avail = count_lines (pot_fp);
10470
10471 rewind (pot_fp);
10472
10473 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10474
10475 uint pot_hashes_avail = 0;
10476
10477 uint line_num = 0;
10478
10479 while (!feof (pot_fp))
10480 {
10481 line_num++;
10482
10483 char line_buf[BUFSIZ] = { 0 };
10484
10485 int line_len = fgetl (pot_fp, line_buf);
10486
10487 if (line_len == 0) continue;
10488
10489 char *plain_buf = line_buf + line_len;
10490
10491 pot_t *pot_ptr = &pot[pot_cnt];
10492
10493 hash_t *hashes_buf = &pot_ptr->hash;
10494
10495 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10496 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10497
10498 if (pot_cnt == pot_hashes_avail)
10499 {
10500 uint pos = 0;
10501
10502 for (pos = 0; pos < INCR_POT; pos++)
10503 {
10504 if ((pot_cnt + pos) >= pot_avail) break;
10505
10506 pot_t *tmp_pot = &pot[pot_cnt + pos];
10507
10508 hash_t *tmp_hash = &tmp_pot->hash;
10509
10510 tmp_hash->digest = mymalloc (dgst_size);
10511
10512 if (isSalted)
10513 {
10514 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10515 }
10516
10517 if (esalt_size)
10518 {
10519 tmp_hash->esalt = mymalloc (esalt_size);
10520 }
10521
10522 pot_hashes_avail++;
10523 }
10524 }
10525
10526 int plain_len = 0;
10527
10528 int parser_status;
10529
10530 int iter = MAX_CUT_TRIES;
10531
10532 do
10533 {
10534 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10535 {
10536 if (line_buf[i] == ':')
10537 {
10538 line_len--;
10539
10540 break;
10541 }
10542 }
10543
10544 if (data.hash_mode != 2500)
10545 {
10546 parser_status = parse_func (line_buf, line_len, hashes_buf);
10547 }
10548 else
10549 {
10550 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10551
10552 if (line_len > max_salt_size)
10553 {
10554 parser_status = PARSER_GLOBAL_LENGTH;
10555 }
10556 else
10557 {
10558 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10559
10560 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10561
10562 hashes_buf->salt->salt_len = line_len;
10563
10564 parser_status = PARSER_OK;
10565 }
10566 }
10567
10568 // if NOT parsed without error, we add the ":" to the plain
10569
10570 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10571 {
10572 plain_len++;
10573 plain_buf--;
10574 }
10575
10576 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10577
10578 if (parser_status < PARSER_GLOBAL_ZERO)
10579 {
10580 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10581
10582 continue;
10583 }
10584
10585 if (plain_len >= 255) continue;
10586
10587 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10588
10589 pot_ptr->plain_len = plain_len;
10590
10591 pot_cnt++;
10592 }
10593
10594 fclose (pot_fp);
10595
10596 SUPPRESS_OUTPUT = 0;
10597
10598 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10599 }
10600
10601 /**
10602 * word len
10603 */
10604
10605 uint pw_min = PW_MIN;
10606 uint pw_max = PW_MAX;
10607
10608 switch (hash_mode)
10609 {
10610 case 400: if (pw_max > 40) pw_max = 40;
10611 break;
10612 case 500: if (pw_max > 16) pw_max = 16;
10613 break;
10614 case 1500: if (pw_max > 8) pw_max = 8;
10615 break;
10616 case 1600: if (pw_max > 16) pw_max = 16;
10617 break;
10618 case 1800: if (pw_max > 16) pw_max = 16;
10619 break;
10620 case 2100: if (pw_max > 16) pw_max = 16;
10621 break;
10622 case 2500: if (pw_min < 8) pw_min = 8;
10623 break;
10624 case 3000: if (pw_max > 7) pw_max = 7;
10625 break;
10626 case 5200: if (pw_max > 24) pw_max = 24;
10627 break;
10628 case 5800: if (pw_max > 16) pw_max = 16;
10629 break;
10630 case 6300: if (pw_max > 16) pw_max = 16;
10631 break;
10632 case 7400: if (pw_max > 16) pw_max = 16;
10633 break;
10634 case 7900: if (pw_max > 48) pw_max = 48;
10635 break;
10636 case 8500: if (pw_max > 8) pw_max = 8;
10637 break;
10638 case 8600: if (pw_max > 16) pw_max = 16;
10639 break;
10640 case 9710: pw_min = 5;
10641 pw_max = 5;
10642 break;
10643 case 9810: pw_min = 5;
10644 pw_max = 5;
10645 break;
10646 case 10410: pw_min = 5;
10647 pw_max = 5;
10648 break;
10649 case 10300: if (pw_max < 3) pw_min = 3;
10650 if (pw_max > 40) pw_max = 40;
10651 break;
10652 case 10500: if (pw_max < 3) pw_min = 3;
10653 if (pw_max > 40) pw_max = 40;
10654 break;
10655 case 10700: if (pw_max > 16) pw_max = 16;
10656 break;
10657 case 11300: if (pw_max > 40) pw_max = 40;
10658 break;
10659 case 12500: if (pw_max > 20) pw_max = 20;
10660 break;
10661 case 12800: if (pw_max > 24) pw_max = 24;
10662 break;
10663 }
10664
10665 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10666 {
10667 switch (attack_kern)
10668 {
10669 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10670 break;
10671 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10672 break;
10673 }
10674 }
10675
10676 /**
10677 * charsets : keep them together for more easy maintainnce
10678 */
10679
10680 cs_t mp_sys[6] = { { { 0 }, 0 } };
10681 cs_t mp_usr[4] = { { { 0 }, 0 } };
10682
10683 mp_setup_sys (mp_sys);
10684
10685 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10686 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10687 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10688 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10689
10690 /**
10691 * load hashes, part I: find input mode, count hashes
10692 */
10693
10694 uint hashlist_mode = 0;
10695 uint hashlist_format = HLFMT_HASHCAT;
10696
10697 uint hashes_avail = 0;
10698
10699 if (benchmark == 0)
10700 {
10701 struct stat f;
10702
10703 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10704
10705 if ((hash_mode == 2500) ||
10706 (hash_mode == 5200) ||
10707 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10708 (hash_mode == 9000))
10709 {
10710 hashlist_mode = HL_MODE_ARG;
10711
10712 char *hashfile = myargv[optind];
10713
10714 data.hashfile = hashfile;
10715
10716 logfile_top_var_string ("target", hashfile);
10717 }
10718
10719 if (hashlist_mode == HL_MODE_ARG)
10720 {
10721 if (hash_mode == 2500)
10722 {
10723 struct stat st;
10724
10725 if (stat (data.hashfile, &st) == -1)
10726 {
10727 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10728
10729 return (-1);
10730 }
10731
10732 hashes_avail = st.st_size / sizeof (hccap_t);
10733 }
10734 else
10735 {
10736 hashes_avail = 1;
10737 }
10738 }
10739 else if (hashlist_mode == HL_MODE_FILE)
10740 {
10741 char *hashfile = myargv[optind];
10742
10743 data.hashfile = hashfile;
10744
10745 logfile_top_var_string ("target", hashfile);
10746
10747 FILE *fp = NULL;
10748
10749 if ((fp = fopen (hashfile, "rb")) == NULL)
10750 {
10751 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10752
10753 return (-1);
10754 }
10755
10756 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10757
10758 hashes_avail = count_lines (fp);
10759
10760 rewind (fp);
10761
10762 if (hashes_avail == 0)
10763 {
10764 log_error ("ERROR: hashfile is empty or corrupt");
10765
10766 fclose (fp);
10767
10768 return (-1);
10769 }
10770
10771 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10772
10773 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10774 {
10775 log_error ("ERROR: remove not supported in native hashfile-format mode");
10776
10777 fclose (fp);
10778
10779 return (-1);
10780 }
10781
10782 fclose (fp);
10783 }
10784 }
10785 else
10786 {
10787 hashlist_mode = HL_MODE_ARG;
10788
10789 hashes_avail = 1;
10790 }
10791
10792 if (hash_mode == 3000) hashes_avail *= 2;
10793
10794 data.hashlist_mode = hashlist_mode;
10795 data.hashlist_format = hashlist_format;
10796
10797 logfile_top_uint (hashlist_mode);
10798 logfile_top_uint (hashlist_format);
10799
10800 /**
10801 * load hashes, part II: allocate required memory, set pointers
10802 */
10803
10804 hash_t *hashes_buf = NULL;
10805 void *digests_buf = NULL;
10806 salt_t *salts_buf = NULL;
10807 void *esalts_buf = NULL;
10808
10809 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10810
10811 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10812
10813 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10814 {
10815 u32 hash_pos;
10816
10817 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10818 {
10819 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10820
10821 hashes_buf[hash_pos].hash_info = hash_info;
10822
10823 if (username && (remove || show || left))
10824 {
10825 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10826 }
10827
10828 if (benchmark)
10829 {
10830 hash_info->orighash = (char *) mymalloc (256);
10831 }
10832 }
10833 }
10834
10835 if (isSalted)
10836 {
10837 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10838
10839 if (esalt_size)
10840 {
10841 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10842 }
10843 }
10844 else
10845 {
10846 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10847 }
10848
10849 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10850 {
10851 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10852
10853 if (isSalted)
10854 {
10855 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10856
10857 if (esalt_size)
10858 {
10859 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10860 }
10861 }
10862 else
10863 {
10864 hashes_buf[hash_pos].salt = &salts_buf[0];
10865 }
10866 }
10867
10868 /**
10869 * load hashes, part III: parse hashes or generate them if benchmark
10870 */
10871
10872 uint hashes_cnt = 0;
10873
10874 if (benchmark == 0)
10875 {
10876 if (keyspace == 1)
10877 {
10878 // useless to read hash file for keyspace, cheat a little bit w/ optind
10879 }
10880 else if (hashes_avail == 0)
10881 {
10882 }
10883 else if (hashlist_mode == HL_MODE_ARG)
10884 {
10885 char *input_buf = myargv[optind];
10886
10887 uint input_len = strlen (input_buf);
10888
10889 logfile_top_var_string ("target", input_buf);
10890
10891 char *hash_buf = NULL;
10892 int hash_len = 0;
10893
10894 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10895
10896 if (hash_len)
10897 {
10898 if (opts_type & OPTS_TYPE_HASH_COPY)
10899 {
10900 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10901
10902 hash_info_tmp->orighash = mystrdup (hash_buf);
10903 }
10904
10905 if (isSalted)
10906 {
10907 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10908 }
10909
10910 int parser_status = PARSER_OK;
10911
10912 if (hash_mode == 2500)
10913 {
10914 if (hash_len == 0)
10915 {
10916 log_error ("ERROR: hccap file not specified");
10917
10918 return (-1);
10919 }
10920
10921 hashlist_mode = HL_MODE_FILE;
10922
10923 data.hashlist_mode = hashlist_mode;
10924
10925 FILE *fp = fopen (hash_buf, "rb");
10926
10927 if (fp == NULL)
10928 {
10929 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10930
10931 return (-1);
10932 }
10933
10934 if (hashes_avail < 1)
10935 {
10936 log_error ("ERROR: hccap file is empty or corrupt");
10937
10938 fclose (fp);
10939
10940 return (-1);
10941 }
10942
10943 uint hccap_size = sizeof (hccap_t);
10944
10945 char *in = (char *) mymalloc (hccap_size);
10946
10947 while (!feof (fp))
10948 {
10949 int n = fread (in, hccap_size, 1, fp);
10950
10951 if (n != 1)
10952 {
10953 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10954
10955 break;
10956 }
10957
10958 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10959
10960 if (parser_status != PARSER_OK)
10961 {
10962 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10963
10964 continue;
10965 }
10966
10967 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10968
10969 if ((show == 1) || (left == 1))
10970 {
10971 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10972
10973 char *salt_ptr = (char *) tmp_salt->salt_buf;
10974
10975 int cur_pos = tmp_salt->salt_len;
10976 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10977
10978 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10979
10980 u8 *pke_ptr = (u8 *) wpa->pke;
10981
10982 // do the appending task
10983
10984 snprintf (salt_ptr + cur_pos,
10985 rem_len,
10986 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10987 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10988 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10989
10990
10991 // memset () the remaining part of the salt
10992
10993 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10994 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10995
10996 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10997
10998 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10999 }
11000
11001 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);
11002 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);
11003
11004 hashes_cnt++;
11005 }
11006
11007 fclose (fp);
11008
11009 myfree (in);
11010 }
11011 else if (hash_mode == 3000)
11012 {
11013 if (hash_len == 32)
11014 {
11015 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11016
11017 hash_t *lm_hash_left = NULL;
11018
11019 if (parser_status == PARSER_OK)
11020 {
11021 lm_hash_left = &hashes_buf[hashes_cnt];
11022
11023 hashes_cnt++;
11024 }
11025 else
11026 {
11027 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11028 }
11029
11030 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11031
11032 hash_t *lm_hash_right = NULL;
11033
11034 if (parser_status == PARSER_OK)
11035 {
11036 lm_hash_right = &hashes_buf[hashes_cnt];
11037
11038 hashes_cnt++;
11039 }
11040 else
11041 {
11042 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11043 }
11044
11045 // show / left
11046
11047 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11048 {
11049 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);
11050 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);
11051 }
11052 }
11053 else
11054 {
11055 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11056
11057 if (parser_status == PARSER_OK)
11058 {
11059 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11060 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11061 }
11062
11063 if (parser_status == PARSER_OK)
11064 {
11065 hashes_cnt++;
11066 }
11067 else
11068 {
11069 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11070 }
11071 }
11072 }
11073 else
11074 {
11075 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11076
11077 if (parser_status == PARSER_OK)
11078 {
11079 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11080 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11081 }
11082
11083 if (parser_status == PARSER_OK)
11084 {
11085 hashes_cnt++;
11086 }
11087 else
11088 {
11089 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11090 }
11091 }
11092 }
11093 }
11094 else if (hashlist_mode == HL_MODE_FILE)
11095 {
11096 char *hashfile = data.hashfile;
11097
11098 FILE *fp;
11099
11100 if ((fp = fopen (hashfile, "rb")) == NULL)
11101 {
11102 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11103
11104 return (-1);
11105 }
11106
11107 uint line_num = 0;
11108
11109 while (!feof (fp))
11110 {
11111 line_num++;
11112
11113 char line_buf[BUFSIZ] = { 0 };
11114
11115 int line_len = fgetl (fp, line_buf);
11116
11117 if (line_len == 0) continue;
11118
11119 char *hash_buf = NULL;
11120 int hash_len = 0;
11121
11122 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11123
11124 if (username)
11125 {
11126 char *user_buf = NULL;
11127 int user_len = 0;
11128
11129 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11130
11131 if (remove || show)
11132 {
11133 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11134
11135 *user = (user_t *) mymalloc (sizeof (user_t));
11136
11137 user_t *user_ptr = *user;
11138
11139 if (user_buf != NULL)
11140 {
11141 user_ptr->user_name = mystrdup (user_buf);
11142 }
11143 else
11144 {
11145 user_ptr->user_name = mystrdup ("");
11146 }
11147
11148 user_ptr->user_len = user_len;
11149 }
11150 }
11151
11152 if (opts_type & OPTS_TYPE_HASH_COPY)
11153 {
11154 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11155
11156 hash_info_tmp->orighash = mystrdup (hash_buf);
11157 }
11158
11159 if (isSalted)
11160 {
11161 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11162 }
11163
11164 if (hash_mode == 3000)
11165 {
11166 if (hash_len == 32)
11167 {
11168 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11169
11170 if (parser_status < PARSER_GLOBAL_ZERO)
11171 {
11172 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11173
11174 continue;
11175 }
11176
11177 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11178
11179 hashes_cnt++;
11180
11181 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11182
11183 if (parser_status < PARSER_GLOBAL_ZERO)
11184 {
11185 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11186
11187 continue;
11188 }
11189
11190 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11191
11192 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);
11193
11194 hashes_cnt++;
11195
11196 // show / left
11197
11198 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);
11199 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);
11200 }
11201 else
11202 {
11203 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11204
11205 if (parser_status < PARSER_GLOBAL_ZERO)
11206 {
11207 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11208
11209 continue;
11210 }
11211
11212 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);
11213
11214 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11215 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11216
11217 hashes_cnt++;
11218 }
11219 }
11220 else
11221 {
11222 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11223
11224 if (parser_status < PARSER_GLOBAL_ZERO)
11225 {
11226 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11227
11228 continue;
11229 }
11230
11231 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);
11232
11233 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11234 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11235
11236 hashes_cnt++;
11237 }
11238 }
11239
11240 fclose (fp);
11241
11242 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11243
11244 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11245 }
11246 }
11247 else
11248 {
11249 if (isSalted)
11250 {
11251 hashes_buf[0].salt->salt_len = 8;
11252
11253 // special salt handling
11254
11255 switch (hash_mode)
11256 {
11257 case 1500: hashes_buf[0].salt->salt_len = 2;
11258 break;
11259 case 1731: hashes_buf[0].salt->salt_len = 4;
11260 break;
11261 case 2410: hashes_buf[0].salt->salt_len = 4;
11262 break;
11263 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11264 break;
11265 case 3100: hashes_buf[0].salt->salt_len = 1;
11266 break;
11267 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11268 break;
11269 case 5800: hashes_buf[0].salt->salt_len = 16;
11270 break;
11271 case 6800: hashes_buf[0].salt->salt_len = 32;
11272 break;
11273 case 8400: hashes_buf[0].salt->salt_len = 40;
11274 break;
11275 case 8800: hashes_buf[0].salt->salt_len = 16;
11276 break;
11277 case 8900: hashes_buf[0].salt->salt_len = 16;
11278 hashes_buf[0].salt->scrypt_N = 1024;
11279 hashes_buf[0].salt->scrypt_r = 1;
11280 hashes_buf[0].salt->scrypt_p = 1;
11281 break;
11282 case 9100: hashes_buf[0].salt->salt_len = 16;
11283 break;
11284 case 9300: hashes_buf[0].salt->salt_len = 14;
11285 hashes_buf[0].salt->scrypt_N = 16384;
11286 hashes_buf[0].salt->scrypt_r = 1;
11287 hashes_buf[0].salt->scrypt_p = 1;
11288 break;
11289 case 9400: hashes_buf[0].salt->salt_len = 16;
11290 break;
11291 case 9500: hashes_buf[0].salt->salt_len = 16;
11292 break;
11293 case 9600: hashes_buf[0].salt->salt_len = 16;
11294 break;
11295 case 9700: hashes_buf[0].salt->salt_len = 16;
11296 break;
11297 case 9710: hashes_buf[0].salt->salt_len = 16;
11298 break;
11299 case 9720: hashes_buf[0].salt->salt_len = 16;
11300 break;
11301 case 9800: hashes_buf[0].salt->salt_len = 16;
11302 break;
11303 case 9810: hashes_buf[0].salt->salt_len = 16;
11304 break;
11305 case 9820: hashes_buf[0].salt->salt_len = 16;
11306 break;
11307 case 10300: hashes_buf[0].salt->salt_len = 12;
11308 break;
11309 case 11500: hashes_buf[0].salt->salt_len = 4;
11310 break;
11311 case 11600: hashes_buf[0].salt->salt_len = 4;
11312 break;
11313 case 12400: hashes_buf[0].salt->salt_len = 4;
11314 break;
11315 case 12500: hashes_buf[0].salt->salt_len = 8;
11316 break;
11317 case 12600: hashes_buf[0].salt->salt_len = 64;
11318 break;
11319 }
11320
11321 // special esalt handling
11322
11323 switch (hash_mode)
11324 {
11325 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11326 break;
11327 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11328 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11329 break;
11330 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11331 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11332 break;
11333 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11334 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11335 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11336 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11337 break;
11338 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11339 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11340 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11341 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11342 break;
11343 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11344 break;
11345 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11346 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11347 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11348 break;
11349 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11350 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11351 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11352 break;
11353 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11354 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11355 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11356 break;
11357 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11358 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11359 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11360 break;
11361 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11362 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11363 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11364 break;
11365 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11366 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11367 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11368 break;
11369 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11370 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11371 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11372 break;
11373 }
11374 }
11375
11376 // set hashfile
11377
11378 switch (hash_mode)
11379 {
11380 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11381 break;
11382 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11383 break;
11384 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11385 break;
11386 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11387 break;
11388 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11389 break;
11390 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11391 break;
11392 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11393 break;
11394 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11395 break;
11396 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11397 break;
11398 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11399 break;
11400 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11401 break;
11402 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11403 break;
11404 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11405 break;
11406 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11407 break;
11408 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11409 break;
11410 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11411 break;
11412 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11413 break;
11414 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11415 break;
11416 }
11417
11418 // set default iterations
11419
11420 switch (hash_mode)
11421 {
11422 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11423 break;
11424 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11425 break;
11426 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11427 break;
11428 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11429 break;
11430 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11431 break;
11432 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11433 break;
11434 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11435 break;
11436 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11437 break;
11438 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11439 break;
11440 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11441 break;
11442 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11443 break;
11444 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11445 break;
11446 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11447 break;
11448 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11449 break;
11450 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11451 break;
11452 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11453 break;
11454 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11455 break;
11456 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11457 break;
11458 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11459 break;
11460 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11461 break;
11462 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11463 break;
11464 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11465 break;
11466 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11467 break;
11468 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11469 break;
11470 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11471 break;
11472 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11473 break;
11474 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11475 break;
11476 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11477 break;
11478 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11479 break;
11480 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11481 break;
11482 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11483 break;
11484 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11485 break;
11486 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11487 break;
11488 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11489 break;
11490 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11491 break;
11492 case 8900: hashes_buf[0].salt->salt_iter = 1;
11493 break;
11494 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11495 break;
11496 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11497 break;
11498 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11499 break;
11500 case 9300: hashes_buf[0].salt->salt_iter = 1;
11501 break;
11502 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11503 break;
11504 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11505 break;
11506 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11507 break;
11508 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11509 break;
11510 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11511 break;
11512 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11513 break;
11514 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11515 break;
11516 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11517 break;
11518 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11519 break;
11520 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11521 break;
11522 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11523 break;
11524 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11525 break;
11526 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11527 break;
11528 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11529 break;
11530 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11531 break;
11532 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11533 break;
11534 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11535 break;
11536 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11537 break;
11538 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11539 break;
11540 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11541 break;
11542 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11543 break;
11544 }
11545
11546 hashes_cnt = 1;
11547 }
11548
11549 if (show == 1 || left == 1)
11550 {
11551 for (uint i = 0; i < pot_cnt; i++)
11552 {
11553 pot_t *pot_ptr = &pot[i];
11554
11555 hash_t *hashes_buf = &pot_ptr->hash;
11556
11557 local_free (hashes_buf->digest);
11558
11559 if (isSalted)
11560 {
11561 local_free (hashes_buf->salt);
11562 }
11563 }
11564
11565 local_free (pot);
11566
11567 if (data.quiet == 0) log_info_nn ("");
11568
11569 return (0);
11570 }
11571
11572 if (keyspace == 0)
11573 {
11574 if (hashes_cnt == 0)
11575 {
11576 log_error ("ERROR: No hashes loaded");
11577
11578 return (-1);
11579 }
11580 }
11581
11582 /**
11583 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11584 */
11585
11586 if (data.outfile != NULL)
11587 {
11588 if (data.hashfile != NULL)
11589 {
11590 #ifdef _POSIX
11591 struct stat tmpstat_outfile;
11592 struct stat tmpstat_hashfile;
11593 #endif
11594
11595 #ifdef _WIN
11596 struct stat64 tmpstat_outfile;
11597 struct stat64 tmpstat_hashfile;
11598 #endif
11599
11600 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11601
11602 if (tmp_outfile_fp)
11603 {
11604 #ifdef _POSIX
11605 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11606 #endif
11607
11608 #ifdef _WIN
11609 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11610 #endif
11611
11612 fclose (tmp_outfile_fp);
11613 }
11614
11615 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11616
11617 if (tmp_hashfile_fp)
11618 {
11619 #ifdef _POSIX
11620 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11621 #endif
11622
11623 #ifdef _WIN
11624 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11625 #endif
11626
11627 fclose (tmp_hashfile_fp);
11628 }
11629
11630 if (tmp_outfile_fp && tmp_outfile_fp)
11631 {
11632 tmpstat_outfile.st_mode = 0;
11633 tmpstat_outfile.st_nlink = 0;
11634 tmpstat_outfile.st_uid = 0;
11635 tmpstat_outfile.st_gid = 0;
11636 tmpstat_outfile.st_rdev = 0;
11637 tmpstat_outfile.st_atime = 0;
11638
11639 tmpstat_hashfile.st_mode = 0;
11640 tmpstat_hashfile.st_nlink = 0;
11641 tmpstat_hashfile.st_uid = 0;
11642 tmpstat_hashfile.st_gid = 0;
11643 tmpstat_hashfile.st_rdev = 0;
11644 tmpstat_hashfile.st_atime = 0;
11645
11646 #ifdef _POSIX
11647 tmpstat_outfile.st_blksize = 0;
11648 tmpstat_outfile.st_blocks = 0;
11649
11650 tmpstat_hashfile.st_blksize = 0;
11651 tmpstat_hashfile.st_blocks = 0;
11652 #endif
11653
11654 #ifdef _POSIX
11655 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11656 {
11657 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11658
11659 return (-1);
11660 }
11661 #endif
11662
11663 #ifdef _WIN
11664 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11665 {
11666 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11667
11668 return (-1);
11669 }
11670 #endif
11671 }
11672 }
11673 }
11674
11675 /**
11676 * Remove duplicates
11677 */
11678
11679 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11680
11681 if (isSalted)
11682 {
11683 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11684 }
11685 else
11686 {
11687 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11688 }
11689
11690 uint hashes_cnt_orig = hashes_cnt;
11691
11692 hashes_cnt = 1;
11693
11694 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11695 {
11696 if (isSalted)
11697 {
11698 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11699 {
11700 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11701 }
11702 }
11703 else
11704 {
11705 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11706 }
11707
11708 if (hashes_pos > hashes_cnt)
11709 {
11710 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11711 }
11712
11713 hashes_cnt++;
11714 }
11715
11716 /**
11717 * Potfile removes
11718 */
11719
11720 uint potfile_remove_cracks = 0;
11721
11722 if (potfile_disable == 0)
11723 {
11724 hash_t hash_buf;
11725
11726 hash_buf.digest = mymalloc (dgst_size);
11727 hash_buf.salt = NULL;
11728 hash_buf.esalt = NULL;
11729 hash_buf.hash_info = NULL;
11730 hash_buf.cracked = 0;
11731
11732 if (isSalted)
11733 {
11734 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11735 }
11736
11737 if (esalt_size)
11738 {
11739 hash_buf.esalt = mymalloc (esalt_size);
11740 }
11741
11742 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11743
11744 // no solution for these special hash types (for instane because they use hashfile in output etc)
11745 if ((hash_mode != 5200) &&
11746 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11747 (hash_mode != 9000))
11748 {
11749 FILE *fp = fopen (potfile, "rb");
11750
11751 if (fp != NULL)
11752 {
11753 while (!feof (fp))
11754 {
11755 char line_buf[BUFSIZ] = { 0 };
11756
11757 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11758
11759 if (ptr == NULL) break;
11760
11761 int line_len = strlen (line_buf);
11762
11763 if (line_len == 0) continue;
11764
11765 int iter = MAX_CUT_TRIES;
11766
11767 for (int i = line_len - 1; i && iter; i--, line_len--)
11768 {
11769 if (line_buf[i] != ':') continue;
11770
11771 if (isSalted)
11772 {
11773 memset (hash_buf.salt, 0, sizeof (salt_t));
11774 }
11775
11776 hash_t *found = NULL;
11777
11778 if (hash_mode == 6800)
11779 {
11780 if (i < 64) // 64 = 16 * uint in salt_buf[]
11781 {
11782 // manipulate salt_buf
11783 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11784
11785 hash_buf.salt->salt_len = i;
11786
11787 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11788 }
11789 }
11790 else if (hash_mode == 2500)
11791 {
11792 if (i < 64) // 64 = 16 * uint in salt_buf[]
11793 {
11794 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11795 // manipulate salt_buf
11796
11797 // to be safe work with a copy (because of line_len loop, i etc)
11798
11799 char line_buf_cpy[BUFSIZ] = { 0 };
11800
11801 memcpy (line_buf_cpy, line_buf, i);
11802
11803 char *mac2_pos = strrchr (line_buf_cpy, ':');
11804
11805 if (mac2_pos == NULL) continue;
11806
11807 mac2_pos[0] = 0;
11808 mac2_pos++;
11809
11810 if (strlen (mac2_pos) != 12) continue;
11811
11812 char *mac1_pos = strrchr (line_buf_cpy, ':');
11813
11814 if (mac1_pos == NULL) continue;
11815
11816 mac1_pos[0] = 0;
11817 mac1_pos++;
11818
11819 if (strlen (mac1_pos) != 12) continue;
11820
11821 uint essid_length = mac1_pos - line_buf_cpy - 1;
11822
11823 // here we need the ESSID
11824 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11825
11826 hash_buf.salt->salt_len = essid_length;
11827
11828 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11829
11830 if (found)
11831 {
11832 wpa_t *wpa = (wpa_t *) found->esalt;
11833
11834 uint pke[25] = { 0 };
11835
11836 char *pke_ptr = (char *) pke;
11837
11838 for (uint i = 0; i < 25; i++)
11839 {
11840 pke[i] = byte_swap_32 (wpa->pke[i]);
11841 }
11842
11843 u8 mac1[6] = { 0 };
11844 u8 mac2[6] = { 0 };
11845
11846 memcpy (mac1, pke_ptr + 23, 6);
11847 memcpy (mac2, pke_ptr + 29, 6);
11848
11849 // compare hex string(s) vs binary MAC address(es)
11850
11851 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11852 {
11853 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11854 {
11855 found = NULL;
11856 break;
11857 }
11858 }
11859
11860 // early skip ;)
11861 if (!found) continue;
11862
11863 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11864 {
11865 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11866 {
11867 found = NULL;
11868 break;
11869 }
11870 }
11871 }
11872 }
11873 }
11874 else
11875 {
11876 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11877
11878 if (parser_status == PARSER_OK)
11879 {
11880 if (isSalted)
11881 {
11882 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11883 }
11884 else
11885 {
11886 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11887 }
11888 }
11889 }
11890
11891 if (found == NULL) continue;
11892
11893 if (!found->cracked) potfile_remove_cracks++;
11894
11895 found->cracked = 1;
11896
11897 if (found) break;
11898
11899 iter--;
11900 }
11901 }
11902
11903 fclose (fp);
11904 }
11905 }
11906
11907 if (esalt_size)
11908 {
11909 local_free (hash_buf.esalt);
11910 }
11911
11912 if (isSalted)
11913 {
11914 local_free (hash_buf.salt);
11915 }
11916
11917 local_free (hash_buf.digest);
11918 }
11919
11920 /**
11921 * Now generate all the buffers required for later
11922 */
11923
11924 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11925
11926 salt_t *salts_buf_new = NULL;
11927 void *esalts_buf_new = NULL;
11928
11929 if (isSalted)
11930 {
11931 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11932
11933 if (esalt_size)
11934 {
11935 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11936 }
11937 }
11938 else
11939 {
11940 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11941 }
11942
11943 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11944
11945 uint digests_cnt = hashes_cnt;
11946 uint digests_done = 0;
11947
11948 uint size_digests = digests_cnt * dgst_size;
11949 uint size_shown = digests_cnt * sizeof (uint);
11950
11951 uint *digests_shown = (uint *) mymalloc (size_shown);
11952 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11953
11954 uint salts_cnt = 0;
11955 uint salts_done = 0;
11956
11957 hashinfo_t **hash_info = NULL;
11958
11959 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11960 {
11961 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11962
11963 if (username && (remove || show))
11964 {
11965 uint user_pos;
11966
11967 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11968 {
11969 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11970
11971 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11972 }
11973 }
11974 }
11975
11976 uint *salts_shown = (uint *) mymalloc (size_shown);
11977
11978 salt_t *salt_buf;
11979
11980 {
11981 // copied from inner loop
11982
11983 salt_buf = &salts_buf_new[salts_cnt];
11984
11985 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11986
11987 if (esalt_size)
11988 {
11989 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11990 }
11991
11992 salt_buf->digests_cnt = 0;
11993 salt_buf->digests_done = 0;
11994 salt_buf->digests_offset = 0;
11995
11996 salts_cnt++;
11997 }
11998
11999 if (hashes_buf[0].cracked == 1)
12000 {
12001 digests_shown[0] = 1;
12002
12003 digests_done++;
12004
12005 salt_buf->digests_done++;
12006 }
12007
12008 salt_buf->digests_cnt++;
12009
12010 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12011
12012 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12013 {
12014 hash_info[0] = hashes_buf[0].hash_info;
12015 }
12016
12017 // copy from inner loop
12018
12019 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12020 {
12021 if (isSalted)
12022 {
12023 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12024 {
12025 salt_buf = &salts_buf_new[salts_cnt];
12026
12027 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12028
12029 if (esalt_size)
12030 {
12031 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12032 }
12033
12034 salt_buf->digests_cnt = 0;
12035 salt_buf->digests_done = 0;
12036 salt_buf->digests_offset = hashes_pos;
12037
12038 salts_cnt++;
12039 }
12040 }
12041
12042 if (hashes_buf[hashes_pos].cracked == 1)
12043 {
12044 digests_shown[hashes_pos] = 1;
12045
12046 digests_done++;
12047
12048 salt_buf->digests_done++;
12049 }
12050
12051 salt_buf->digests_cnt++;
12052
12053 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12054
12055 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12056 {
12057 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12058 }
12059 }
12060
12061 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12062 {
12063 salt_t *salt_buf = &salts_buf_new[salt_pos];
12064
12065 if (salt_buf->digests_done == salt_buf->digests_cnt)
12066 {
12067 salts_shown[salt_pos] = 1;
12068
12069 salts_done++;
12070 }
12071
12072 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12073 }
12074
12075 local_free (digests_buf);
12076 local_free (salts_buf);
12077 local_free (esalts_buf);
12078
12079 digests_buf = digests_buf_new;
12080 salts_buf = salts_buf_new;
12081 esalts_buf = esalts_buf_new;
12082
12083 local_free (hashes_buf);
12084
12085 /**
12086 * special modification not set from parser
12087 */
12088
12089 switch (hash_mode)
12090 {
12091 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12092 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12093 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12094 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12095 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12096 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12097 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12098 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12099 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12100 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12101 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12102 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12103 }
12104
12105 if (truecrypt_keyfiles)
12106 {
12107 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12108
12109 char *keyfiles = strdup (truecrypt_keyfiles);
12110
12111 char *keyfile = strtok (keyfiles, ",");
12112
12113 do
12114 {
12115 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12116
12117 } while ((keyfile = strtok (NULL, ",")) != NULL);
12118
12119 free (keyfiles);
12120 }
12121
12122 data.digests_cnt = digests_cnt;
12123 data.digests_done = digests_done;
12124 data.digests_buf = digests_buf;
12125 data.digests_shown = digests_shown;
12126 data.digests_shown_tmp = digests_shown_tmp;
12127
12128 data.salts_cnt = salts_cnt;
12129 data.salts_done = salts_done;
12130 data.salts_buf = salts_buf;
12131 data.salts_shown = salts_shown;
12132
12133 data.esalts_buf = esalts_buf;
12134 data.hash_info = hash_info;
12135
12136 /**
12137 * Automatic Optimizers
12138 */
12139
12140 if (salts_cnt == 1)
12141 opti_type |= OPTI_TYPE_SINGLE_SALT;
12142
12143 if (digests_cnt == 1)
12144 opti_type |= OPTI_TYPE_SINGLE_HASH;
12145
12146 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12147 opti_type |= OPTI_TYPE_NOT_ITERATED;
12148
12149 if (attack_mode == ATTACK_MODE_BF)
12150 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12151
12152 data.opti_type = opti_type;
12153
12154 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12155 {
12156 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12157 {
12158 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12159 {
12160 if (opts_type & OPTS_TYPE_ST_ADD80)
12161 {
12162 opts_type &= ~OPTS_TYPE_ST_ADD80;
12163 opts_type |= OPTS_TYPE_PT_ADD80;
12164 }
12165
12166 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12167 {
12168 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12169 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12170 }
12171
12172 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12173 {
12174 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12175 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12176 }
12177 }
12178 }
12179 }
12180
12181 /**
12182 * Some algorithm, like descrypt, can benefit from JIT compilation
12183 */
12184
12185 int force_jit_compilation = -1;
12186
12187 if (hash_mode == 8900)
12188 {
12189 force_jit_compilation = 8900;
12190 }
12191 else if (hash_mode == 9300)
12192 {
12193 force_jit_compilation = 8900;
12194 }
12195 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12196 {
12197 force_jit_compilation = 1500;
12198 }
12199
12200 /**
12201 * generate bitmap tables
12202 */
12203
12204 const uint bitmap_shift1 = 5;
12205 const uint bitmap_shift2 = 13;
12206
12207 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12208
12209 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12210 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12211 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12212 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12213 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12214 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12215 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12216 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12217
12218 uint bitmap_bits;
12219 uint bitmap_nums;
12220 uint bitmap_mask;
12221 uint bitmap_size;
12222
12223 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12224 {
12225 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12226
12227 bitmap_nums = 1 << bitmap_bits;
12228
12229 bitmap_mask = bitmap_nums - 1;
12230
12231 bitmap_size = bitmap_nums * sizeof (uint);
12232
12233 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12234
12235 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;
12236 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;
12237
12238 break;
12239 }
12240
12241 bitmap_nums = 1 << bitmap_bits;
12242
12243 bitmap_mask = bitmap_nums - 1;
12244
12245 bitmap_size = bitmap_nums * sizeof (uint);
12246
12247 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);
12248 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);
12249
12250 /**
12251 * prepare quick rule
12252 */
12253
12254 data.rule_buf_l = rule_buf_l;
12255 data.rule_buf_r = rule_buf_r;
12256
12257 int rule_len_l = (int) strlen (rule_buf_l);
12258 int rule_len_r = (int) strlen (rule_buf_r);
12259
12260 data.rule_len_l = rule_len_l;
12261 data.rule_len_r = rule_len_r;
12262
12263 /**
12264 * load rules
12265 */
12266
12267 uint *all_kernel_rules_cnt = NULL;
12268
12269 kernel_rule_t **all_kernel_rules_buf = NULL;
12270
12271 if (rp_files_cnt)
12272 {
12273 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12274
12275 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12276 }
12277
12278 char rule_buf[BUFSIZ] = { 0 };
12279
12280 int rule_len = 0;
12281
12282 for (uint i = 0; i < rp_files_cnt; i++)
12283 {
12284 uint kernel_rules_avail = 0;
12285
12286 uint kernel_rules_cnt = 0;
12287
12288 kernel_rule_t *kernel_rules_buf = NULL;
12289
12290 char *rp_file = rp_files[i];
12291
12292 char in[BLOCK_SIZE] = { 0 };
12293 char out[BLOCK_SIZE] = { 0 };
12294
12295 FILE *fp = NULL;
12296
12297 uint rule_line = 0;
12298
12299 if ((fp = fopen (rp_file, "rb")) == NULL)
12300 {
12301 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12302
12303 return (-1);
12304 }
12305
12306 while (!feof (fp))
12307 {
12308 memset (rule_buf, 0, BUFSIZ);
12309
12310 rule_len = fgetl (fp, rule_buf);
12311
12312 rule_line++;
12313
12314 if (rule_len == 0) continue;
12315
12316 if (rule_buf[0] == '#') continue;
12317
12318 if (kernel_rules_avail == kernel_rules_cnt)
12319 {
12320 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12321
12322 kernel_rules_avail += INCR_RULES;
12323 }
12324
12325 memset (in, 0, BLOCK_SIZE);
12326 memset (out, 0, BLOCK_SIZE);
12327
12328 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12329
12330 if (result == -1)
12331 {
12332 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12333
12334 continue;
12335 }
12336
12337 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12338 {
12339 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12340
12341 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12342
12343 continue;
12344 }
12345
12346 /* its so slow
12347 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12348 {
12349 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12350
12351 continue;
12352 }
12353 */
12354
12355 kernel_rules_cnt++;
12356 }
12357
12358 fclose (fp);
12359
12360 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12361
12362 all_kernel_rules_buf[i] = kernel_rules_buf;
12363 }
12364
12365 /**
12366 * merge rules or automatic rule generator
12367 */
12368
12369 uint kernel_rules_cnt = 0;
12370
12371 kernel_rule_t *kernel_rules_buf = NULL;
12372
12373 if (attack_mode == ATTACK_MODE_STRAIGHT)
12374 {
12375 if (rp_files_cnt)
12376 {
12377 kernel_rules_cnt = 1;
12378
12379 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12380
12381 repeats[0] = kernel_rules_cnt;
12382
12383 for (uint i = 0; i < rp_files_cnt; i++)
12384 {
12385 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12386
12387 repeats[i + 1] = kernel_rules_cnt;
12388 }
12389
12390 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12391
12392 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12393
12394 for (uint i = 0; i < kernel_rules_cnt; i++)
12395 {
12396 uint out_pos = 0;
12397
12398 kernel_rule_t *out = &kernel_rules_buf[i];
12399
12400 for (uint j = 0; j < rp_files_cnt; j++)
12401 {
12402 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12403 uint in_pos;
12404
12405 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12406
12407 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12408 {
12409 if (out_pos == RULES_MAX - 1)
12410 {
12411 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12412
12413 break;
12414 }
12415
12416 out->cmds[out_pos] = in->cmds[in_pos];
12417 }
12418 }
12419 }
12420
12421 local_free (repeats);
12422 }
12423 else if (rp_gen)
12424 {
12425 uint kernel_rules_avail = 0;
12426
12427 while (kernel_rules_cnt < rp_gen)
12428 {
12429 if (kernel_rules_avail == kernel_rules_cnt)
12430 {
12431 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12432
12433 kernel_rules_avail += INCR_RULES;
12434 }
12435
12436 memset (rule_buf, 0, BLOCK_SIZE);
12437
12438 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12439
12440 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12441
12442 kernel_rules_cnt++;
12443 }
12444 }
12445 }
12446
12447 /**
12448 * generate NOP rules
12449 */
12450
12451 if (kernel_rules_cnt == 0)
12452 {
12453 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12454
12455 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12456
12457 kernel_rules_cnt++;
12458 }
12459
12460 data.kernel_rules_cnt = kernel_rules_cnt;
12461 data.kernel_rules_buf = kernel_rules_buf;
12462
12463 /**
12464 * OpenCL platforms: detect
12465 */
12466
12467 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12468 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12469
12470 cl_uint platforms_cnt = 0;
12471 cl_uint platform_devices_cnt = 0;
12472
12473 if (keyspace == 0)
12474 {
12475 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12476
12477 if (platforms_cnt == 0)
12478 {
12479 log_error ("ERROR: No OpenCL compatible platform found");
12480
12481 return (-1);
12482 }
12483 }
12484
12485 /**
12486 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12487 */
12488
12489 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12490 {
12491 cl_platform_id platform = platforms[platform_id];
12492
12493 char platform_vendor[INFOSZ] = { 0 };
12494
12495 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12496
12497 #ifdef HAVE_HWMON
12498 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12499 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12500 {
12501 // make sure that we do not directly control the fan for NVidia
12502
12503 gpu_temp_retain = 0;
12504
12505 data.gpu_temp_retain = gpu_temp_retain;
12506 }
12507 #endif // HAVE_NVML || HAVE_NVAPI
12508 #endif
12509 }
12510
12511 /**
12512 * OpenCL devices: simply push all devices from all platforms into the same device array
12513 */
12514
12515 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12516
12517 data.devices_param = devices_param;
12518
12519 uint devices_cnt = 0;
12520
12521 uint devices_active = 0;
12522
12523 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12524 {
12525 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12526
12527 cl_platform_id platform = platforms[platform_id];
12528
12529 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12530
12531 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12532 {
12533 size_t param_value_size = 0;
12534
12535 const uint device_id = devices_cnt;
12536
12537 hc_device_param_t *device_param = &data.devices_param[device_id];
12538
12539 device_param->device = platform_devices[platform_devices_id];
12540
12541 device_param->device_id = device_id;
12542
12543 device_param->platform_devices_id = platform_devices_id;
12544
12545 // device_type
12546
12547 cl_device_type device_type;
12548
12549 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12550
12551 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12552
12553 device_param->device_type = device_type;
12554
12555 // vendor_id
12556
12557 cl_uint vendor_id = 0;
12558
12559 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12560
12561 device_param->vendor_id = vendor_id;
12562
12563 // device_name
12564
12565 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12566
12567 char *device_name = (char *) mymalloc (param_value_size);
12568
12569 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12570
12571 device_param->device_name = device_name;
12572
12573 // tuning db
12574
12575 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12576
12577 // device_version
12578
12579 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12580
12581 char *device_version = (char *) mymalloc (param_value_size);
12582
12583 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12584
12585 device_param->device_version = device_version;
12586
12587 // device_opencl_version
12588
12589 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12590
12591 char *device_opencl_version = (char *) mymalloc (param_value_size);
12592
12593 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12594
12595 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12596
12597 myfree (device_opencl_version);
12598
12599 if (strstr (device_version, "pocl"))
12600 {
12601 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12602 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12603
12604 cl_uint vendor_id = VENDOR_ID_GENERIC;
12605
12606 device_param->vendor_id = vendor_id;
12607 }
12608
12609 // vector_width
12610
12611 cl_uint vector_width;
12612
12613 if (opencl_vector_width_chgd == 0)
12614 {
12615 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12616 {
12617 if (opti_type & OPTI_TYPE_USES_BITS_64)
12618 {
12619 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12620 }
12621 else
12622 {
12623 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12624 }
12625 }
12626 else
12627 {
12628 vector_width = (cl_uint) tuningdb_entry->vector_width;
12629 }
12630 }
12631 else
12632 {
12633 vector_width = opencl_vector_width;
12634 }
12635
12636 if (vector_width > 16) vector_width = 16;
12637
12638 device_param->vector_width = vector_width;
12639
12640 // max_compute_units
12641
12642 cl_uint device_processors;
12643
12644 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12645
12646 device_param->device_processors = device_processors;
12647
12648 // max_mem_alloc_size
12649
12650 cl_ulong device_maxmem_alloc;
12651
12652 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12653
12654 device_param->device_maxmem_alloc = device_maxmem_alloc;
12655
12656 // max_mem_alloc_size
12657
12658 cl_ulong device_global_mem;
12659
12660 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12661
12662 device_param->device_global_mem = device_global_mem;
12663
12664 // max_clock_frequency
12665
12666 cl_uint device_maxclock_frequency;
12667
12668 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12669
12670 device_param->device_maxclock_frequency = device_maxclock_frequency;
12671
12672 // skipped
12673
12674 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12675 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12676
12677 device_param->skipped = (skipped1 || skipped2);
12678
12679 // driver_version
12680 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12681
12682 char *driver_version = (char *) mymalloc (param_value_size);
12683
12684 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12685
12686 device_param->driver_version = driver_version;
12687
12688 // device_name_chksum
12689
12690 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12691
12692 #if __x86_64__
12693 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);
12694 #else
12695 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);
12696 #endif
12697
12698 uint device_name_digest[4] = { 0 };
12699
12700 md5_64 ((uint *) device_name_chksum, device_name_digest);
12701
12702 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12703
12704 device_param->device_name_chksum = device_name_chksum;
12705
12706 // device_processor_cores
12707
12708 if (device_type & CL_DEVICE_TYPE_CPU)
12709 {
12710 cl_uint device_processor_cores = 1;
12711
12712 device_param->device_processor_cores = device_processor_cores;
12713 }
12714
12715 if (device_type & CL_DEVICE_TYPE_GPU)
12716 {
12717 if (vendor_id == VENDOR_ID_AMD)
12718 {
12719 cl_uint device_processor_cores = 0;
12720
12721 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12722
12723 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12724
12725 device_param->device_processor_cores = device_processor_cores;
12726 }
12727 else if (vendor_id == VENDOR_ID_NV)
12728 {
12729 cl_uint kernel_exec_timeout = 0;
12730
12731 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12732
12733 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12734
12735 device_param->kernel_exec_timeout = kernel_exec_timeout;
12736
12737 cl_uint device_processor_cores = 0;
12738
12739 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12740
12741 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12742
12743 device_param->device_processor_cores = device_processor_cores;
12744
12745 cl_uint sm_minor = 0;
12746 cl_uint sm_major = 0;
12747
12748 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12749 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12750
12751 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12752 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12753
12754 device_param->sm_minor = sm_minor;
12755 device_param->sm_major = sm_major;
12756 }
12757 else
12758 {
12759 cl_uint device_processor_cores = 1;
12760
12761 device_param->device_processor_cores = device_processor_cores;
12762 }
12763 }
12764
12765 // display results
12766
12767 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12768 {
12769 if (device_param->skipped == 0)
12770 {
12771 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12772 device_id + 1,
12773 device_name,
12774 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12775 (unsigned int) (device_global_mem / 1024 / 1024),
12776 (unsigned int) (device_maxclock_frequency),
12777 (unsigned int) device_processors);
12778 }
12779 else
12780 {
12781 log_info ("Device #%u: %s, skipped",
12782 device_id + 1,
12783 device_name);
12784 }
12785 }
12786
12787 // common driver check
12788
12789 if (device_param->skipped == 0)
12790 {
12791 if (strstr (device_version, "pocl"))
12792 {
12793 if (force == 0)
12794 {
12795 log_info ("");
12796 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12797 log_info ("You are STRONGLY encouraged not to use it");
12798 log_info ("You can use --force to override this but do not post error reports if you do so");
12799 log_info ("");
12800
12801 return (-1);
12802 }
12803 }
12804
12805 if (device_type & CL_DEVICE_TYPE_GPU)
12806 {
12807 if (vendor_id == VENDOR_ID_NV)
12808 {
12809 if (device_param->kernel_exec_timeout != 0)
12810 {
12811 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);
12812 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12813 }
12814 }
12815 else if (vendor_id == VENDOR_ID_AMD)
12816 {
12817 int catalyst_check = (force == 1) ? 0 : 1;
12818
12819 int catalyst_warn = 0;
12820
12821 int catalyst_broken = 0;
12822
12823 if (catalyst_check == 1)
12824 {
12825 catalyst_warn = 1;
12826
12827 // v14.9 and higher
12828 if (atoi (device_param->driver_version) >= 1573)
12829 {
12830 catalyst_warn = 0;
12831 }
12832
12833 catalyst_check = 0;
12834 }
12835
12836 if (catalyst_broken == 1)
12837 {
12838 log_info ("");
12839 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12840 log_info ("It will pass over cracked hashes and does not report them as cracked");
12841 log_info ("You are STRONGLY encouraged not to use it");
12842 log_info ("You can use --force to override this but do not post error reports if you do so");
12843 log_info ("");
12844
12845 return (-1);
12846 }
12847
12848 if (catalyst_warn == 1)
12849 {
12850 log_info ("");
12851 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12852 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12853 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12854 #ifdef _WIN
12855 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12856 #endif
12857 log_info ("You can use --force to override this but do not post error reports if you do so");
12858 log_info ("");
12859
12860 return (-1);
12861 }
12862 }
12863 }
12864
12865 /**
12866 * kernel accel and loops tuning db adjustment
12867 */
12868
12869 device_param->kernel_accel_min = 1;
12870 device_param->kernel_accel_max = 1024;
12871
12872 device_param->kernel_loops_min = 1;
12873 device_param->kernel_loops_max = 1024;
12874
12875 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12876
12877 if (tuningdb_entry)
12878 {
12879 u32 _kernel_accel = tuningdb_entry->kernel_accel;
12880 u32 _kernel_loops = tuningdb_entry->kernel_loops;
12881
12882 if (_kernel_accel)
12883 {
12884 device_param->kernel_accel_min = _kernel_accel;
12885 device_param->kernel_accel_max = _kernel_accel;
12886 }
12887
12888 if (_kernel_loops)
12889 {
12890 if (workload_profile == 1)
12891 {
12892 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
12893 }
12894 else if (workload_profile == 2)
12895 {
12896 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
12897 }
12898
12899 device_param->kernel_loops_min = _kernel_loops;
12900 device_param->kernel_loops_max = _kernel_loops;
12901 }
12902 }
12903
12904 // commandline parameters overwrite tuningdb entries
12905
12906 if (kernel_accel)
12907 {
12908 device_param->kernel_accel_min = kernel_accel;
12909 device_param->kernel_accel_max = kernel_accel;
12910 }
12911
12912 if (kernel_loops)
12913 {
12914 device_param->kernel_loops_min = kernel_loops;
12915 device_param->kernel_loops_max = kernel_loops;
12916 }
12917
12918 /**
12919 * activate device
12920 */
12921
12922 devices_active++;
12923 }
12924
12925 // next please
12926
12927 devices_cnt++;
12928 }
12929 }
12930
12931 if (keyspace == 0 && devices_active == 0)
12932 {
12933 log_error ("ERROR: No devices found/left");
12934
12935 return (-1);
12936 }
12937
12938 data.devices_cnt = devices_cnt;
12939
12940 data.devices_active = devices_active;
12941
12942 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12943 {
12944 log_info ("");
12945 }
12946
12947 /**
12948 * HM devices: init
12949 */
12950
12951 #ifdef HAVE_HWMON
12952 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12953 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12954 #endif
12955
12956 #ifdef HAVE_ADL
12957 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12958 #endif
12959
12960 if (gpu_temp_disable == 0)
12961 {
12962 #if defined(WIN) && defined(HAVE_NVAPI)
12963 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
12964
12965 if (nvapi_init (nvapi) == 0)
12966 data.hm_nv = nvapi;
12967
12968 if (data.hm_nv)
12969 {
12970 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
12971 {
12972 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
12973
12974 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12975
12976 int tmp_out = 0;
12977
12978 for (int i = 0; i < tmp_in; i++)
12979 {
12980 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12981 }
12982
12983 for (int i = 0; i < tmp_out; i++)
12984 {
12985 NV_GPU_COOLER_SETTINGS pCoolerSettings;
12986
12987 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
12988
12989 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;
12990 }
12991 }
12992 }
12993 #endif // WIN && HAVE_NVAPI
12994
12995 #if defined(LINUX) && defined(HAVE_NVML)
12996 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
12997
12998 if (nvml_init (nvml) == 0)
12999 data.hm_nv = nvml;
13000
13001 if (data.hm_nv)
13002 {
13003 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13004 {
13005 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13006
13007 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13008
13009 int tmp_out = 0;
13010
13011 for (int i = 0; i < tmp_in; i++)
13012 {
13013 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13014 }
13015
13016 for (int i = 0; i < tmp_out; i++)
13017 {
13018 unsigned int speed;
13019
13020 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;
13021 }
13022 }
13023 }
13024 #endif // LINUX && HAVE_NVML
13025
13026 data.hm_amd = NULL;
13027
13028 #ifdef HAVE_ADL
13029 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13030
13031 if (adl_init (adl) == 0)
13032 data.hm_amd = adl;
13033
13034 if (data.hm_amd)
13035 {
13036 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13037 {
13038 // total number of adapters
13039
13040 int hm_adapters_num;
13041
13042 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13043
13044 // adapter info
13045
13046 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13047
13048 if (lpAdapterInfo == NULL) return (-1);
13049
13050 // get a list (of ids of) valid/usable adapters
13051
13052 int num_adl_adapters = 0;
13053
13054 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13055
13056 if (num_adl_adapters > 0)
13057 {
13058 hc_thread_mutex_lock (mux_adl);
13059
13060 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13061
13062 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13063
13064 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13065 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13066
13067 hc_thread_mutex_unlock (mux_adl);
13068 }
13069
13070 myfree (valid_adl_device_list);
13071 myfree (lpAdapterInfo);
13072 }
13073 }
13074 #endif // HAVE_ADL
13075
13076 if (data.hm_amd == NULL && data.hm_nv == NULL)
13077 {
13078 gpu_temp_disable = 1;
13079 }
13080 }
13081
13082 /**
13083 * OpenCL devices: allocate buffer for device specific information
13084 */
13085
13086 #ifdef HAVE_HWMON
13087 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13088
13089 #ifdef HAVE_ADL
13090 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13091
13092 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13093 #endif // ADL
13094 #endif
13095
13096 /**
13097 * enable custom signal handler(s)
13098 */
13099
13100 if (benchmark == 0)
13101 {
13102 hc_signal (sigHandler_default);
13103 }
13104 else
13105 {
13106 hc_signal (sigHandler_benchmark);
13107 }
13108
13109 /**
13110 * User-defined GPU temp handling
13111 */
13112
13113 #ifdef HAVE_HWMON
13114 if (gpu_temp_disable == 1)
13115 {
13116 gpu_temp_abort = 0;
13117 gpu_temp_retain = 0;
13118 }
13119
13120 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13121 {
13122 if (gpu_temp_abort < gpu_temp_retain)
13123 {
13124 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13125
13126 return (-1);
13127 }
13128 }
13129
13130 data.gpu_temp_disable = gpu_temp_disable;
13131 data.gpu_temp_abort = gpu_temp_abort;
13132 data.gpu_temp_retain = gpu_temp_retain;
13133 #endif
13134
13135 /**
13136 * inform the user
13137 */
13138
13139 if (data.quiet == 0)
13140 {
13141 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13142
13143 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);
13144
13145 if (attack_mode == ATTACK_MODE_STRAIGHT)
13146 {
13147 log_info ("Rules: %u", kernel_rules_cnt);
13148 }
13149
13150 if (opti_type)
13151 {
13152 log_info ("Applicable Optimizers:");
13153
13154 for (uint i = 0; i < 32; i++)
13155 {
13156 const uint opti_bit = 1u << i;
13157
13158 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13159 }
13160 }
13161
13162 /**
13163 * Watchdog and Temperature balance
13164 */
13165
13166 #ifdef HAVE_HWMON
13167 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13168 {
13169 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13170 }
13171
13172 if (gpu_temp_abort == 0)
13173 {
13174 log_info ("Watchdog: Temperature abort trigger disabled");
13175 }
13176 else
13177 {
13178 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13179 }
13180
13181 if (gpu_temp_retain == 0)
13182 {
13183 log_info ("Watchdog: Temperature retain trigger disabled");
13184 }
13185 else
13186 {
13187 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13188 }
13189 #endif
13190 }
13191
13192 if (data.quiet == 0) log_info ("");
13193
13194 /**
13195 * HM devices: copy
13196 */
13197
13198 if (gpu_temp_disable == 0)
13199 {
13200 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13201 {
13202 hc_device_param_t *device_param = &data.devices_param[device_id];
13203
13204 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13205
13206 if (device_param->skipped) continue;
13207
13208 const uint platform_devices_id = device_param->platform_devices_id;
13209
13210 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13211 if (device_param->vendor_id == VENDOR_ID_NV)
13212 {
13213 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13214 }
13215 #endif
13216
13217 #ifdef HAVE_ADL
13218 if (device_param->vendor_id == VENDOR_ID_AMD)
13219 {
13220 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13221 }
13222 #endif
13223 }
13224 }
13225
13226 /*
13227 * Temporary fix:
13228 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13229 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13230 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13231 * Driver / ADL bug?
13232 */
13233
13234 #ifdef HAVE_ADL
13235 if (powertune_enable == 1)
13236 {
13237 hc_thread_mutex_lock (mux_adl);
13238
13239 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13240 {
13241 hc_device_param_t *device_param = &data.devices_param[device_id];
13242
13243 if (device_param->skipped) continue;
13244
13245 if (data.hm_device[device_id].od_version == 6)
13246 {
13247 // set powertune value only
13248
13249 int powertune_supported = 0;
13250
13251 int ADL_rc = 0;
13252
13253 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13254 {
13255 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13256
13257 return (-1);
13258 }
13259
13260 if (powertune_supported != 0)
13261 {
13262 // powertune set
13263 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13264
13265 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13266 {
13267 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13268
13269 return (-1);
13270 }
13271
13272 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13273 {
13274 log_error ("ERROR: Failed to set new ADL PowerControl values");
13275
13276 return (-1);
13277 }
13278 }
13279 }
13280 }
13281
13282 hc_thread_mutex_unlock (mux_adl);
13283 }
13284 #endif // HAVE_ADK
13285 #endif // HAVE_HWMON
13286
13287 #ifdef DEBUG
13288 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13289 #endif
13290
13291 uint kernel_power_all = 0;
13292
13293 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13294 {
13295 /**
13296 * host buffer
13297 */
13298
13299 hc_device_param_t *device_param = &data.devices_param[device_id];
13300
13301 if (device_param->skipped) continue;
13302
13303 /**
13304 * device properties
13305 */
13306
13307 const char *device_name_chksum = device_param->device_name_chksum;
13308 const u32 device_processors = device_param->device_processors;
13309 const u32 device_processor_cores = device_param->device_processor_cores;
13310
13311 /**
13312 * create context for each device
13313 */
13314
13315 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13316
13317 /**
13318 * create command-queue
13319 */
13320
13321 // not supported with NV
13322 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13323
13324 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13325
13326 /**
13327 * create input buffers on device : calculate size of fixed memory buffers
13328 */
13329
13330 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13331 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13332
13333 device_param->size_root_css = size_root_css;
13334 device_param->size_markov_css = size_markov_css;
13335
13336 uint size_results = KERNEL_THREADS * sizeof (uint);
13337
13338 device_param->size_results = size_results;
13339
13340 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13341 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13342
13343 uint size_plains = digests_cnt * sizeof (plain_t);
13344 uint size_salts = salts_cnt * sizeof (salt_t);
13345 uint size_esalts = salts_cnt * esalt_size;
13346
13347 device_param->size_plains = size_plains;
13348 device_param->size_digests = size_digests;
13349 device_param->size_shown = size_shown;
13350 device_param->size_salts = size_salts;
13351
13352 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13353 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13354 uint size_tm = 32 * sizeof (bs_word_t);
13355
13356 // scryptV stuff
13357
13358 u64 size_scryptV = 1;
13359
13360 if ((hash_mode == 8900) || (hash_mode == 9300))
13361 {
13362 uint tmto_start = 0;
13363 uint tmto_stop = 10;
13364
13365 if (scrypt_tmto)
13366 {
13367 tmto_start = scrypt_tmto;
13368 }
13369 else
13370 {
13371 // in case the user did not specify the tmto manually
13372 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13373 // but set the lower end only in case the user has a device with too less memory
13374
13375 if (hash_mode == 8900)
13376 {
13377 if (device_param->vendor_id == VENDOR_ID_AMD)
13378 {
13379 tmto_start = 1;
13380 }
13381 else if (device_param->vendor_id == VENDOR_ID_NV)
13382 {
13383 tmto_start = 3;
13384 }
13385 }
13386 else if (hash_mode == 9300)
13387 {
13388 if (device_param->vendor_id == VENDOR_ID_AMD)
13389 {
13390 tmto_start = 3;
13391 }
13392 else if (device_param->vendor_id == VENDOR_ID_NV)
13393 {
13394 tmto_start = 5;
13395 }
13396 }
13397 }
13398
13399 if (quiet == 0) log_info ("");
13400
13401 uint shader_per_mp = 1;
13402
13403 if (device_param->vendor_id == VENDOR_ID_AMD)
13404 {
13405 shader_per_mp = 8;
13406 }
13407 else if (device_param->vendor_id == VENDOR_ID_NV)
13408 {
13409 shader_per_mp = 32;
13410 }
13411
13412 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13413 {
13414 // TODO: in theory the following calculation needs to be done per salt, not global
13415 // we assume all hashes have the same scrypt settings
13416
13417 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13418
13419 size_scryptV /= 1 << tmto;
13420
13421 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13422
13423 if (size_scryptV > device_param->device_maxmem_alloc)
13424 {
13425 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13426
13427 continue;
13428 }
13429
13430 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13431 {
13432 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13433 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13434 }
13435
13436 break;
13437 }
13438
13439 if (data.salts_buf[0].scrypt_phy == 0)
13440 {
13441 log_error ("ERROR: can't allocate enough device memory");
13442
13443 return -1;
13444 }
13445
13446 if (quiet == 0) log_info ("");
13447 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13448 }
13449
13450 /**
13451 * create input buffers on device : calculate size of dynamic size memory buffers
13452 */
13453
13454 uint kernel_threads = KERNEL_THREADS;
13455
13456 // some algorithms need a fixed kernel-threads count (mostly because of shared memory usage)
13457
13458 if (hash_mode == 3200) kernel_threads = 8;
13459 if (hash_mode == 9000) kernel_threads = 8;
13460
13461 /**
13462 * some algorithms need a fixed kernel-loops count
13463 */
13464
13465 if (hash_mode == 1500)
13466 {
13467 const u32 kernel_loops_fixed = 1024;
13468
13469 device_param->kernel_loops_min = kernel_loops_fixed;
13470 device_param->kernel_loops_max = kernel_loops_fixed;
13471 }
13472
13473 if (hash_mode == 3000)
13474 {
13475 const u32 kernel_loops_fixed = 1024;
13476
13477 device_param->kernel_loops_min = kernel_loops_fixed;
13478 device_param->kernel_loops_max = kernel_loops_fixed;
13479 }
13480
13481 if (hash_mode == 8900)
13482 {
13483 const u32 kernel_loops_fixed = 1;
13484
13485 device_param->kernel_loops_min = kernel_loops_fixed;
13486 device_param->kernel_loops_max = kernel_loops_fixed;
13487 }
13488
13489 if (hash_mode == 9300)
13490 {
13491 const u32 kernel_loops_fixed = 1;
13492
13493 device_param->kernel_loops_min = kernel_loops_fixed;
13494 device_param->kernel_loops_max = kernel_loops_fixed;
13495 }
13496
13497 if (hash_mode == 12500)
13498 {
13499 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13500
13501 device_param->kernel_loops_min = kernel_loops_fixed;
13502 device_param->kernel_loops_max = kernel_loops_fixed;
13503 }
13504
13505 /**
13506 * some algorithms have a maximum kernel-loops count
13507 */
13508
13509 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13510 {
13511 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13512 {
13513 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13514 }
13515 }
13516
13517 /**
13518 * some algorithms need a special kernel-accel
13519 */
13520
13521 if (hash_mode == 8900)
13522 {
13523 device_param->kernel_accel_min = 1;
13524 device_param->kernel_accel_max = 64;
13525 }
13526
13527 if (hash_mode == 9300)
13528 {
13529 device_param->kernel_accel_min = 1;
13530 device_param->kernel_accel_max = 64;
13531 }
13532
13533 u32 kernel_accel_min = device_param->kernel_accel_min;
13534 u32 kernel_accel_max = device_param->kernel_accel_max;
13535
13536 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13537
13538 uint size_pws = 4;
13539 uint size_tmps = 4;
13540 uint size_hooks = 4;
13541
13542 while (kernel_accel_max >= kernel_accel_min)
13543 {
13544 uint kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13545
13546 // size_pws
13547
13548 size_pws = kernel_power_max * sizeof (pw_t);
13549
13550 // size_tmps
13551
13552 switch (hash_mode)
13553 {
13554 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13555 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13556 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13557 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13558 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13559 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13560 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13561 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13562 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13563 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13564 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13565 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13566 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13567 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13568 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13569 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13570 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13571 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13572 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13573 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13574 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13575 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13576 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13577 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13578 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13579 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13580 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13581 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13582 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13583 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13584 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13585 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13586 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13587 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13588 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13589 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13590 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13591 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13592 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13593 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13594 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13595 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13596 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13597 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13598 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13599 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13600 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13601 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13602 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13603 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13604 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13605 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13606 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13607 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13608 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13609 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13610 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13611 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13612 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13613 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13614 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13615 };
13616
13617 // size_hooks
13618
13619 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13620 {
13621 // none yet
13622 }
13623
13624 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13625 // if not, decrease amplifier and try again
13626
13627 int skip = 0;
13628
13629 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13630 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13631 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13632
13633 if (( bitmap_size
13634 + bitmap_size
13635 + bitmap_size
13636 + bitmap_size
13637 + bitmap_size
13638 + bitmap_size
13639 + bitmap_size
13640 + bitmap_size
13641 + size_bfs
13642 + size_combs
13643 + size_digests
13644 + size_esalts
13645 + size_hooks
13646 + size_markov_css
13647 + size_plains
13648 + size_pws
13649 + size_results
13650 + size_root_css
13651 + size_rules
13652 + size_rules_c
13653 + size_salts
13654 + size_scryptV
13655 + size_shown
13656 + size_tm
13657 + size_tmps) > device_param->device_global_mem) skip = 1;
13658
13659 if (skip == 1)
13660 {
13661 kernel_accel_max--;
13662
13663 continue;
13664 }
13665
13666 break;
13667 }
13668
13669 /*
13670 if (kernel_accel_max == 0)
13671 {
13672 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13673
13674 return -1;
13675 }
13676 */
13677
13678 device_param->kernel_accel_min = kernel_accel_min;
13679 device_param->kernel_accel_max = kernel_accel_max;
13680
13681 /*
13682 if (kernel_accel_max < kernel_accel)
13683 {
13684 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13685
13686 device_param->kernel_accel = kernel_accel_max;
13687 }
13688 */
13689
13690 device_param->size_bfs = size_bfs;
13691 device_param->size_combs = size_combs;
13692 device_param->size_rules = size_rules;
13693 device_param->size_rules_c = size_rules_c;
13694 device_param->size_pws = size_pws;
13695 device_param->size_tmps = size_tmps;
13696 device_param->size_hooks = size_hooks;
13697
13698 // do not confuse kernel_accel_max with kernel_accel here
13699
13700 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13701
13702 device_param->kernel_threads = kernel_threads;
13703 device_param->kernel_power_user = kernel_power;
13704
13705 kernel_power_all += kernel_power;
13706
13707 /**
13708 * default building options
13709 */
13710
13711 char build_opts[1024] = { 0 };
13712
13713 // we don't have sm_* on vendors not NV but it doesn't matter
13714
13715 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);
13716
13717 /**
13718 * main kernel
13719 */
13720
13721 {
13722 /**
13723 * kernel source filename
13724 */
13725
13726 char source_file[256] = { 0 };
13727
13728 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13729
13730 struct stat sst;
13731
13732 if (stat (source_file, &sst) == -1)
13733 {
13734 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13735
13736 return -1;
13737 }
13738
13739 /**
13740 * kernel cached filename
13741 */
13742
13743 char cached_file[256] = { 0 };
13744
13745 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13746
13747 int cached = 1;
13748
13749 struct stat cst;
13750
13751 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13752 {
13753 cached = 0;
13754 }
13755
13756 /**
13757 * kernel compile or load
13758 */
13759
13760 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13761
13762 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13763
13764 if (force_jit_compilation == -1)
13765 {
13766 if (cached == 0)
13767 {
13768 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13769
13770 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13771
13772 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13773
13774 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13775
13776 if (rc != 0)
13777 {
13778 device_param->skipped = true;
13779 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13780 continue;
13781 }
13782
13783 size_t binary_size;
13784
13785 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13786
13787 u8 *binary = (u8 *) mymalloc (binary_size);
13788
13789 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13790
13791 writeProgramBin (cached_file, binary, binary_size);
13792
13793 local_free (binary);
13794 }
13795 else
13796 {
13797 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13798
13799 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13800
13801 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13802
13803 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
13804 }
13805 }
13806 else
13807 {
13808 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13809
13810 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13811
13812 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13813
13814 char build_opts_update[1024] = { 0 };
13815
13816 if (force_jit_compilation == 1500)
13817 {
13818 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13819 }
13820 else if (force_jit_compilation == 8900)
13821 {
13822 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);
13823 }
13824 else
13825 {
13826 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
13827 }
13828
13829 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
13830
13831 if (rc != 0)
13832 {
13833 device_param->skipped = true;
13834
13835 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13836 }
13837 }
13838
13839 local_free (kernel_lengths);
13840 local_free (kernel_sources[0]);
13841 local_free (kernel_sources);
13842 }
13843
13844 /**
13845 * word generator kernel
13846 */
13847
13848 if (attack_mode != ATTACK_MODE_STRAIGHT)
13849 {
13850 /**
13851 * kernel mp source filename
13852 */
13853
13854 char source_file[256] = { 0 };
13855
13856 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13857
13858 struct stat sst;
13859
13860 if (stat (source_file, &sst) == -1)
13861 {
13862 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13863
13864 return -1;
13865 }
13866
13867 /**
13868 * kernel mp cached filename
13869 */
13870
13871 char cached_file[256] = { 0 };
13872
13873 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13874
13875 int cached = 1;
13876
13877 struct stat cst;
13878
13879 if (stat (cached_file, &cst) == -1)
13880 {
13881 cached = 0;
13882 }
13883
13884 /**
13885 * kernel compile or load
13886 */
13887
13888 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13889
13890 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13891
13892 if (cached == 0)
13893 {
13894 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13895
13896 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13897
13898 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13899
13900 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
13901
13902 if (rc != 0)
13903 {
13904 device_param->skipped = true;
13905 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13906 continue;
13907 }
13908
13909 size_t binary_size;
13910
13911 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13912
13913 u8 *binary = (u8 *) mymalloc (binary_size);
13914
13915 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13916
13917 writeProgramBin (cached_file, binary, binary_size);
13918
13919 local_free (binary);
13920 }
13921 else
13922 {
13923 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13924
13925 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13926
13927 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13928
13929 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
13930 }
13931
13932 local_free (kernel_lengths);
13933 local_free (kernel_sources[0]);
13934 local_free (kernel_sources);
13935 }
13936
13937 /**
13938 * amplifier kernel
13939 */
13940
13941 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13942 {
13943
13944 }
13945 else
13946 {
13947 /**
13948 * kernel amp source filename
13949 */
13950
13951 char source_file[256] = { 0 };
13952
13953 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13954
13955 struct stat sst;
13956
13957 if (stat (source_file, &sst) == -1)
13958 {
13959 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13960
13961 return -1;
13962 }
13963
13964 /**
13965 * kernel amp cached filename
13966 */
13967
13968 char cached_file[256] = { 0 };
13969
13970 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
13971
13972 int cached = 1;
13973
13974 struct stat cst;
13975
13976 if (stat (cached_file, &cst) == -1)
13977 {
13978 cached = 0;
13979 }
13980
13981 /**
13982 * kernel compile or load
13983 */
13984
13985 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13986
13987 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13988
13989 if (cached == 0)
13990 {
13991 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13992
13993 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13994
13995 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13996
13997 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
13998
13999 if (rc != 0)
14000 {
14001 device_param->skipped = true;
14002 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14003 continue;
14004 }
14005
14006 size_t binary_size;
14007
14008 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14009
14010 u8 *binary = (u8 *) mymalloc (binary_size);
14011
14012 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14013
14014 writeProgramBin (cached_file, binary, binary_size);
14015
14016 local_free (binary);
14017 }
14018 else
14019 {
14020 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14021
14022 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14023
14024 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14025
14026 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14027 }
14028
14029 local_free (kernel_lengths);
14030 local_free (kernel_sources[0]);
14031 local_free (kernel_sources);
14032 }
14033
14034 // some algorithm collide too fast, make that impossible
14035
14036 if (benchmark == 1)
14037 {
14038 ((uint *) digests_buf)[0] = -1;
14039 ((uint *) digests_buf)[1] = -1;
14040 ((uint *) digests_buf)[2] = -1;
14041 ((uint *) digests_buf)[3] = -1;
14042 }
14043
14044 /**
14045 * global buffers
14046 */
14047
14048 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14049 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14050 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14051 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14052 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14053 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14054 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14055 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14056 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14057 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14058 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14059 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14060 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14061 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14062 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14063 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14064 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14065 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14066
14067 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);
14068 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);
14069 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);
14070 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);
14071 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);
14072 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);
14073 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);
14074 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);
14075 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14076 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14077 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14078
14079 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14080 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14081 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14082 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14083 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14084 run_kernel_bzero (device_param, device_param->d_result, size_results);
14085
14086 /**
14087 * special buffers
14088 */
14089
14090 if (attack_kern == ATTACK_KERN_STRAIGHT)
14091 {
14092 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14093 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14094
14095 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14096
14097 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14098 }
14099 else if (attack_kern == ATTACK_KERN_COMBI)
14100 {
14101 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14102 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14103 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14104 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14105
14106 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14107 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14108 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14109 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14110 }
14111 else if (attack_kern == ATTACK_KERN_BF)
14112 {
14113 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14114 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14115 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14116 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14117 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14118
14119 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14120 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14121 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14122 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14123 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14124 }
14125
14126 if (size_esalts)
14127 {
14128 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14129
14130 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14131 }
14132
14133 /**
14134 * main host data
14135 */
14136
14137 uint *result = (uint *) mymalloc (size_results);
14138
14139 device_param->result = result;
14140
14141 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14142
14143 device_param->pws_buf = pws_buf;
14144
14145 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14146
14147 device_param->combs_buf = combs_buf;
14148
14149 void *hooks_buf = mymalloc (size_hooks);
14150
14151 device_param->hooks_buf = hooks_buf;
14152
14153 /**
14154 * kernel args
14155 */
14156
14157 device_param->kernel_params_buf32[21] = bitmap_mask;
14158 device_param->kernel_params_buf32[22] = bitmap_shift1;
14159 device_param->kernel_params_buf32[23] = bitmap_shift2;
14160 device_param->kernel_params_buf32[24] = 0; // salt_pos
14161 device_param->kernel_params_buf32[25] = 0; // loop_pos
14162 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14163 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14164 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14165 device_param->kernel_params_buf32[29] = 0; // digests_offset
14166 device_param->kernel_params_buf32[30] = 0; // combs_mode
14167 device_param->kernel_params_buf32[31] = 0; // gid_max
14168
14169 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14170 ? &device_param->d_pws_buf
14171 : &device_param->d_pws_amp_buf;
14172 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14173 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14174 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14175 device_param->kernel_params[ 4] = &device_param->d_tmps;
14176 device_param->kernel_params[ 5] = &device_param->d_hooks;
14177 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14178 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14179 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14180 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14181 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14182 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14183 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14184 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14185 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14186 device_param->kernel_params[15] = &device_param->d_digests_buf;
14187 device_param->kernel_params[16] = &device_param->d_digests_shown;
14188 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14189 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14190 device_param->kernel_params[19] = &device_param->d_result;
14191 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14192 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14193 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14194 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14195 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14196 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14197 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14198 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14199 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14200 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14201 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14202 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14203
14204 device_param->kernel_params_mp_buf64[3] = 0;
14205 device_param->kernel_params_mp_buf32[4] = 0;
14206 device_param->kernel_params_mp_buf32[5] = 0;
14207 device_param->kernel_params_mp_buf32[6] = 0;
14208 device_param->kernel_params_mp_buf32[7] = 0;
14209 device_param->kernel_params_mp_buf32[8] = 0;
14210
14211 device_param->kernel_params_mp[0] = NULL;
14212 device_param->kernel_params_mp[1] = NULL;
14213 device_param->kernel_params_mp[2] = NULL;
14214 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14215 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14216 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14217 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14218 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14219 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14220
14221 device_param->kernel_params_mp_l_buf64[3] = 0;
14222 device_param->kernel_params_mp_l_buf32[4] = 0;
14223 device_param->kernel_params_mp_l_buf32[5] = 0;
14224 device_param->kernel_params_mp_l_buf32[6] = 0;
14225 device_param->kernel_params_mp_l_buf32[7] = 0;
14226 device_param->kernel_params_mp_l_buf32[8] = 0;
14227 device_param->kernel_params_mp_l_buf32[9] = 0;
14228
14229 device_param->kernel_params_mp_l[0] = NULL;
14230 device_param->kernel_params_mp_l[1] = NULL;
14231 device_param->kernel_params_mp_l[2] = NULL;
14232 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14233 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14234 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14235 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14236 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14237 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14238 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14239
14240 device_param->kernel_params_mp_r_buf64[3] = 0;
14241 device_param->kernel_params_mp_r_buf32[4] = 0;
14242 device_param->kernel_params_mp_r_buf32[5] = 0;
14243 device_param->kernel_params_mp_r_buf32[6] = 0;
14244 device_param->kernel_params_mp_r_buf32[7] = 0;
14245 device_param->kernel_params_mp_r_buf32[8] = 0;
14246
14247 device_param->kernel_params_mp_r[0] = NULL;
14248 device_param->kernel_params_mp_r[1] = NULL;
14249 device_param->kernel_params_mp_r[2] = NULL;
14250 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14251 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14252 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14253 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14254 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14255 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14256
14257 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14258 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14259
14260 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14261 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14262 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14263 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14264 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14265 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14266 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14267
14268 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14269
14270 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14271 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14272
14273 /**
14274 * kernel name
14275 */
14276
14277 char kernel_name[64] = { 0 };
14278
14279 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14280 {
14281 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14282 {
14283 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14284
14285 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14286
14287 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14288
14289 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14290
14291 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14292
14293 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14294 }
14295 else
14296 {
14297 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14298
14299 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14300
14301 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14302
14303 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14304
14305 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14306
14307 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14308 }
14309
14310 if (data.attack_mode == ATTACK_MODE_BF)
14311 {
14312 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14313 {
14314 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14315
14316 device_param->kernel_tb = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14317
14318 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14319
14320 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14321 }
14322 }
14323 }
14324 else
14325 {
14326 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14327
14328 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14329
14330 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14331
14332 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14333
14334 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14335
14336 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14337
14338 if (opts_type & OPTS_TYPE_HOOK12)
14339 {
14340 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14341
14342 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14343 }
14344
14345 if (opts_type & OPTS_TYPE_HOOK23)
14346 {
14347 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14348
14349 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14350 }
14351 }
14352
14353 for (uint i = 0; i <= 20; i++)
14354 {
14355 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14356 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14357 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14358
14359 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14360 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14361 }
14362
14363 for (uint i = 21; i <= 31; i++)
14364 {
14365 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14366 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14367 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14368
14369 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14370 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14371 }
14372
14373 if (attack_mode == ATTACK_MODE_BF)
14374 {
14375 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14376 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14377
14378 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14379 {
14380 hc_clSetKernelArg (data.ocl, device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14381
14382 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14383 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14384 }
14385 }
14386 else if (attack_mode == ATTACK_MODE_HYBRID1)
14387 {
14388 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14389 }
14390 else if (attack_mode == ATTACK_MODE_HYBRID2)
14391 {
14392 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14393 }
14394
14395 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14396 {
14397 // nothing to do
14398 }
14399 else
14400 {
14401 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14402 }
14403
14404 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14405 {
14406 // nothing to do
14407 }
14408 else
14409 {
14410 for (uint i = 0; i < 5; i++)
14411 {
14412 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14413 }
14414
14415 for (uint i = 5; i < 7; i++)
14416 {
14417 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14418 }
14419 }
14420
14421 /**
14422 * Store initial fanspeed if gpu_temp_retain is enabled
14423 */
14424
14425 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14426 int gpu_temp_retain_set = 0;
14427
14428 if (gpu_temp_disable == 0)
14429 {
14430 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14431 {
14432 hc_thread_mutex_lock (mux_adl);
14433
14434 if (data.hm_device[device_id].fan_supported == 1)
14435 {
14436 if (gpu_temp_retain_chgd == 0)
14437 {
14438 uint cur_temp = 0;
14439 uint default_temp = 0;
14440
14441 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);
14442
14443 if (ADL_rc == ADL_OK)
14444 {
14445 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14446
14447 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14448
14449 // special case with multi gpu setups: always use minimum retain
14450
14451 if (gpu_temp_retain_set == 0)
14452 {
14453 gpu_temp_retain = gpu_temp_retain_target;
14454 gpu_temp_retain_set = 1;
14455 }
14456 else
14457 {
14458 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14459 }
14460
14461 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14462 }
14463 }
14464
14465 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14466
14467 temp_retain_fanspeed_value[device_id] = fan_speed;
14468
14469 if (fan_speed == -1)
14470 {
14471 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14472
14473 temp_retain_fanspeed_value[device_id] = 0;
14474 }
14475 }
14476
14477 hc_thread_mutex_unlock (mux_adl);
14478 }
14479 }
14480
14481 /**
14482 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14483 */
14484
14485 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14486 {
14487 hc_thread_mutex_lock (mux_adl);
14488
14489 if (data.hm_device[device_id].od_version == 6)
14490 {
14491 int ADL_rc;
14492
14493 // check powertune capabilities first, if not available then skip device
14494
14495 int powertune_supported = 0;
14496
14497 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14498 {
14499 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14500
14501 return (-1);
14502 }
14503
14504 if (powertune_supported != 0)
14505 {
14506 // powercontrol settings
14507
14508 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14509
14510 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14511 {
14512 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14513 }
14514
14515 if (ADL_rc != ADL_OK)
14516 {
14517 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14518
14519 return (-1);
14520 }
14521
14522 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14523 {
14524 log_error ("ERROR: Failed to set new ADL PowerControl values");
14525
14526 return (-1);
14527 }
14528
14529 // clocks
14530
14531 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14532
14533 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14534
14535 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)
14536 {
14537 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14538
14539 return (-1);
14540 }
14541
14542 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14543
14544 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14545
14546 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14547 {
14548 log_error ("ERROR: Failed to get ADL device capabilities");
14549
14550 return (-1);
14551 }
14552
14553 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14554 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14555
14556 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14557 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14558
14559 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14560 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14561
14562 // warning if profile has too low max values
14563
14564 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14565 {
14566 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14567 }
14568
14569 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14570 {
14571 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14572 }
14573
14574 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14575
14576 performance_state->iNumberOfPerformanceLevels = 2;
14577
14578 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14579 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14580 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14581 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14582
14583 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)
14584 {
14585 log_info ("ERROR: Failed to set ADL performance state");
14586
14587 return (-1);
14588 }
14589
14590 local_free (performance_state);
14591 }
14592 }
14593
14594 hc_thread_mutex_unlock (mux_adl);
14595 }
14596 #endif // HAVE_HWMON && HAVE_ADL
14597 }
14598
14599 data.kernel_power_all = kernel_power_all;
14600
14601 if (data.quiet == 0) log_info ("");
14602
14603 /**
14604 * Inform user which algorithm is checked and at which workload setting
14605 */
14606
14607 if (benchmark == 1)
14608 {
14609 quiet = 0;
14610
14611 data.quiet = quiet;
14612
14613 char *hash_type = strhashtype (data.hash_mode); // not a bug
14614
14615 log_info ("Hashtype: %s", hash_type);
14616 log_info ("");
14617 }
14618
14619 /**
14620 * keep track of the progress
14621 */
14622
14623 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14624 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14625 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14626
14627 /**
14628 * open filehandles
14629 */
14630
14631 #if _WIN
14632 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14633 {
14634 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14635
14636 return (-1);
14637 }
14638
14639 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14640 {
14641 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14642
14643 return (-1);
14644 }
14645
14646 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14647 {
14648 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14649
14650 return (-1);
14651 }
14652 #endif
14653
14654 /**
14655 * dictionary pad
14656 */
14657
14658 segment_size *= (1024 * 1024);
14659
14660 data.segment_size = segment_size;
14661
14662 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14663
14664 wl_data->buf = (char *) mymalloc (segment_size);
14665 wl_data->avail = segment_size;
14666 wl_data->incr = segment_size;
14667 wl_data->cnt = 0;
14668 wl_data->pos = 0;
14669
14670 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14671
14672 data.wordlist_mode = wordlist_mode;
14673
14674 cs_t *css_buf = NULL;
14675 uint css_cnt = 0;
14676 uint dictcnt = 0;
14677 uint maskcnt = 1;
14678 char **masks = NULL;
14679 char **dictfiles = NULL;
14680
14681 uint mask_from_file = 0;
14682
14683 if (attack_mode == ATTACK_MODE_STRAIGHT)
14684 {
14685 if (wordlist_mode == WL_MODE_FILE)
14686 {
14687 int wls_left = myargc - (optind + 1);
14688
14689 for (int i = 0; i < wls_left; i++)
14690 {
14691 char *l0_filename = myargv[optind + 1 + i];
14692
14693 struct stat l0_stat;
14694
14695 if (stat (l0_filename, &l0_stat) == -1)
14696 {
14697 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14698
14699 return (-1);
14700 }
14701
14702 uint is_dir = S_ISDIR (l0_stat.st_mode);
14703
14704 if (is_dir == 0)
14705 {
14706 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14707
14708 dictcnt++;
14709
14710 dictfiles[dictcnt - 1] = l0_filename;
14711 }
14712 else
14713 {
14714 // do not allow --keyspace w/ a directory
14715
14716 if (keyspace == 1)
14717 {
14718 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14719
14720 return (-1);
14721 }
14722
14723 char **dictionary_files = NULL;
14724
14725 dictionary_files = scan_directory (l0_filename);
14726
14727 if (dictionary_files != NULL)
14728 {
14729 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14730
14731 for (int d = 0; dictionary_files[d] != NULL; d++)
14732 {
14733 char *l1_filename = dictionary_files[d];
14734
14735 struct stat l1_stat;
14736
14737 if (stat (l1_filename, &l1_stat) == -1)
14738 {
14739 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14740
14741 return (-1);
14742 }
14743
14744 if (S_ISREG (l1_stat.st_mode))
14745 {
14746 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14747
14748 dictcnt++;
14749
14750 dictfiles[dictcnt - 1] = strdup (l1_filename);
14751 }
14752 }
14753 }
14754
14755 local_free (dictionary_files);
14756 }
14757 }
14758
14759 if (dictcnt < 1)
14760 {
14761 log_error ("ERROR: No usable dictionary file found.");
14762
14763 return (-1);
14764 }
14765 }
14766 else if (wordlist_mode == WL_MODE_STDIN)
14767 {
14768 dictcnt = 1;
14769 }
14770 }
14771 else if (attack_mode == ATTACK_MODE_COMBI)
14772 {
14773 // display
14774
14775 char *dictfile1 = myargv[optind + 1 + 0];
14776 char *dictfile2 = myargv[optind + 1 + 1];
14777
14778 // find the bigger dictionary and use as base
14779
14780 FILE *fp1 = NULL;
14781 FILE *fp2 = NULL;
14782
14783 struct stat tmp_stat;
14784
14785 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14786 {
14787 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14788
14789 return (-1);
14790 }
14791
14792 if (stat (dictfile1, &tmp_stat) == -1)
14793 {
14794 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14795
14796 fclose (fp1);
14797
14798 return (-1);
14799 }
14800
14801 if (S_ISDIR (tmp_stat.st_mode))
14802 {
14803 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14804
14805 fclose (fp1);
14806
14807 return (-1);
14808 }
14809
14810 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14811 {
14812 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14813
14814 fclose (fp1);
14815
14816 return (-1);
14817 }
14818
14819 if (stat (dictfile2, &tmp_stat) == -1)
14820 {
14821 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14822
14823 fclose (fp1);
14824 fclose (fp2);
14825
14826 return (-1);
14827 }
14828
14829 if (S_ISDIR (tmp_stat.st_mode))
14830 {
14831 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14832
14833 fclose (fp1);
14834 fclose (fp2);
14835
14836 return (-1);
14837 }
14838
14839 data.combs_cnt = 1;
14840
14841 data.quiet = 1;
14842
14843 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14844
14845 data.quiet = quiet;
14846
14847 if (words1_cnt == 0)
14848 {
14849 log_error ("ERROR: %s: empty file", dictfile1);
14850
14851 fclose (fp1);
14852 fclose (fp2);
14853
14854 return (-1);
14855 }
14856
14857 data.combs_cnt = 1;
14858
14859 data.quiet = 1;
14860
14861 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14862
14863 data.quiet = quiet;
14864
14865 if (words2_cnt == 0)
14866 {
14867 log_error ("ERROR: %s: empty file", dictfile2);
14868
14869 fclose (fp1);
14870 fclose (fp2);
14871
14872 return (-1);
14873 }
14874
14875 fclose (fp1);
14876 fclose (fp2);
14877
14878 data.dictfile = dictfile1;
14879 data.dictfile2 = dictfile2;
14880
14881 if (words1_cnt >= words2_cnt)
14882 {
14883 data.combs_cnt = words2_cnt;
14884 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14885
14886 dictfiles = &data.dictfile;
14887
14888 dictcnt = 1;
14889 }
14890 else
14891 {
14892 data.combs_cnt = words1_cnt;
14893 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14894
14895 dictfiles = &data.dictfile2;
14896
14897 dictcnt = 1;
14898
14899 // we also have to switch wordlist related rules!
14900
14901 char *tmpc = data.rule_buf_l;
14902
14903 data.rule_buf_l = data.rule_buf_r;
14904 data.rule_buf_r = tmpc;
14905
14906 int tmpi = data.rule_len_l;
14907
14908 data.rule_len_l = data.rule_len_r;
14909 data.rule_len_r = tmpi;
14910 }
14911 }
14912 else if (attack_mode == ATTACK_MODE_BF)
14913 {
14914 char *mask = NULL;
14915
14916 maskcnt = 0;
14917
14918 if (benchmark == 0)
14919 {
14920 mask = myargv[optind + 1];
14921
14922 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14923
14924 if ((optind + 2) <= myargc)
14925 {
14926 struct stat file_stat;
14927
14928 if (stat (mask, &file_stat) == -1)
14929 {
14930 maskcnt = 1;
14931
14932 masks[maskcnt - 1] = mystrdup (mask);
14933 }
14934 else
14935 {
14936 int wls_left = myargc - (optind + 1);
14937
14938 uint masks_avail = INCR_MASKS;
14939
14940 for (int i = 0; i < wls_left; i++)
14941 {
14942 if (i != 0)
14943 {
14944 mask = myargv[optind + 1 + i];
14945
14946 if (stat (mask, &file_stat) == -1)
14947 {
14948 log_error ("ERROR: %s: %s", mask, strerror (errno));
14949
14950 return (-1);
14951 }
14952 }
14953
14954 uint is_file = S_ISREG (file_stat.st_mode);
14955
14956 if (is_file == 1)
14957 {
14958 FILE *mask_fp;
14959
14960 if ((mask_fp = fopen (mask, "r")) == NULL)
14961 {
14962 log_error ("ERROR: %s: %s", mask, strerror (errno));
14963
14964 return (-1);
14965 }
14966
14967 char line_buf[BUFSIZ] = { 0 };
14968
14969 while (!feof (mask_fp))
14970 {
14971 memset (line_buf, 0, BUFSIZ);
14972
14973 int line_len = fgetl (mask_fp, line_buf);
14974
14975 if (line_len == 0) continue;
14976
14977 if (line_buf[0] == '#') continue;
14978
14979 if (masks_avail == maskcnt)
14980 {
14981 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14982
14983 masks_avail += INCR_MASKS;
14984 }
14985
14986 masks[maskcnt] = mystrdup (line_buf);
14987
14988 maskcnt++;
14989 }
14990
14991 fclose (mask_fp);
14992 }
14993 else
14994 {
14995 log_error ("ERROR: %s: unsupported file-type", mask);
14996
14997 return (-1);
14998 }
14999 }
15000
15001 mask_from_file = 1;
15002 }
15003 }
15004 else
15005 {
15006 custom_charset_1 = (char *) "?l?d?u";
15007 custom_charset_2 = (char *) "?l?d";
15008 custom_charset_3 = (char *) "?l?d*!$@_";
15009
15010 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15011 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15012 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15013
15014 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15015
15016 wordlist_mode = WL_MODE_MASK;
15017
15018 data.wordlist_mode = wordlist_mode;
15019
15020 increment = 1;
15021
15022 maskcnt = 1;
15023 }
15024 }
15025 else
15026 {
15027 /**
15028 * generate full masks and charsets
15029 */
15030
15031 masks = (char **) mymalloc (sizeof (char *));
15032
15033 switch (hash_mode)
15034 {
15035 case 1731: pw_min = 5;
15036 pw_max = 5;
15037 mask = mystrdup ("?b?b?b?b?b");
15038 break;
15039 case 12500: pw_min = 5;
15040 pw_max = 5;
15041 mask = mystrdup ("?b?b?b?b?b");
15042 break;
15043 default: pw_min = 7;
15044 pw_max = 7;
15045 mask = mystrdup ("?b?b?b?b?b?b?b");
15046 break;
15047 }
15048
15049 maskcnt = 1;
15050
15051 masks[maskcnt - 1] = mystrdup (mask);
15052
15053 wordlist_mode = WL_MODE_MASK;
15054
15055 data.wordlist_mode = wordlist_mode;
15056
15057 increment = 1;
15058 }
15059
15060 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15061
15062 if (increment)
15063 {
15064 if (increment_min > pw_min) pw_min = increment_min;
15065
15066 if (increment_max < pw_max) pw_max = increment_max;
15067 }
15068 }
15069 else if (attack_mode == ATTACK_MODE_HYBRID1)
15070 {
15071 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15072
15073 // display
15074
15075 char *mask = myargv[myargc - 1];
15076
15077 maskcnt = 0;
15078
15079 masks = (char **) mymalloc (1 * sizeof (char *));
15080
15081 // mod
15082
15083 struct stat file_stat;
15084
15085 if (stat (mask, &file_stat) == -1)
15086 {
15087 maskcnt = 1;
15088
15089 masks[maskcnt - 1] = mystrdup (mask);
15090 }
15091 else
15092 {
15093 uint is_file = S_ISREG (file_stat.st_mode);
15094
15095 if (is_file == 1)
15096 {
15097 FILE *mask_fp;
15098
15099 if ((mask_fp = fopen (mask, "r")) == NULL)
15100 {
15101 log_error ("ERROR: %s: %s", mask, strerror (errno));
15102
15103 return (-1);
15104 }
15105
15106 char line_buf[BUFSIZ] = { 0 };
15107
15108 uint masks_avail = 1;
15109
15110 while (!feof (mask_fp))
15111 {
15112 memset (line_buf, 0, BUFSIZ);
15113
15114 int line_len = fgetl (mask_fp, line_buf);
15115
15116 if (line_len == 0) continue;
15117
15118 if (line_buf[0] == '#') continue;
15119
15120 if (masks_avail == maskcnt)
15121 {
15122 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15123
15124 masks_avail += INCR_MASKS;
15125 }
15126
15127 masks[maskcnt] = mystrdup (line_buf);
15128
15129 maskcnt++;
15130 }
15131
15132 fclose (mask_fp);
15133
15134 mask_from_file = 1;
15135 }
15136 else
15137 {
15138 maskcnt = 1;
15139
15140 masks[maskcnt - 1] = mystrdup (mask);
15141 }
15142 }
15143
15144 // base
15145
15146 int wls_left = myargc - (optind + 2);
15147
15148 for (int i = 0; i < wls_left; i++)
15149 {
15150 char *filename = myargv[optind + 1 + i];
15151
15152 struct stat file_stat;
15153
15154 if (stat (filename, &file_stat) == -1)
15155 {
15156 log_error ("ERROR: %s: %s", filename, strerror (errno));
15157
15158 return (-1);
15159 }
15160
15161 uint is_dir = S_ISDIR (file_stat.st_mode);
15162
15163 if (is_dir == 0)
15164 {
15165 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15166
15167 dictcnt++;
15168
15169 dictfiles[dictcnt - 1] = filename;
15170 }
15171 else
15172 {
15173 // do not allow --keyspace w/ a directory
15174
15175 if (keyspace == 1)
15176 {
15177 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15178
15179 return (-1);
15180 }
15181
15182 char **dictionary_files = NULL;
15183
15184 dictionary_files = scan_directory (filename);
15185
15186 if (dictionary_files != NULL)
15187 {
15188 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15189
15190 for (int d = 0; dictionary_files[d] != NULL; d++)
15191 {
15192 char *l1_filename = dictionary_files[d];
15193
15194 struct stat l1_stat;
15195
15196 if (stat (l1_filename, &l1_stat) == -1)
15197 {
15198 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15199
15200 return (-1);
15201 }
15202
15203 if (S_ISREG (l1_stat.st_mode))
15204 {
15205 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15206
15207 dictcnt++;
15208
15209 dictfiles[dictcnt - 1] = strdup (l1_filename);
15210 }
15211 }
15212 }
15213
15214 local_free (dictionary_files);
15215 }
15216 }
15217
15218 if (dictcnt < 1)
15219 {
15220 log_error ("ERROR: No usable dictionary file found.");
15221
15222 return (-1);
15223 }
15224
15225 if (increment)
15226 {
15227 maskcnt = 0;
15228
15229 uint mask_min = increment_min; // we can't reject smaller masks here
15230 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15231
15232 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15233 {
15234 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15235
15236 if (cur_mask == NULL) break;
15237
15238 masks[maskcnt] = cur_mask;
15239
15240 maskcnt++;
15241
15242 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15243 }
15244 }
15245 }
15246 else if (attack_mode == ATTACK_MODE_HYBRID2)
15247 {
15248 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15249
15250 // display
15251
15252 char *mask = myargv[optind + 1 + 0];
15253
15254 maskcnt = 0;
15255
15256 masks = (char **) mymalloc (1 * sizeof (char *));
15257
15258 // mod
15259
15260 struct stat file_stat;
15261
15262 if (stat (mask, &file_stat) == -1)
15263 {
15264 maskcnt = 1;
15265
15266 masks[maskcnt - 1] = mystrdup (mask);
15267 }
15268 else
15269 {
15270 uint is_file = S_ISREG (file_stat.st_mode);
15271
15272 if (is_file == 1)
15273 {
15274 FILE *mask_fp;
15275
15276 if ((mask_fp = fopen (mask, "r")) == NULL)
15277 {
15278 log_error ("ERROR: %s: %s", mask, strerror (errno));
15279
15280 return (-1);
15281 }
15282
15283 char line_buf[BUFSIZ] = { 0 };
15284
15285 uint masks_avail = 1;
15286
15287 while (!feof (mask_fp))
15288 {
15289 memset (line_buf, 0, BUFSIZ);
15290
15291 int line_len = fgetl (mask_fp, line_buf);
15292
15293 if (line_len == 0) continue;
15294
15295 if (line_buf[0] == '#') continue;
15296
15297 if (masks_avail == maskcnt)
15298 {
15299 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15300
15301 masks_avail += INCR_MASKS;
15302 }
15303
15304 masks[maskcnt] = mystrdup (line_buf);
15305
15306 maskcnt++;
15307 }
15308
15309 fclose (mask_fp);
15310
15311 mask_from_file = 1;
15312 }
15313 else
15314 {
15315 maskcnt = 1;
15316
15317 masks[maskcnt - 1] = mystrdup (mask);
15318 }
15319 }
15320
15321 // base
15322
15323 int wls_left = myargc - (optind + 2);
15324
15325 for (int i = 0; i < wls_left; i++)
15326 {
15327 char *filename = myargv[optind + 2 + i];
15328
15329 struct stat file_stat;
15330
15331 if (stat (filename, &file_stat) == -1)
15332 {
15333 log_error ("ERROR: %s: %s", filename, strerror (errno));
15334
15335 return (-1);
15336 }
15337
15338 uint is_dir = S_ISDIR (file_stat.st_mode);
15339
15340 if (is_dir == 0)
15341 {
15342 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15343
15344 dictcnt++;
15345
15346 dictfiles[dictcnt - 1] = filename;
15347 }
15348 else
15349 {
15350 // do not allow --keyspace w/ a directory
15351
15352 if (keyspace == 1)
15353 {
15354 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15355
15356 return (-1);
15357 }
15358
15359 char **dictionary_files = NULL;
15360
15361 dictionary_files = scan_directory (filename);
15362
15363 if (dictionary_files != NULL)
15364 {
15365 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15366
15367 for (int d = 0; dictionary_files[d] != NULL; d++)
15368 {
15369 char *l1_filename = dictionary_files[d];
15370
15371 struct stat l1_stat;
15372
15373 if (stat (l1_filename, &l1_stat) == -1)
15374 {
15375 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15376
15377 return (-1);
15378 }
15379
15380 if (S_ISREG (l1_stat.st_mode))
15381 {
15382 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15383
15384 dictcnt++;
15385
15386 dictfiles[dictcnt - 1] = strdup (l1_filename);
15387 }
15388 }
15389 }
15390
15391 local_free (dictionary_files);
15392 }
15393 }
15394
15395 if (dictcnt < 1)
15396 {
15397 log_error ("ERROR: No usable dictionary file found.");
15398
15399 return (-1);
15400 }
15401
15402 if (increment)
15403 {
15404 maskcnt = 0;
15405
15406 uint mask_min = increment_min; // we can't reject smaller masks here
15407 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15408
15409 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15410 {
15411 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15412
15413 if (cur_mask == NULL) break;
15414
15415 masks[maskcnt] = cur_mask;
15416
15417 maskcnt++;
15418
15419 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15420 }
15421 }
15422 }
15423
15424 data.pw_min = pw_min;
15425 data.pw_max = pw_max;
15426
15427 /**
15428 * weak hash check
15429 */
15430
15431 if (weak_hash_threshold >= salts_cnt)
15432 {
15433 hc_device_param_t *device_param = NULL;
15434
15435 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15436 {
15437 device_param = &data.devices_param[device_id];
15438
15439 if (device_param->skipped) continue;
15440
15441 break;
15442 }
15443
15444 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15445
15446 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15447 {
15448 weak_hash_check (device_param, salt_pos);
15449 }
15450 }
15451
15452 // Display hack, guarantee that there is at least one \r before real start
15453
15454 if (data.quiet == 0) log_info_nn ("");
15455
15456 /**
15457 * status and monitor threads
15458 */
15459
15460 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15461
15462 hc_thread_t i_thread = 0;
15463
15464 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15465 {
15466 hc_thread_create (i_thread, thread_keypress, &benchmark);
15467 }
15468
15469 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15470
15471 uint ni_threads_cnt = 0;
15472
15473 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15474
15475 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15476
15477 ni_threads_cnt++;
15478
15479 /**
15480 * Outfile remove
15481 */
15482
15483 if (keyspace == 0)
15484 {
15485 if (outfile_check_timer != 0)
15486 {
15487 if (data.outfile_check_directory != NULL)
15488 {
15489 if ((hash_mode != 5200) &&
15490 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15491 (hash_mode != 9000))
15492 {
15493 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15494
15495 ni_threads_cnt++;
15496 }
15497 else
15498 {
15499 outfile_check_timer = 0;
15500 }
15501 }
15502 else
15503 {
15504 outfile_check_timer = 0;
15505 }
15506 }
15507 }
15508
15509 /**
15510 * Inform the user if we got some hashes remove because of the pot file remove feature
15511 */
15512
15513 if (data.quiet == 0)
15514 {
15515 if (potfile_remove_cracks > 0)
15516 {
15517 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15518 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15519 }
15520 }
15521
15522 data.outfile_check_timer = outfile_check_timer;
15523
15524 /**
15525 * main loop
15526 */
15527
15528 char **induction_dictionaries = NULL;
15529
15530 int induction_dictionaries_cnt = 0;
15531
15532 hcstat_table_t *root_table_buf = NULL;
15533 hcstat_table_t *markov_table_buf = NULL;
15534
15535 uint initial_restore_done = 0;
15536
15537 data.maskcnt = maskcnt;
15538
15539 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15540 {
15541 if (data.devices_status == STATUS_CRACKED) break;
15542
15543 data.devices_status = STATUS_INIT;
15544
15545 if (maskpos > rd->maskpos)
15546 {
15547 rd->dictpos = 0;
15548 }
15549
15550 rd->maskpos = maskpos;
15551 data.maskpos = maskpos;
15552
15553 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15554 {
15555 char *mask = masks[maskpos];
15556
15557 if (mask_from_file == 1)
15558 {
15559 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15560
15561 char *str_ptr;
15562 uint str_pos;
15563
15564 uint mask_offset = 0;
15565
15566 uint separator_cnt;
15567
15568 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15569 {
15570 str_ptr = strstr (mask + mask_offset, ",");
15571
15572 if (str_ptr == NULL) break;
15573
15574 str_pos = str_ptr - mask;
15575
15576 // escaped separator, i.e. "\,"
15577
15578 if (str_pos > 0)
15579 {
15580 if (mask[str_pos - 1] == '\\')
15581 {
15582 separator_cnt --;
15583
15584 mask_offset = str_pos + 1;
15585
15586 continue;
15587 }
15588 }
15589
15590 // reset the offset
15591
15592 mask_offset = 0;
15593
15594 mask[str_pos] = '\0';
15595
15596 switch (separator_cnt)
15597 {
15598 case 0:
15599 mp_reset_usr (mp_usr, 0);
15600
15601 custom_charset_1 = mask;
15602 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15603 break;
15604
15605 case 1:
15606 mp_reset_usr (mp_usr, 1);
15607
15608 custom_charset_2 = mask;
15609 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15610 break;
15611
15612 case 2:
15613 mp_reset_usr (mp_usr, 2);
15614
15615 custom_charset_3 = mask;
15616 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15617 break;
15618
15619 case 3:
15620 mp_reset_usr (mp_usr, 3);
15621
15622 custom_charset_4 = mask;
15623 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15624 break;
15625 }
15626
15627 mask = mask + str_pos + 1;
15628 }
15629 }
15630
15631 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15632 {
15633 if (maskpos > 0)
15634 {
15635 local_free (css_buf);
15636 local_free (data.root_css_buf);
15637 local_free (data.markov_css_buf);
15638
15639 local_free (masks[maskpos - 1]);
15640 }
15641
15642 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15643
15644 data.mask = mask;
15645 data.css_cnt = css_cnt;
15646 data.css_buf = css_buf;
15647
15648 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15649
15650 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15651
15652 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15653 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15654
15655 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15656
15657 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15658
15659 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15660 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15661
15662 data.root_css_buf = root_css_buf;
15663 data.markov_css_buf = markov_css_buf;
15664
15665 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15666
15667 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15668
15669 local_free (root_table_buf);
15670 local_free (markov_table_buf);
15671
15672 // args
15673
15674 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15675 {
15676 hc_device_param_t *device_param = &data.devices_param[device_id];
15677
15678 if (device_param->skipped) continue;
15679
15680 device_param->kernel_params_mp[0] = &device_param->d_combs;
15681 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15682 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15683
15684 device_param->kernel_params_mp_buf64[3] = 0;
15685 device_param->kernel_params_mp_buf32[4] = css_cnt;
15686 device_param->kernel_params_mp_buf32[5] = 0;
15687 device_param->kernel_params_mp_buf32[6] = 0;
15688 device_param->kernel_params_mp_buf32[7] = 0;
15689
15690 if (attack_mode == ATTACK_MODE_HYBRID1)
15691 {
15692 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15693 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15694 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15695 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15696 }
15697 else if (attack_mode == ATTACK_MODE_HYBRID2)
15698 {
15699 device_param->kernel_params_mp_buf32[5] = 0;
15700 device_param->kernel_params_mp_buf32[6] = 0;
15701 device_param->kernel_params_mp_buf32[7] = 0;
15702 }
15703
15704 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]);
15705 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]);
15706 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]);
15707
15708 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);
15709 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);
15710 }
15711 }
15712 else if (attack_mode == ATTACK_MODE_BF)
15713 {
15714 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15715
15716 if (increment)
15717 {
15718 for (uint i = 0; i < dictcnt; i++)
15719 {
15720 local_free (dictfiles[i]);
15721 }
15722
15723 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15724 {
15725 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15726
15727 if (l1_filename == NULL) break;
15728
15729 dictcnt++;
15730
15731 dictfiles[dictcnt - 1] = l1_filename;
15732 }
15733 }
15734 else
15735 {
15736 dictcnt++;
15737
15738 dictfiles[dictcnt - 1] = mask;
15739 }
15740
15741 if (dictcnt == 0)
15742 {
15743 log_error ("ERROR: Mask is too small");
15744
15745 return (-1);
15746 }
15747 }
15748 }
15749
15750 free (induction_dictionaries);
15751
15752 // induction_dictionaries_cnt = 0; // implied
15753
15754 if (attack_mode != ATTACK_MODE_BF)
15755 {
15756 if (keyspace == 0)
15757 {
15758 induction_dictionaries = scan_directory (induction_directory);
15759
15760 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15761 }
15762 }
15763
15764 if (induction_dictionaries_cnt)
15765 {
15766 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15767 }
15768
15769 /**
15770 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15771 */
15772 if (keyspace == 1)
15773 {
15774 if ((maskcnt > 1) || (dictcnt > 1))
15775 {
15776 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15777
15778 return (-1);
15779 }
15780 }
15781
15782 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15783 {
15784 char *subid = logfile_generate_subid ();
15785
15786 data.subid = subid;
15787
15788 logfile_sub_msg ("START");
15789
15790 data.devices_status = STATUS_INIT;
15791
15792 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15793 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15794 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15795
15796 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15797
15798 data.cpt_pos = 0;
15799
15800 data.cpt_start = time (NULL);
15801
15802 data.cpt_total = 0;
15803
15804 if (data.restore == 0)
15805 {
15806 rd->words_cur = skip;
15807
15808 skip = 0;
15809
15810 data.skip = 0;
15811 }
15812
15813 data.ms_paused = 0;
15814
15815 data.words_cur = rd->words_cur;
15816
15817 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15818 {
15819 hc_device_param_t *device_param = &data.devices_param[device_id];
15820
15821 if (device_param->skipped) continue;
15822
15823 device_param->speed_pos = 0;
15824
15825 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15826 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15827 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15828
15829 device_param->exec_pos = 0;
15830
15831 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
15832
15833 device_param->kernel_power = device_param->kernel_power_user;
15834
15835 device_param->outerloop_pos = 0;
15836 device_param->outerloop_left = 0;
15837 device_param->innerloop_pos = 0;
15838 device_param->innerloop_left = 0;
15839
15840 // some more resets:
15841
15842 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
15843
15844 device_param->pws_cnt = 0;
15845
15846 device_param->words_off = 0;
15847 device_param->words_done = 0;
15848 }
15849
15850 data.kernel_power_div = 0;
15851
15852 // figure out some workload
15853
15854 if (attack_mode == ATTACK_MODE_STRAIGHT)
15855 {
15856 if (data.wordlist_mode == WL_MODE_FILE)
15857 {
15858 char *dictfile = NULL;
15859
15860 if (induction_dictionaries_cnt)
15861 {
15862 dictfile = induction_dictionaries[0];
15863 }
15864 else
15865 {
15866 dictfile = dictfiles[dictpos];
15867 }
15868
15869 data.dictfile = dictfile;
15870
15871 logfile_sub_string (dictfile);
15872
15873 for (uint i = 0; i < rp_files_cnt; i++)
15874 {
15875 logfile_sub_var_string ("rulefile", rp_files[i]);
15876 }
15877
15878 FILE *fd2 = fopen (dictfile, "rb");
15879
15880 if (fd2 == NULL)
15881 {
15882 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15883
15884 return (-1);
15885 }
15886
15887 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15888
15889 fclose (fd2);
15890
15891 if (data.words_cnt == 0)
15892 {
15893 if (data.devices_status == STATUS_CRACKED) break;
15894 if (data.devices_status == STATUS_ABORTED) break;
15895
15896 dictpos++;
15897
15898 continue;
15899 }
15900 }
15901 }
15902 else if (attack_mode == ATTACK_MODE_COMBI)
15903 {
15904 char *dictfile = data.dictfile;
15905 char *dictfile2 = data.dictfile2;
15906
15907 logfile_sub_string (dictfile);
15908 logfile_sub_string (dictfile2);
15909
15910 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15911 {
15912 FILE *fd2 = fopen (dictfile, "rb");
15913
15914 if (fd2 == NULL)
15915 {
15916 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15917
15918 return (-1);
15919 }
15920
15921 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15922
15923 fclose (fd2);
15924 }
15925 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15926 {
15927 FILE *fd2 = fopen (dictfile2, "rb");
15928
15929 if (fd2 == NULL)
15930 {
15931 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15932
15933 return (-1);
15934 }
15935
15936 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15937
15938 fclose (fd2);
15939 }
15940
15941 if (data.words_cnt == 0)
15942 {
15943 if (data.devices_status == STATUS_CRACKED) break;
15944 if (data.devices_status == STATUS_ABORTED) break;
15945
15946 dictpos++;
15947
15948 continue;
15949 }
15950 }
15951 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15952 {
15953 char *dictfile = NULL;
15954
15955 if (induction_dictionaries_cnt)
15956 {
15957 dictfile = induction_dictionaries[0];
15958 }
15959 else
15960 {
15961 dictfile = dictfiles[dictpos];
15962 }
15963
15964 data.dictfile = dictfile;
15965
15966 char *mask = data.mask;
15967
15968 logfile_sub_string (dictfile);
15969 logfile_sub_string (mask);
15970
15971 FILE *fd2 = fopen (dictfile, "rb");
15972
15973 if (fd2 == NULL)
15974 {
15975 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15976
15977 return (-1);
15978 }
15979
15980 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15981
15982 fclose (fd2);
15983
15984 if (data.words_cnt == 0)
15985 {
15986 if (data.devices_status == STATUS_CRACKED) break;
15987 if (data.devices_status == STATUS_ABORTED) break;
15988
15989 dictpos++;
15990
15991 continue;
15992 }
15993 }
15994 else if (attack_mode == ATTACK_MODE_BF)
15995 {
15996 local_free (css_buf);
15997 local_free (data.root_css_buf);
15998 local_free (data.markov_css_buf);
15999
16000 char *mask = dictfiles[dictpos];
16001
16002 logfile_sub_string (mask);
16003
16004 // base
16005
16006 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16007
16008 if (opts_type & OPTS_TYPE_PT_UNICODE)
16009 {
16010 uint css_cnt_unicode = css_cnt * 2;
16011
16012 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16013
16014 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16015 {
16016 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16017
16018 css_buf_unicode[j + 1].cs_buf[0] = 0;
16019 css_buf_unicode[j + 1].cs_len = 1;
16020 }
16021
16022 free (css_buf);
16023
16024 css_buf = css_buf_unicode;
16025 css_cnt = css_cnt_unicode;
16026 }
16027
16028 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16029
16030 uint mask_min = pw_min;
16031 uint mask_max = pw_max;
16032
16033 if (opts_type & OPTS_TYPE_PT_UNICODE)
16034 {
16035 mask_min *= 2;
16036 mask_max *= 2;
16037 }
16038
16039 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16040 {
16041 if (css_cnt < mask_min)
16042 {
16043 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16044 }
16045
16046 if (css_cnt > mask_max)
16047 {
16048 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16049 }
16050
16051 // skip to next mask
16052
16053 dictpos++;
16054
16055 rd->dictpos = dictpos;
16056
16057 logfile_sub_msg ("STOP");
16058
16059 continue;
16060 }
16061
16062 uint save_css_cnt = css_cnt;
16063
16064 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16065 {
16066 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16067 {
16068 uint salt_len = (uint) data.salts_buf[0].salt_len;
16069 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16070
16071 uint css_cnt_salt = css_cnt + salt_len;
16072
16073 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16074
16075 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16076
16077 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16078 {
16079 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16080 css_buf_salt[j].cs_len = 1;
16081 }
16082
16083 free (css_buf);
16084
16085 css_buf = css_buf_salt;
16086 css_cnt = css_cnt_salt;
16087 }
16088 }
16089
16090 data.mask = mask;
16091 data.css_cnt = css_cnt;
16092 data.css_buf = css_buf;
16093
16094 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16095
16096 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16097
16098 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16099
16100 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16101 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16102
16103 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16104
16105 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16106
16107 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16108 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16109
16110 data.root_css_buf = root_css_buf;
16111 data.markov_css_buf = markov_css_buf;
16112
16113 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16114
16115 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16116
16117 local_free (root_table_buf);
16118 local_free (markov_table_buf);
16119
16120 // copy + args
16121
16122 uint css_cnt_l = css_cnt;
16123 uint css_cnt_r;
16124
16125 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16126 {
16127 if (save_css_cnt < 6)
16128 {
16129 css_cnt_r = 1;
16130 }
16131 else if (save_css_cnt == 6)
16132 {
16133 css_cnt_r = 2;
16134 }
16135 else
16136 {
16137 if (opts_type & OPTS_TYPE_PT_UNICODE)
16138 {
16139 if (save_css_cnt == 8 || save_css_cnt == 10)
16140 {
16141 css_cnt_r = 2;
16142 }
16143 else
16144 {
16145 css_cnt_r = 4;
16146 }
16147 }
16148 else
16149 {
16150 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16151 {
16152 css_cnt_r = 3;
16153 }
16154 else
16155 {
16156 css_cnt_r = 4;
16157 }
16158 }
16159 }
16160 }
16161 else
16162 {
16163 css_cnt_r = 1;
16164
16165 /* unfinished code?
16166 int sum = css_buf[css_cnt_r - 1].cs_len;
16167
16168 for (uint i = 1; i < 4 && i < css_cnt; i++)
16169 {
16170 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16171
16172 css_cnt_r++;
16173
16174 sum *= css_buf[css_cnt_r - 1].cs_len;
16175 }
16176 */
16177 }
16178
16179 css_cnt_l -= css_cnt_r;
16180
16181 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16182
16183 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16184 {
16185 hc_device_param_t *device_param = &data.devices_param[device_id];
16186
16187 if (device_param->skipped) continue;
16188
16189 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16190 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16191 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16192
16193 device_param->kernel_params_mp_l_buf64[3] = 0;
16194 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16195 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16196 device_param->kernel_params_mp_l_buf32[6] = 0;
16197 device_param->kernel_params_mp_l_buf32[7] = 0;
16198 device_param->kernel_params_mp_l_buf32[8] = 0;
16199
16200 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16201 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16202 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16203 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16204
16205 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16206 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16207 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16208
16209 device_param->kernel_params_mp_r_buf64[3] = 0;
16210 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16211 device_param->kernel_params_mp_r_buf32[5] = 0;
16212 device_param->kernel_params_mp_r_buf32[6] = 0;
16213 device_param->kernel_params_mp_r_buf32[7] = 0;
16214
16215 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]);
16216 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]);
16217 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]);
16218
16219 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]);
16220 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]);
16221 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]);
16222
16223 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);
16224 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);
16225 }
16226 }
16227
16228 u64 words_base = data.words_cnt;
16229
16230 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16231 {
16232 if (data.kernel_rules_cnt)
16233 {
16234 words_base /= data.kernel_rules_cnt;
16235 }
16236 }
16237 else if (data.attack_kern == ATTACK_KERN_COMBI)
16238 {
16239 if (data.combs_cnt)
16240 {
16241 words_base /= data.combs_cnt;
16242 }
16243 }
16244 else if (data.attack_kern == ATTACK_KERN_BF)
16245 {
16246 if (data.bfs_cnt)
16247 {
16248 words_base /= data.bfs_cnt;
16249 }
16250 }
16251
16252 data.words_base = words_base;
16253
16254 if (keyspace == 1)
16255 {
16256 log_info ("%llu", (unsigned long long int) words_base);
16257
16258 return (0);
16259 }
16260
16261 if (data.words_cur > data.words_base)
16262 {
16263 log_error ("ERROR: restore value greater keyspace");
16264
16265 return (-1);
16266 }
16267
16268 if (data.words_cur)
16269 {
16270 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16271 {
16272 for (uint i = 0; i < data.salts_cnt; i++)
16273 {
16274 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16275 }
16276 }
16277 else if (data.attack_kern == ATTACK_KERN_COMBI)
16278 {
16279 for (uint i = 0; i < data.salts_cnt; i++)
16280 {
16281 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16282 }
16283 }
16284 else if (data.attack_kern == ATTACK_KERN_BF)
16285 {
16286 for (uint i = 0; i < data.salts_cnt; i++)
16287 {
16288 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16289 }
16290 }
16291 }
16292
16293 /*
16294 * Inform user about possible slow speeds
16295 */
16296
16297 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16298 {
16299 if (data.words_base < kernel_power_all)
16300 {
16301 if (quiet == 0)
16302 {
16303 log_info ("");
16304 log_info ("ATTENTION!");
16305 log_info (" The wordlist or mask you are using is too small.");
16306 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16307 log_info (" The cracking speed will drop.");
16308 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16309 log_info ("");
16310 }
16311 }
16312 }
16313
16314 /*
16315 * Update loopback file
16316 */
16317
16318 if (loopback == 1)
16319 {
16320 time_t now;
16321
16322 time (&now);
16323
16324 uint random_num = get_random_num (0, 9999);
16325
16326 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16327
16328 data.loopback_file = loopback_file;
16329 }
16330
16331 /*
16332 * Update dictionary statistic
16333 */
16334
16335 if (keyspace == 0)
16336 {
16337 dictstat_fp = fopen (dictstat, "wb");
16338
16339 if (dictstat_fp)
16340 {
16341 lock_file (dictstat_fp);
16342
16343 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16344
16345 fclose (dictstat_fp);
16346 }
16347 }
16348
16349 data.devices_status = STATUS_RUNNING;
16350
16351 if (initial_restore_done == 0)
16352 {
16353 if (data.restore_disable == 0) cycle_restore ();
16354
16355 initial_restore_done = 1;
16356 }
16357
16358 hc_timer_set (&data.timer_running);
16359
16360 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16361 {
16362 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16363 {
16364 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16365 if (quiet == 0) fflush (stdout);
16366 }
16367 }
16368 else if (wordlist_mode == WL_MODE_STDIN)
16369 {
16370 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16371 if (data.quiet == 0) log_info ("");
16372 }
16373
16374 time_t runtime_start;
16375
16376 time (&runtime_start);
16377
16378 data.runtime_start = runtime_start;
16379
16380 /**
16381 * create cracker threads
16382 */
16383
16384 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16385
16386 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16387 {
16388 hc_device_param_t *device_param = &devices_param[device_id];
16389
16390 if (wordlist_mode == WL_MODE_STDIN)
16391 {
16392 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16393 }
16394 else
16395 {
16396 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16397 }
16398 }
16399
16400 // wait for crack threads to exit
16401
16402 hc_thread_wait (data.devices_cnt, c_threads);
16403
16404 local_free (c_threads);
16405
16406 data.restore = 0;
16407
16408 // finalize task
16409
16410 logfile_sub_var_uint ("status-after-work", data.devices_status);
16411
16412 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16413
16414 if (data.devices_status == STATUS_CRACKED) break;
16415 if (data.devices_status == STATUS_ABORTED) break;
16416
16417 if (data.devices_status == STATUS_BYPASS)
16418 {
16419 data.devices_status = STATUS_RUNNING;
16420 }
16421
16422 if (induction_dictionaries_cnt)
16423 {
16424 unlink (induction_dictionaries[0]);
16425 }
16426
16427 free (induction_dictionaries);
16428
16429 if (attack_mode != ATTACK_MODE_BF)
16430 {
16431 induction_dictionaries = scan_directory (induction_directory);
16432
16433 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16434 }
16435
16436 if (benchmark == 0)
16437 {
16438 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16439 {
16440 if (quiet == 0) clear_prompt ();
16441
16442 if (quiet == 0) log_info ("");
16443
16444 if (status == 1)
16445 {
16446 status_display ();
16447 }
16448 else
16449 {
16450 if (quiet == 0) status_display ();
16451 }
16452
16453 if (quiet == 0) log_info ("");
16454 }
16455 }
16456
16457 if (attack_mode == ATTACK_MODE_BF)
16458 {
16459 dictpos++;
16460
16461 rd->dictpos = dictpos;
16462 }
16463 else
16464 {
16465 if (induction_dictionaries_cnt)
16466 {
16467 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16468 }
16469 else
16470 {
16471 dictpos++;
16472
16473 rd->dictpos = dictpos;
16474 }
16475 }
16476
16477 time_t runtime_stop;
16478
16479 time (&runtime_stop);
16480
16481 data.runtime_stop = runtime_stop;
16482
16483 logfile_sub_uint (runtime_start);
16484 logfile_sub_uint (runtime_stop);
16485
16486 logfile_sub_msg ("STOP");
16487
16488 global_free (subid);
16489 }
16490
16491 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16492
16493 if (data.devices_status == STATUS_CRACKED) break;
16494 if (data.devices_status == STATUS_ABORTED) break;
16495 if (data.devices_status == STATUS_QUIT) break;
16496
16497 if (data.devices_status == STATUS_BYPASS)
16498 {
16499 data.devices_status = STATUS_RUNNING;
16500 }
16501 }
16502
16503 // 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
16504
16505 if (attack_mode == ATTACK_MODE_STRAIGHT)
16506 {
16507 if (data.wordlist_mode == WL_MODE_FILE)
16508 {
16509 if (data.dictfile == NULL)
16510 {
16511 if (dictfiles != NULL)
16512 {
16513 data.dictfile = dictfiles[0];
16514
16515 hc_timer_set (&data.timer_running);
16516 }
16517 }
16518 }
16519 }
16520 // NOTE: combi is okay because it is already set beforehand
16521 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16522 {
16523 if (data.dictfile == NULL)
16524 {
16525 if (dictfiles != NULL)
16526 {
16527 hc_timer_set (&data.timer_running);
16528
16529 data.dictfile = dictfiles[0];
16530 }
16531 }
16532 }
16533 else if (attack_mode == ATTACK_MODE_BF)
16534 {
16535 if (data.mask == NULL)
16536 {
16537 hc_timer_set (&data.timer_running);
16538
16539 data.mask = masks[0];
16540 }
16541 }
16542
16543 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16544 {
16545 data.devices_status = STATUS_EXHAUSTED;
16546 }
16547
16548 // if cracked / aborted remove last induction dictionary
16549
16550 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16551 {
16552 struct stat induct_stat;
16553
16554 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16555 {
16556 unlink (induction_dictionaries[file_pos]);
16557 }
16558 }
16559
16560 // wait for non-interactive threads
16561
16562 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16563 {
16564 hc_thread_wait (1, &ni_threads[thread_idx]);
16565 }
16566
16567 local_free (ni_threads);
16568
16569 // wait for interactive threads
16570
16571 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16572 {
16573 hc_thread_wait (1, &i_thread);
16574 }
16575
16576 // we dont need restore file anymore
16577 if (data.restore_disable == 0)
16578 {
16579 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16580 {
16581 unlink (eff_restore_file);
16582 unlink (new_restore_file);
16583 }
16584 else
16585 {
16586 cycle_restore ();
16587 }
16588 }
16589
16590 // finally save left hashes
16591
16592 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16593 {
16594 save_hash ();
16595 }
16596
16597 /**
16598 * Clean up
16599 */
16600
16601 if (benchmark == 1)
16602 {
16603 status_benchmark ();
16604
16605 log_info ("");
16606 }
16607 else
16608 {
16609 if (quiet == 0) clear_prompt ();
16610
16611 if (quiet == 0) log_info ("");
16612
16613 if (status == 1)
16614 {
16615 status_display ();
16616 }
16617 else
16618 {
16619 if (quiet == 0) status_display ();
16620 }
16621
16622 if (quiet == 0) log_info ("");
16623 }
16624
16625 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16626 {
16627 hc_device_param_t *device_param = &data.devices_param[device_id];
16628
16629 if (device_param->skipped) continue;
16630
16631 local_free (device_param->result);
16632
16633 local_free (device_param->combs_buf);
16634
16635 local_free (device_param->hooks_buf);
16636
16637 local_free (device_param->device_name);
16638
16639 local_free (device_param->device_name_chksum);
16640
16641 local_free (device_param->device_version);
16642
16643 local_free (device_param->driver_version);
16644
16645 if (device_param->pws_buf) myfree (device_param->pws_buf);
16646 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16647 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16648 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16649 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16650 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16651 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16652 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16653 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16654 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16655 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16656 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16657 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16658 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16659 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16660 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16661 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16662 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16663 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16664 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16665 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16666 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16667 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16668 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16669 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16670 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16671 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16672 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16673 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16674
16675 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16676 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16677 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16678 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16679 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16680 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16681 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16682 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16683 if (device_param->kernel_tb) hc_clReleaseKernel (data.ocl, device_param->kernel_tb);
16684 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16685 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16686
16687 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16688 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16689 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16690
16691 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16692 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16693 }
16694
16695 // reset default fan speed
16696
16697 #ifdef HAVE_HWMON
16698 if (gpu_temp_disable == 0)
16699 {
16700 #ifdef HAVE_ADL
16701 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16702 {
16703 hc_thread_mutex_lock (mux_adl);
16704
16705 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16706 {
16707 hc_device_param_t *device_param = &data.devices_param[device_id];
16708
16709 if (device_param->skipped) continue;
16710
16711 if (data.hm_device[device_id].fan_supported == 1)
16712 {
16713 int fanspeed = temp_retain_fanspeed_value[device_id];
16714
16715 if (fanspeed == -1) continue;
16716
16717 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16718
16719 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16720 }
16721 }
16722
16723 hc_thread_mutex_unlock (mux_adl);
16724 }
16725 #endif // HAVE_ADL
16726 }
16727
16728 #ifdef HAVE_ADL
16729 // reset power tuning
16730
16731 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16732 {
16733 hc_thread_mutex_lock (mux_adl);
16734
16735 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16736 {
16737 hc_device_param_t *device_param = &data.devices_param[device_id];
16738
16739 if (device_param->skipped) continue;
16740
16741 if (data.hm_device[device_id].od_version == 6)
16742 {
16743 // check powertune capabilities first, if not available then skip device
16744
16745 int powertune_supported = 0;
16746
16747 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16748 {
16749 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16750
16751 return (-1);
16752 }
16753
16754 if (powertune_supported != 0)
16755 {
16756 // powercontrol settings
16757
16758 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)
16759 {
16760 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16761
16762 return (-1);
16763 }
16764
16765 // clocks
16766
16767 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16768
16769 performance_state->iNumberOfPerformanceLevels = 2;
16770
16771 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16772 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16773 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16774 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16775
16776 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)
16777 {
16778 log_info ("ERROR: Failed to restore ADL performance state");
16779
16780 return (-1);
16781 }
16782
16783 local_free (performance_state);
16784 }
16785 }
16786 }
16787
16788 hc_thread_mutex_unlock (mux_adl);
16789 }
16790 #endif // HAVE_ADL
16791
16792 if (gpu_temp_disable == 0)
16793 {
16794 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
16795 if (data.hm_nv)
16796 {
16797 #if defined(LINUX) && defined(HAVE_NVML)
16798
16799 hm_NVML_nvmlShutdown (data.hm_nv);
16800
16801 nvml_close (data.hm_nv);
16802
16803 #elif defined(WIN) && (HAVE_NVAPI)
16804
16805 hm_NvAPI_Unload (data.hm_nv);
16806
16807 nvapi_close (data.hm_nv);
16808
16809 #endif
16810
16811 data.hm_nv = NULL;
16812 }
16813 #endif
16814
16815 #ifdef HAVE_ADL
16816 if (data.hm_amd)
16817 {
16818 hm_ADL_Main_Control_Destroy (data.hm_amd);
16819
16820 adl_close (data.hm_amd);
16821 data.hm_amd = NULL;
16822 }
16823 #endif
16824 }
16825 #endif // HAVE_HWMON
16826
16827 // free memory
16828
16829 local_free (masks);
16830
16831 local_free (dictstat_base);
16832
16833 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16834 {
16835 pot_t *pot_ptr = &pot[pot_pos];
16836
16837 hash_t *hash = &pot_ptr->hash;
16838
16839 local_free (hash->digest);
16840
16841 if (isSalted)
16842 {
16843 local_free (hash->salt);
16844 }
16845 }
16846
16847 local_free (pot);
16848
16849 local_free (all_kernel_rules_cnt);
16850 local_free (all_kernel_rules_buf);
16851
16852 local_free (wl_data->buf);
16853 local_free (wl_data);
16854
16855 local_free (bitmap_s1_a);
16856 local_free (bitmap_s1_b);
16857 local_free (bitmap_s1_c);
16858 local_free (bitmap_s1_d);
16859 local_free (bitmap_s2_a);
16860 local_free (bitmap_s2_b);
16861 local_free (bitmap_s2_c);
16862 local_free (bitmap_s2_d);
16863
16864 #ifdef HAVE_HWMON
16865 local_free (temp_retain_fanspeed_value);
16866 #ifdef HAVE_ADL
16867 local_free (od_clock_mem_status);
16868 local_free (od_power_control_status);
16869 #endif // ADL
16870 #endif
16871
16872 global_free (devices_param);
16873
16874 global_free (kernel_rules_buf);
16875
16876 global_free (root_css_buf);
16877 global_free (markov_css_buf);
16878
16879 global_free (digests_buf);
16880 global_free (digests_shown);
16881 global_free (digests_shown_tmp);
16882
16883 global_free (salts_buf);
16884 global_free (salts_shown);
16885
16886 global_free (esalts_buf);
16887
16888 global_free (words_progress_done);
16889 global_free (words_progress_rejected);
16890 global_free (words_progress_restored);
16891
16892 if (pot_fp) fclose (pot_fp);
16893
16894 if (data.devices_status == STATUS_QUIT) break;
16895 }
16896
16897 // destroy others mutex
16898
16899 hc_thread_mutex_delete (mux_dispatcher);
16900 hc_thread_mutex_delete (mux_counter);
16901 hc_thread_mutex_delete (mux_display);
16902 hc_thread_mutex_delete (mux_adl);
16903
16904 // free memory
16905
16906 local_free (eff_restore_file);
16907 local_free (new_restore_file);
16908
16909 local_free (rd);
16910
16911 // tuning db
16912
16913 tuning_db_destroy (tuning_db);
16914
16915 // loopback
16916
16917 local_free (loopback_file);
16918
16919 if (loopback == 1) unlink (loopback_file);
16920
16921 // induction directory
16922
16923 if (induction_dir == NULL)
16924 {
16925 if (attack_mode != ATTACK_MODE_BF)
16926 {
16927 if (rmdir (induction_directory) == -1)
16928 {
16929 if (errno == ENOENT)
16930 {
16931 // good, we can ignore
16932 }
16933 else if (errno == ENOTEMPTY)
16934 {
16935 // good, we can ignore
16936 }
16937 else
16938 {
16939 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16940
16941 return (-1);
16942 }
16943 }
16944
16945 local_free (induction_directory);
16946 }
16947 }
16948
16949 // outfile-check directory
16950
16951 if (outfile_check_dir == NULL)
16952 {
16953 if (rmdir (outfile_check_directory) == -1)
16954 {
16955 if (errno == ENOENT)
16956 {
16957 // good, we can ignore
16958 }
16959 else if (errno == ENOTEMPTY)
16960 {
16961 // good, we can ignore
16962 }
16963 else
16964 {
16965 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16966
16967 return (-1);
16968 }
16969 }
16970
16971 local_free (outfile_check_directory);
16972 }
16973
16974 time_t proc_stop;
16975
16976 time (&proc_stop);
16977
16978 logfile_top_uint (proc_start);
16979 logfile_top_uint (proc_stop);
16980
16981 logfile_top_msg ("STOP");
16982
16983 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16984 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16985
16986 if (data.ocl) ocl_close (data.ocl);
16987
16988 if (data.devices_status == STATUS_ABORTED) return 2;
16989 if (data.devices_status == STATUS_QUIT) return 2;
16990 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16991 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16992 if (data.devices_status == STATUS_CRACKED) return 0;
16993
16994 return -1;
16995 }
Hashcat additions to support pwdhash