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