projects / hashcat.git / blob
? search:


9ab8a6c113b693532646972a2730a41cb247745d
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "oclHashcat";
19 const uint VERSION_BIN = 210;
20 const uint RESTORE_MIN = 210;
21
22 double TARGET_MS_PROFILE[3] = { 8, 16, 96 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define BENCHMARK_REPEATS 2
37 #define RESTORE 0
38 #define RESTORE_TIMER 60
39 #define RESTORE_DISABLE 0
40 #define STATUS 0
41 #define STATUS_TIMER 10
42 #define STATUS_AUTOMAT 0
43 #define LOOPBACK 0
44 #define WEAK_HASH_THRESHOLD 100
45 #define SHOW 0
46 #define LEFT 0
47 #define USERNAME 0
48 #define REMOVE 0
49 #define REMOVE_TIMER 60
50 #define SKIP 0
51 #define LIMIT 0
52 #define KEYSPACE 0
53 #define POTFILE_DISABLE 0
54 #define DEBUG_MODE 0
55 #define RP_GEN 0
56 #define RP_GEN_FUNC_MIN 1
57 #define RP_GEN_FUNC_MAX 4
58 #define RP_GEN_SEED 0
59 #define RULE_BUF_L ":"
60 #define RULE_BUF_R ":"
61 #define FORCE 0
62 #define RUNTIME 0
63 #define HEX_CHARSET 0
64 #define HEX_SALT 0
65 #define HEX_WORDLIST 0
66 #define OUTFILE_FORMAT 3
67 #define OUTFILE_AUTOHEX 1
68 #define OUTFILE_CHECK_TIMER 5
69 #define ATTACK_MODE 0
70 #define HASH_MODE 0
71 #define SEGMENT_SIZE 32
72 #define INCREMENT 0
73 #define INCREMENT_MIN 1
74 #define INCREMENT_MAX PW_MAX
75 #define SEPARATOR ':'
76 #define BITMAP_MIN 16
77 #define BITMAP_MAX 24
78 #define GPU_TEMP_DISABLE 0
79 #define GPU_TEMP_ABORT 90
80 #define GPU_TEMP_RETAIN 80
81 #define WORKLOAD_PROFILE 2
82 #define KERNEL_ACCEL 0
83 #define KERNEL_LOOPS 0
84 #define KERNEL_RULES 1024
85 #define KERNEL_COMBS 1024
86 #define KERNEL_BFS 1024
87 #define KERNEL_THREADS 64
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMT_HASHCAT 0
101 #define HLFMT_PWDUMP 1
102 #define HLFMT_PASSWD 2
103 #define HLFMT_SHADOW 3
104 #define HLFMT_DCC 4
105 #define HLFMT_DCC2 5
106 #define HLFMT_NETNTLM1 7
107 #define HLFMT_NETNTLM2 8
108 #define HLFMT_NSLDAP 9
109 #define HLFMT_NSLDAPS 10
110 #define HLFMTS_CNT 11
111
112 #define ATTACK_MODE_STRAIGHT 0
113 #define ATTACK_MODE_COMBI 1
114 #define ATTACK_MODE_TOGGLE 2
115 #define ATTACK_MODE_BF 3
116 #define ATTACK_MODE_PERM 4
117 #define ATTACK_MODE_TABLE 5
118 #define ATTACK_MODE_HYBRID1 6
119 #define ATTACK_MODE_HYBRID2 7
120 #define ATTACK_MODE_NONE 100
121
122 #define ATTACK_KERN_STRAIGHT 0
123 #define ATTACK_KERN_COMBI 1
124 #define ATTACK_KERN_BF 3
125 #define ATTACK_KERN_NONE 100
126
127 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
128 #define ATTACK_EXEC_INSIDE_KERNEL 11
129
130 #define COMBINATOR_MODE_BASE_LEFT 10001
131 #define COMBINATOR_MODE_BASE_RIGHT 10002
132
133 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
134 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
135
136 #define MAX_CUT_TRIES 4
137
138 #define MAX_DICTSTAT 10000
139
140 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 131
141
142 #define global_free(attr) \
143 { \
144 myfree ((void *) data.attr); \
145 \
146 data.attr = NULL; \
147 }
148
149 #define local_free(attr) \
150 { \
151 myfree ((void *) attr); \
152 \
153 attr = NULL; \
154 }
155
156 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
157 {
158 900,
159 0,
160 5100,
161 100,
162 1400,
163 10800,
164 1700,
165 5000,
166 10100,
167 6000,
168 6100,
169 6900,
170 11700,
171 11800,
172 400,
173 8900,
174 11900,
175 12000,
176 10900,
177 12100,
178 23,
179 2500,
180 5300,
181 5400,
182 5500,
183 5600,
184 7300,
185 7500,
186 13100,
187 8300,
188 11100,
189 11200,
190 11400,
191 121,
192 2611,
193 2711,
194 2811,
195 8400,
196 11,
197 2612,
198 7900,
199 21,
200 11000,
201 124,
202 10000,
203 3711,
204 7600,
205 12,
206 131,
207 132,
208 1731,
209 200,
210 300,
211 3100,
212 112,
213 12300,
214 8000,
215 141,
216 1441,
217 1600,
218 12600,
219 1421,
220 101,
221 111,
222 1711,
223 3000,
224 1000,
225 1100,
226 2100,
227 12800,
228 1500,
229 12400,
230 500,
231 3200,
232 7400,
233 1800,
234 122,
235 1722,
236 7100,
237 6300,
238 6700,
239 6400,
240 6500,
241 2400,
242 2410,
243 5700,
244 9200,
245 9300,
246 22,
247 501,
248 5800,
249 8100,
250 8500,
251 7200,
252 9900,
253 7700,
254 7800,
255 10300,
256 8600,
257 8700,
258 9100,
259 133,
260 11600,
261 12500,
262 13000,
263 6211,
264 6221,
265 6231,
266 6241,
267 8800,
268 12900,
269 12200,
270 9700,
271 9710,
272 9800,
273 9810,
274 9400,
275 9500,
276 9600,
277 10400,
278 10410,
279 10500,
280 10600,
281 10700,
282 9000,
283 5200,
284 6800,
285 6600,
286 8200,
287 11300,
288 12700
289 };
290
291 /**
292 * types
293 */
294
295 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
296
297 /**
298 * globals
299 */
300
301 static unsigned int full01 = 0x01010101;
302 static unsigned int full80 = 0x80808080;
303
304 int SUPPRESS_OUTPUT = 0;
305
306 hc_thread_mutex_t mux_adl;
307 hc_thread_mutex_t mux_counter;
308 hc_thread_mutex_t mux_dispatcher;
309 hc_thread_mutex_t mux_display;
310
311 hc_global_data_t data;
312
313 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
314
315 const char *USAGE_MINI[] =
316 {
317 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
318 "",
319 "Try --help for more help.",
320 NULL
321 };
322
323 const char *USAGE_BIG[] =
324 {
325 "%s, advanced password recovery",
326 "",
327 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
328 "",
329 "=======",
330 "Options",
331 "=======",
332 "",
333 "* General:",
334 "",
335 " -m, --hash-type=NUM Hash-type, see references below",
336 " -a, --attack-mode=NUM Attack-mode, see references below",
337 " -V, --version Print version",
338 " -h, --help Print help",
339 " --quiet Suppress output",
340 "",
341 "* Misc:",
342 "",
343 " --hex-charset Assume charset is given in hex",
344 " --hex-salt Assume salt is given in hex",
345 " --hex-wordlist Assume words in wordlist is given in hex",
346 " --force Ignore warnings",
347 " --status Enable automatic update of the status-screen",
348 " --status-timer=NUM Seconds between status-screen update",
349 " --status-automat Display the status view in a machine readable format",
350 " --loopback Add new plains to induct directory",
351 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
352 "",
353 "* Markov:",
354 "",
355 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
356 " --markov-disable Disables markov-chains, emulates classic brute-force",
357 " --markov-classic Enables classic markov-chains, no per-position enhancement",
358 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
359 "",
360 "* Session:",
361 "",
362 " --runtime=NUM Abort session after NUM seconds of runtime",
363 " --session=STR Define specific session name",
364 " --restore Restore session from --session",
365 " --restore-disable Do not write restore file",
366 "",
367 "* Files:",
368 "",
369 " -o, --outfile=FILE Define outfile for recovered hash",
370 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
371 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
372 " --outfile-check-timer=NUM Seconds between outfile checks",
373 " -p, --separator=CHAR Separator char for hashlists and outfile",
374 " --show Show cracked passwords only",
375 " --left Show un-cracked passwords only",
376 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
377 " --remove Enable remove of hash once it is cracked",
378 " --remove-timer=NUM Update input hash file each NUM seconds",
379 " --potfile-disable Do not write potfile",
380 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
381 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
382 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
383 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
384 " --logfile-disable Disable the logfile",
385 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
386 "",
387 "* Resources:",
388 "",
389 " -b, --benchmark Run benchmark",
390 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
391 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
392 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
393 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
394 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
395 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
396 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
397 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
398 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
399 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
400 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
401 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
402 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
403 #ifdef HAVE_HWMON
404 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
405 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
406 #ifdef HAVE_ADL
407 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
408 #endif
409 #endif
410 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
411 "",
412 "* Distributed:",
413 "",
414 " -s, --skip=NUM Skip number of words",
415 " -l, --limit=NUM Limit number of words",
416 " --keyspace Show keyspace base:mod values and quit",
417 "",
418 "* Rules:",
419 "",
420 " -j, --rule-left=RULE Single rule applied to each word from left dict",
421 " -k, --rule-right=RULE Single rule applied to each word from right dict",
422 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
423 " -g, --generate-rules=NUM Generate NUM random rules",
424 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
425 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
426 " --generate-rules-seed=NUM Force RNG seed to NUM",
427 "",
428 "* Custom charsets:",
429 "",
430 " -1, --custom-charset1=CS User-defined charsets",
431 " -2, --custom-charset2=CS Example:",
432 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
433 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
434 "",
435 "* Increment:",
436 "",
437 " -i, --increment Enable increment mode",
438 " --increment-min=NUM Start incrementing at NUM",
439 " --increment-max=NUM Stop incrementing at NUM",
440 "",
441 "==========",
442 "References",
443 "==========",
444 "",
445 "* Workload Profile:",
446 "",
447 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
448 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
449 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
450 "",
451 "* OpenCL device-types:",
452 "",
453 " 1 = CPU devices",
454 " 2 = GPU devices",
455 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
456 "",
457 "* Outfile Formats:",
458 "",
459 " 1 = hash[:salt]",
460 " 2 = plain",
461 " 3 = hash[:salt]:plain",
462 " 4 = hex_plain",
463 " 5 = hash[:salt]:hex_plain",
464 " 6 = plain:hex_plain",
465 " 7 = hash[:salt]:plain:hex_plain",
466 " 8 = crackpos",
467 " 9 = hash[:salt]:crackpos",
468 " 10 = plain:crackpos",
469 " 11 = hash[:salt]:plain:crackpos",
470 " 12 = hex_plain:crackpos",
471 " 13 = hash[:salt]:hex_plain:crackpos",
472 " 14 = plain:hex_plain:crackpos",
473 " 15 = hash[:salt]:plain:hex_plain:crackpos",
474 "",
475 "* Debug mode output formats (for hybrid mode only, by using rules):",
476 "",
477 " 1 = save finding rule",
478 " 2 = save original word",
479 " 3 = save original word and finding rule",
480 " 4 = save original word, finding rule and modified plain",
481 "",
482 "* Built-in charsets:",
483 "",
484 " ?l = abcdefghijklmnopqrstuvwxyz",
485 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
486 " ?d = 0123456789",
487 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
488 " ?a = ?l?u?d?s",
489 " ?b = 0x00 - 0xff",
490 "",
491 "* Attack modes:",
492 "",
493 " 0 = Straight",
494 " 1 = Combination",
495 " 3 = Brute-force",
496 " 6 = Hybrid dict + mask",
497 " 7 = Hybrid mask + dict",
498 "",
499 "* Hash types:",
500 "",
501 "[[ Roll-your-own: Raw Hashes ]]",
502 "",
503 " 900 = MD4",
504 " 0 = MD5",
505 " 5100 = Half MD5",
506 " 100 = SHA1",
507 " 10800 = SHA-384",
508 " 1400 = SHA-256",
509 " 1700 = SHA-512",
510 " 5000 = SHA-3(Keccak)",
511 " 10100 = SipHash",
512 " 6000 = RipeMD160",
513 " 6100 = Whirlpool",
514 " 6900 = GOST R 34.11-94",
515 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
516 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
517 "",
518 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
519 "",
520 " 10 = md5($pass.$salt)",
521 " 20 = md5($salt.$pass)",
522 " 30 = md5(unicode($pass).$salt)",
523 " 40 = md5($salt.unicode($pass))",
524 " 3800 = md5($salt.$pass.$salt)",
525 " 3710 = md5($salt.md5($pass))",
526 " 2600 = md5(md5($pass)",
527 " 4300 = md5(strtoupper(md5($pass)))",
528 " 4400 = md5(sha1($pass))",
529 " 110 = sha1($pass.$salt)",
530 " 120 = sha1($salt.$pass)",
531 " 130 = sha1(unicode($pass).$salt)",
532 " 140 = sha1($salt.unicode($pass))",
533 " 4500 = sha1(sha1($pass)",
534 " 4700 = sha1(md5($pass))",
535 " 4900 = sha1($salt.$pass.$salt)",
536 " 1410 = sha256($pass.$salt)",
537 " 1420 = sha256($salt.$pass)",
538 " 1430 = sha256(unicode($pass).$salt)",
539 " 1440 = sha256($salt.unicode($pass))",
540 " 1710 = sha512($pass.$salt)",
541 " 1720 = sha512($salt.$pass)",
542 " 1730 = sha512(unicode($pass).$salt)",
543 " 1740 = sha512($salt.unicode($pass))",
544 "",
545 "[[ Roll-your-own: Authenticated Hashes ]]",
546 "",
547 " 50 = HMAC-MD5 (key = $pass)",
548 " 60 = HMAC-MD5 (key = $salt)",
549 " 150 = HMAC-SHA1 (key = $pass)",
550 " 160 = HMAC-SHA1 (key = $salt)",
551 " 1450 = HMAC-SHA256 (key = $pass)",
552 " 1460 = HMAC-SHA256 (key = $salt)",
553 " 1750 = HMAC-SHA512 (key = $pass)",
554 " 1760 = HMAC-SHA512 (key = $salt)",
555 "",
556 "[[ Generic KDF ]]",
557 "",
558 " 400 = phpass",
559 " 8900 = scrypt",
560 " 11900 = PBKDF2-HMAC-MD5",
561 " 12000 = PBKDF2-HMAC-SHA1",
562 " 10900 = PBKDF2-HMAC-SHA256",
563 " 12100 = PBKDF2-HMAC-SHA512",
564 "",
565 "[[ Network protocols, Challenge-Response ]]",
566 "",
567 " 23 = Skype",
568 " 2500 = WPA/WPA2",
569 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
570 " 5300 = IKE-PSK MD5",
571 " 5400 = IKE-PSK SHA1",
572 " 5500 = NetNTLMv1",
573 " 5500 = NetNTLMv1 + ESS",
574 " 5600 = NetNTLMv2",
575 " 7300 = IPMI2 RAKP HMAC-SHA1",
576 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
577 " 8300 = DNSSEC (NSEC3)",
578 " 10200 = Cram MD5",
579 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
580 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
581 " 11400 = SIP digest authentication (MD5)",
582 " 13100 = Kerberos 5 TGS-REP etype 23",
583 "",
584 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
585 "",
586 " 121 = SMF (Simple Machines Forum)",
587 " 400 = phpBB3",
588 " 2611 = vBulletin < v3.8.5",
589 " 2711 = vBulletin > v3.8.5",
590 " 2811 = MyBB",
591 " 2811 = IPB (Invison Power Board)",
592 " 8400 = WBB3 (Woltlab Burning Board)",
593 " 11 = Joomla < 2.5.18",
594 " 400 = Joomla > 2.5.18",
595 " 400 = Wordpress",
596 " 2612 = PHPS",
597 " 7900 = Drupal7",
598 " 21 = osCommerce",
599 " 21 = xt:Commerce",
600 " 11000 = PrestaShop",
601 " 124 = Django (SHA-1)",
602 " 10000 = Django (PBKDF2-SHA256)",
603 " 3711 = Mediawiki B type",
604 " 7600 = Redmine",
605 "",
606 "[[ Database Server ]]",
607 "",
608 " 12 = PostgreSQL",
609 " 131 = MSSQL(2000)",
610 " 132 = MSSQL(2005)",
611 " 1731 = MSSQL(2012)",
612 " 1731 = MSSQL(2014)",
613 " 200 = MySQL323",
614 " 300 = MySQL4.1/MySQL5",
615 " 3100 = Oracle H: Type (Oracle 7+)",
616 " 112 = Oracle S: Type (Oracle 11+)",
617 " 12300 = Oracle T: Type (Oracle 12+)",
618 " 8000 = Sybase ASE",
619 "",
620 "[[ HTTP, SMTP, LDAP Server ]]",
621 "",
622 " 141 = EPiServer 6.x < v4",
623 " 1441 = EPiServer 6.x > v4",
624 " 1600 = Apache $apr1$",
625 " 12600 = ColdFusion 10+",
626 " 1421 = hMailServer",
627 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
628 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
629 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
630 "",
631 "[[ Checksums ]]",
632 "",
633 " 11500 = CRC32",
634 "",
635 "[[ Operating-Systems ]]",
636 "",
637 " 3000 = LM",
638 " 1000 = NTLM",
639 " 1100 = Domain Cached Credentials (DCC), MS Cache",
640 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
641 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
642 " 1500 = descrypt, DES(Unix), Traditional DES",
643 " 12400 = BSDiCrypt, Extended DES",
644 " 500 = md5crypt $1$, MD5(Unix)",
645 " 3200 = bcrypt $2*$, Blowfish(Unix)",
646 " 7400 = sha256crypt $5$, SHA256(Unix)",
647 " 1800 = sha512crypt $6$, SHA512(Unix)",
648 " 122 = OSX v10.4",
649 " 122 = OSX v10.5",
650 " 122 = OSX v10.6",
651 " 1722 = OSX v10.7",
652 " 7100 = OSX v10.8",
653 " 7100 = OSX v10.9",
654 " 7100 = OSX v10.10",
655 " 6300 = AIX {smd5}",
656 " 6700 = AIX {ssha1}",
657 " 6400 = AIX {ssha256}",
658 " 6500 = AIX {ssha512}",
659 " 2400 = Cisco-PIX",
660 " 2410 = Cisco-ASA",
661 " 500 = Cisco-IOS $1$",
662 " 5700 = Cisco-IOS $4$",
663 " 9200 = Cisco-IOS $8$",
664 " 9300 = Cisco-IOS $9$",
665 " 22 = Juniper Netscreen/SSG (ScreenOS)",
666 " 501 = Juniper IVE",
667 " 5800 = Android PIN",
668 " 8100 = Citrix Netscaler",
669 " 8500 = RACF",
670 " 7200 = GRUB 2",
671 " 9900 = Radmin2",
672 "",
673 "[[ Enterprise Application Software (EAS) ]]",
674 "",
675 " 7700 = SAP CODVN B (BCODE)",
676 " 7800 = SAP CODVN F/G (PASSCODE)",
677 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
678 " 8600 = Lotus Notes/Domino 5",
679 " 8700 = Lotus Notes/Domino 6",
680 " 9100 = Lotus Notes/Domino 8",
681 " 133 = PeopleSoft",
682 "",
683 "[[ Archives ]]",
684 "",
685 " 11600 = 7-Zip",
686 " 12500 = RAR3-hp",
687 " 13000 = RAR5",
688 "",
689 "[[ Full-Disk encryptions (FDE) ]]",
690 "",
691 " 62XY = TrueCrypt 5.0+",
692 " X = 1 = PBKDF2-HMAC-RipeMD160",
693 " X = 2 = PBKDF2-HMAC-SHA512",
694 " X = 3 = PBKDF2-HMAC-Whirlpool",
695 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
696 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
697 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
698 " Y = 3 = XTS 1536 bit (Ciphers: All)",
699 " 8800 = Android FDE < v4.3",
700 " 12900 = Android FDE (Samsung DEK)",
701 " 12200 = eCryptfs",
702 "",
703 "[[ Documents ]]",
704 "",
705 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
706 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
707 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
708 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
709 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
710 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
711 " 9400 = MS Office 2007",
712 " 9500 = MS Office 2010",
713 " 9600 = MS Office 2013",
714 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
715 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
716 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
717 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
718 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
719 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
720 "",
721 "[[ Password Managers ]]",
722 "",
723 " 9000 = Password Safe v2",
724 " 5200 = Password Safe v3",
725 " 6800 = Lastpass",
726 " 6600 = 1Password, agilekeychain",
727 " 8200 = 1Password, cloudkeychain",
728 " 11300 = Bitcoin/Litecoin wallet.dat",
729 " 12700 = Blockchain, My Wallet",
730 "",
731 NULL
732 };
733
734 /**
735 * oclHashcat specific functions
736 */
737
738 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
739 {
740 int exec_pos = (int) device_param->exec_pos - last_num_entries;
741
742 if (exec_pos < 0) exec_pos += EXEC_CACHE;
743
744 double exec_ms_sum = 0;
745
746 int exec_ms_cnt = 0;
747
748 for (int i = 0; i < last_num_entries; i++)
749 {
750 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
751
752 if (exec_ms)
753 {
754 exec_ms_sum += exec_ms;
755
756 exec_ms_cnt++;
757 }
758 }
759
760 if (exec_ms_cnt == 0) return 0;
761
762 return exec_ms_sum / exec_ms_cnt;
763 }
764
765 void status_display_automat ()
766 {
767 FILE *out = stdout;
768
769 fprintf (out, "STATUS\t%u\t", data.devices_status);
770
771 /**
772 * speed new
773 */
774
775 fprintf (out, "SPEED\t");
776
777 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
778 {
779 hc_device_param_t *device_param = &data.devices_param[device_id];
780
781 if (device_param->skipped) continue;
782
783 u64 speed_cnt = 0;
784 float speed_ms = 0;
785
786 for (int i = 0; i < SPEED_CACHE; i++)
787 {
788 float rec_ms;
789
790 hc_timer_get (device_param->speed_rec[i], rec_ms);
791
792 if (rec_ms > SPEED_MAXAGE) continue;
793
794 speed_cnt += device_param->speed_cnt[i];
795 speed_ms += device_param->speed_ms[i];
796 }
797
798 speed_cnt /= SPEED_CACHE;
799 speed_ms /= SPEED_CACHE;
800
801 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
802 }
803
804 /**
805 * exec time
806 */
807
808 fprintf (out, "EXEC_RUNTIME\t");
809
810 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
811 {
812 hc_device_param_t *device_param = &data.devices_param[device_id];
813
814 if (device_param->skipped) continue;
815
816 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
817
818 fprintf (out, "%f\t", exec_ms_avg);
819 }
820
821 /**
822 * words_cur
823 */
824
825 u64 words_cur = get_lowest_words_done ();
826
827 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
828
829 /**
830 * counter
831 */
832
833 uint salts_left = data.salts_cnt - data.salts_done;
834
835 if (salts_left == 0) salts_left = 1;
836
837 u64 progress_total = data.words_cnt * salts_left;
838
839 u64 all_done = 0;
840 u64 all_rejected = 0;
841 u64 all_restored = 0;
842
843 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
844 {
845 if (salts_left > 1)
846 {
847 // otherwise the final cracked status shows 0/XXX progress
848
849 if (data.salts_shown[salt_pos] == 1) continue;
850 }
851
852 all_done += data.words_progress_done[salt_pos];
853 all_rejected += data.words_progress_rejected[salt_pos];
854 all_restored += data.words_progress_restored[salt_pos];
855 }
856
857 u64 progress_cur = all_restored + all_done + all_rejected;
858 u64 progress_end = progress_total;
859
860 u64 progress_skip = 0;
861
862 if (data.skip)
863 {
864 progress_skip = MIN (data.skip, data.words_base) * salts_left;
865
866 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
867 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
868 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
869 }
870
871 if (data.limit)
872 {
873 progress_end = MIN (data.limit, data.words_base) * salts_left;
874
875 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
876 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
877 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
878 }
879
880 u64 progress_cur_relative_skip = progress_cur - progress_skip;
881 u64 progress_end_relative_skip = progress_end - progress_skip;
882
883 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
884
885 /**
886 * cracks
887 */
888
889 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
890 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
891
892 /**
893 * temperature
894 */
895
896 #ifdef HAVE_HWMON
897 if (data.gpu_temp_disable == 0)
898 {
899 fprintf (out, "TEMP\t");
900
901 hc_thread_mutex_lock (mux_adl);
902
903 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
904 {
905 hc_device_param_t *device_param = &data.devices_param[device_id];
906
907 if (device_param->skipped) continue;
908
909 int temp = hm_get_temperature_with_device_id (device_id);
910
911 fprintf (out, "%d\t", temp);
912 }
913
914 hc_thread_mutex_unlock (mux_adl);
915 }
916 #endif // HAVE_HWMON
917
918 /**
919 * flush
920 */
921
922 #ifdef _WIN
923 fputc ('\r', out);
924 fputc ('\n', out);
925 #endif
926
927 #ifdef _POSIX
928 fputc ('\n', out);
929 #endif
930
931 fflush (out);
932 }
933
934 void status_display ()
935 {
936 if (data.devices_status == STATUS_INIT) return;
937 if (data.devices_status == STATUS_STARTING) return;
938 if (data.devices_status == STATUS_BYPASS) return;
939
940 if (data.status_automat == 1)
941 {
942 status_display_automat ();
943
944 return;
945 }
946
947 char tmp_buf[1000] = { 0 };
948
949 uint tmp_len = 0;
950
951 log_info ("Session.Name...: %s", data.session);
952
953 char *status_type = strstatus (data.devices_status);
954
955 uint hash_mode = data.hash_mode;
956
957 char *hash_type = strhashtype (hash_mode); // not a bug
958
959 log_info ("Status.........: %s", status_type);
960
961 /**
962 * show rules
963 */
964
965 if (data.rp_files_cnt)
966 {
967 uint i;
968
969 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
970 {
971 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
972 }
973
974 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
975
976 log_info ("Rules.Type.....: %s", tmp_buf);
977
978 tmp_len = 0;
979 }
980
981 if (data.rp_gen)
982 {
983 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
984
985 if (data.rp_gen_seed)
986 {
987 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
988 }
989 }
990
991 /**
992 * show input
993 */
994
995 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
996 {
997 if (data.wordlist_mode == WL_MODE_FILE)
998 {
999 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1000 }
1001 else if (data.wordlist_mode == WL_MODE_STDIN)
1002 {
1003 log_info ("Input.Mode.....: Pipe");
1004 }
1005 }
1006 else if (data.attack_mode == ATTACK_MODE_COMBI)
1007 {
1008 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1009 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1010 }
1011 else if (data.attack_mode == ATTACK_MODE_BF)
1012 {
1013 char *mask = data.mask;
1014
1015 if (mask != NULL)
1016 {
1017 uint mask_len = data.css_cnt;
1018
1019 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1020
1021 if (mask_len > 0)
1022 {
1023 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1024 {
1025 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1026 {
1027 mask_len -= data.salts_buf[0].salt_len;
1028 }
1029 }
1030
1031 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1032
1033 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1034 }
1035
1036 if (data.maskcnt > 1)
1037 {
1038 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1039
1040 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1041 }
1042
1043 log_info ("Input.Mode.....: %s", tmp_buf);
1044 }
1045
1046 tmp_len = 0;
1047 }
1048 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1049 {
1050 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1051 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1052 }
1053 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1054 {
1055 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1056 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1057 }
1058
1059 if (data.digests_cnt == 1)
1060 {
1061 if (data.hash_mode == 2500)
1062 {
1063 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1064
1065 uint pke[25] = { 0 };
1066
1067 char *pke_ptr = (char *) pke;
1068
1069 for (uint i = 0; i < 25; i++)
1070 {
1071 pke[i] = byte_swap_32 (wpa->pke[i]);
1072 }
1073
1074 char mac1[6] = { 0 };
1075 char mac2[6] = { 0 };
1076
1077 memcpy (mac1, pke_ptr + 23, 6);
1078 memcpy (mac2, pke_ptr + 29, 6);
1079
1080 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1081 (char *) data.salts_buf[0].salt_buf,
1082 mac1[0] & 0xff,
1083 mac1[1] & 0xff,
1084 mac1[2] & 0xff,
1085 mac1[3] & 0xff,
1086 mac1[4] & 0xff,
1087 mac1[5] & 0xff,
1088 mac2[0] & 0xff,
1089 mac2[1] & 0xff,
1090 mac2[2] & 0xff,
1091 mac2[3] & 0xff,
1092 mac2[4] & 0xff,
1093 mac2[5] & 0xff);
1094 }
1095 else if (data.hash_mode == 5200)
1096 {
1097 log_info ("Hash.Target....: File (%s)", data.hashfile);
1098 }
1099 else if (data.hash_mode == 9000)
1100 {
1101 log_info ("Hash.Target....: File (%s)", data.hashfile);
1102 }
1103 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1104 {
1105 log_info ("Hash.Target....: File (%s)", data.hashfile);
1106 }
1107 else
1108 {
1109 char out_buf[4096] = { 0 };
1110
1111 ascii_digest (out_buf, 0, 0);
1112
1113 // limit length
1114 if (strlen (out_buf) > 40)
1115 {
1116 out_buf[41] = '.';
1117 out_buf[42] = '.';
1118 out_buf[43] = '.';
1119 out_buf[44] = 0;
1120 }
1121
1122 log_info ("Hash.Target....: %s", out_buf);
1123 }
1124 }
1125 else
1126 {
1127 if (data.hash_mode == 3000)
1128 {
1129 char out_buf1[4096] = { 0 };
1130 char out_buf2[4096] = { 0 };
1131
1132 ascii_digest (out_buf1, 0, 0);
1133 ascii_digest (out_buf2, 0, 1);
1134
1135 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1136 }
1137 else
1138 {
1139 log_info ("Hash.Target....: File (%s)", data.hashfile);
1140 }
1141 }
1142
1143 log_info ("Hash.Type......: %s", hash_type);
1144
1145 /**
1146 * speed new
1147 */
1148
1149 u64 speed_cnt[DEVICES_MAX] = { 0 };
1150 float speed_ms[DEVICES_MAX] = { 0 };
1151
1152 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1153 {
1154 hc_device_param_t *device_param = &data.devices_param[device_id];
1155
1156 if (device_param->skipped) continue;
1157
1158 // we need to clear values (set to 0) because in case the device does
1159 // not get new candidates it idles around but speed display would
1160 // show it as working.
1161 // if we instantly set it to 0 after reading it happens that the
1162 // speed can be shown as zero if the users refreshes too fast.
1163 // therefore, we add a timestamp when a stat was recorded and if its
1164 // too old we will not use it
1165
1166 speed_cnt[device_id] = 0;
1167 speed_ms[device_id] = 0;
1168
1169 for (int i = 0; i < SPEED_CACHE; i++)
1170 {
1171 float rec_ms;
1172
1173 hc_timer_get (device_param->speed_rec[i], rec_ms);
1174
1175 if (rec_ms > SPEED_MAXAGE) continue;
1176
1177 speed_cnt[device_id] += device_param->speed_cnt[i];
1178 speed_ms[device_id] += device_param->speed_ms[i];
1179 }
1180
1181 speed_cnt[device_id] /= SPEED_CACHE;
1182 speed_ms[device_id] /= SPEED_CACHE;
1183 }
1184
1185 float hashes_all_ms = 0;
1186
1187 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1188
1189 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1190 {
1191 hc_device_param_t *device_param = &data.devices_param[device_id];
1192
1193 if (device_param->skipped) continue;
1194
1195 hashes_dev_ms[device_id] = 0;
1196
1197 if (speed_ms[device_id])
1198 {
1199 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1200
1201 hashes_all_ms += hashes_dev_ms[device_id];
1202 }
1203 }
1204
1205 /**
1206 * exec time
1207 */
1208
1209 double exec_all_ms[DEVICES_MAX] = { 0 };
1210
1211 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1212 {
1213 hc_device_param_t *device_param = &data.devices_param[device_id];
1214
1215 if (device_param->skipped) continue;
1216
1217 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1218
1219 exec_all_ms[device_id] = exec_ms_avg;
1220 }
1221
1222 /**
1223 * timers
1224 */
1225
1226 float ms_running = 0;
1227
1228 hc_timer_get (data.timer_running, ms_running);
1229
1230 float ms_paused = data.ms_paused;
1231
1232 if (data.devices_status == STATUS_PAUSED)
1233 {
1234 float ms_paused_tmp = 0;
1235
1236 hc_timer_get (data.timer_paused, ms_paused_tmp);
1237
1238 ms_paused += ms_paused_tmp;
1239 }
1240
1241 #ifdef WIN
1242
1243 __time64_t sec_run = ms_running / 1000;
1244
1245 #else
1246
1247 time_t sec_run = ms_running / 1000;
1248
1249 #endif
1250
1251 if (sec_run)
1252 {
1253 char display_run[32] = { 0 };
1254
1255 struct tm tm_run;
1256
1257 struct tm *tmp = NULL;
1258
1259 #ifdef WIN
1260
1261 tmp = _gmtime64 (&sec_run);
1262
1263 #else
1264
1265 tmp = gmtime (&sec_run);
1266
1267 #endif
1268
1269 if (tmp != NULL)
1270 {
1271 memset (&tm_run, 0, sizeof (tm_run));
1272
1273 memcpy (&tm_run, tmp, sizeof (tm_run));
1274
1275 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1276
1277 char *start = ctime (&data.proc_start);
1278
1279 size_t start_len = strlen (start);
1280
1281 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1282 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1283
1284 log_info ("Time.Started...: %s (%s)", start, display_run);
1285 }
1286 }
1287 else
1288 {
1289 log_info ("Time.Started...: 0 secs");
1290 }
1291
1292 /**
1293 * counters
1294 */
1295
1296 uint salts_left = data.salts_cnt - data.salts_done;
1297
1298 if (salts_left == 0) salts_left = 1;
1299
1300 u64 progress_total = data.words_cnt * salts_left;
1301
1302 u64 all_done = 0;
1303 u64 all_rejected = 0;
1304 u64 all_restored = 0;
1305
1306 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1307 {
1308 if (salts_left > 1)
1309 {
1310 // otherwise the final cracked status shows 0/XXX progress
1311
1312 if (data.salts_shown[salt_pos] == 1) continue;
1313 }
1314
1315 all_done += data.words_progress_done[salt_pos];
1316 all_rejected += data.words_progress_rejected[salt_pos];
1317 all_restored += data.words_progress_restored[salt_pos];
1318 }
1319
1320 u64 progress_cur = all_restored + all_done + all_rejected;
1321 u64 progress_end = progress_total;
1322
1323 u64 progress_skip = 0;
1324
1325 if (data.skip)
1326 {
1327 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1328
1329 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1330 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1331 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1332 }
1333
1334 if (data.limit)
1335 {
1336 progress_end = MIN (data.limit, data.words_base) * salts_left;
1337
1338 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1339 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1340 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1341 }
1342
1343 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1344 u64 progress_end_relative_skip = progress_end - progress_skip;
1345
1346 float speed_ms_real = ms_running - ms_paused;
1347 u64 speed_plains_real = all_done;
1348
1349 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1350 {
1351 if (data.devices_status != STATUS_CRACKED)
1352 {
1353 u64 words_per_ms = 0;
1354
1355 if (speed_plains_real && speed_ms_real)
1356 {
1357 words_per_ms = speed_plains_real / speed_ms_real;
1358 }
1359
1360 #ifdef WIN
1361 __time64_t sec_etc = 0;
1362 #else
1363 time_t sec_etc = 0;
1364 #endif
1365
1366 if (words_per_ms)
1367 {
1368 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1369
1370 u64 ms_left = progress_left_relative_skip / words_per_ms;
1371
1372 sec_etc = ms_left / 1000;
1373 }
1374
1375 if (sec_etc == 0)
1376 {
1377 log_info ("Time.Estimated.: 0 secs");
1378 }
1379 else if ((u64) sec_etc > ETC_MAX)
1380 {
1381 log_info ("Time.Estimated.: > 10 Years");
1382 }
1383 else
1384 {
1385 char display_etc[32] = { 0 };
1386
1387 struct tm tm_etc;
1388
1389 struct tm *tmp = NULL;
1390
1391 #ifdef WIN
1392
1393 tmp = _gmtime64 (&sec_etc);
1394
1395 #else
1396
1397 tmp = gmtime (&sec_etc);
1398
1399 #endif
1400
1401 if (tmp != NULL)
1402 {
1403 memset (&tm_etc, 0, sizeof (tm_etc));
1404
1405 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1406
1407 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1408
1409 time_t now;
1410
1411 time (&now);
1412
1413 now += sec_etc;
1414
1415 char *etc = ctime (&now);
1416
1417 size_t etc_len = strlen (etc);
1418
1419 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1420 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1421
1422 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1423 }
1424 }
1425 }
1426 }
1427
1428 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1429 {
1430 hc_device_param_t *device_param = &data.devices_param[device_id];
1431
1432 if (device_param->skipped) continue;
1433
1434 char display_dev_cur[16] = { 0 };
1435
1436 strncpy (display_dev_cur, "0.00", 4);
1437
1438 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1439
1440 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1441 }
1442
1443 char display_all_cur[16] = { 0 };
1444
1445 strncpy (display_all_cur, "0.00", 4);
1446
1447 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1448
1449 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1450
1451 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1452 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1453
1454 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1455
1456 // crack-per-time
1457
1458 if (data.digests_cnt > 100)
1459 {
1460 time_t now = time (NULL);
1461
1462 int cpt_cur_min = 0;
1463 int cpt_cur_hour = 0;
1464 int cpt_cur_day = 0;
1465
1466 for (int i = 0; i < CPT_BUF; i++)
1467 {
1468 const uint cracked = data.cpt_buf[i].cracked;
1469 const time_t timestamp = data.cpt_buf[i].timestamp;
1470
1471 if ((timestamp + 60) > now)
1472 {
1473 cpt_cur_min += cracked;
1474 }
1475
1476 if ((timestamp + 3600) > now)
1477 {
1478 cpt_cur_hour += cracked;
1479 }
1480
1481 if ((timestamp + 86400) > now)
1482 {
1483 cpt_cur_day += cracked;
1484 }
1485 }
1486
1487 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1488 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1489 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1490
1491 if ((data.cpt_start + 86400) < now)
1492 {
1493 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1494 cpt_cur_min,
1495 cpt_cur_hour,
1496 cpt_cur_day,
1497 cpt_avg_min,
1498 cpt_avg_hour,
1499 cpt_avg_day);
1500 }
1501 else if ((data.cpt_start + 3600) < now)
1502 {
1503 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1504 cpt_cur_min,
1505 cpt_cur_hour,
1506 cpt_avg_min,
1507 cpt_avg_hour,
1508 cpt_avg_day);
1509 }
1510 else if ((data.cpt_start + 60) < now)
1511 {
1512 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1513 cpt_cur_min,
1514 cpt_avg_min,
1515 cpt_avg_hour,
1516 cpt_avg_day);
1517 }
1518 else
1519 {
1520 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1521 cpt_avg_min,
1522 cpt_avg_hour,
1523 cpt_avg_day);
1524 }
1525 }
1526
1527 // Restore point
1528
1529 u64 restore_point = get_lowest_words_done ();
1530
1531 u64 restore_total = data.words_base;
1532
1533 float percent_restore = 0;
1534
1535 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1536
1537 if (progress_end_relative_skip)
1538 {
1539 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1540 {
1541 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1542 float percent_rejected = 0.0;
1543
1544 if (progress_cur)
1545 {
1546 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1547 }
1548
1549 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1550 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1551
1552 if (data.restore_disable == 0)
1553 {
1554 if (percent_finished != 1)
1555 {
1556 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1557 }
1558 }
1559 }
1560 }
1561 else
1562 {
1563 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1564 {
1565 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1566 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1567
1568 if (data.restore_disable == 0)
1569 {
1570 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1571 }
1572 }
1573 else
1574 {
1575 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1576 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1577
1578 // --restore not allowed if stdin is used -- really? why?
1579
1580 //if (data.restore_disable == 0)
1581 //{
1582 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1583 //}
1584 }
1585 }
1586
1587 #ifdef HAVE_HWMON
1588 if (data.gpu_temp_disable == 0)
1589 {
1590 hc_thread_mutex_lock (mux_adl);
1591
1592 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1593 {
1594 hc_device_param_t *device_param = &data.devices_param[device_id];
1595
1596 if (device_param->skipped) continue;
1597
1598 #define HM_STR_BUF_SIZE 255
1599
1600 if (data.hm_device[device_id].fan_supported == 1)
1601 {
1602 char utilization[HM_STR_BUF_SIZE] = { 0 };
1603 char temperature[HM_STR_BUF_SIZE] = { 0 };
1604 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1605
1606 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1607 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1608
1609 if (device_param->vendor_id == VENDOR_ID_AMD)
1610 {
1611 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1612 }
1613 else if (device_param->vendor_id == VENDOR_ID_NV)
1614 {
1615 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1616 }
1617
1618 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1619 }
1620 else
1621 {
1622 char utilization[HM_STR_BUF_SIZE] = { 0 };
1623 char temperature[HM_STR_BUF_SIZE] = { 0 };
1624
1625 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1626 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1627
1628 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1629 }
1630 }
1631
1632 hc_thread_mutex_unlock (mux_adl);
1633 }
1634 #endif // HAVE_HWMON
1635 }
1636
1637 static void status_benchmark ()
1638 {
1639 if (data.devices_status == STATUS_INIT) return;
1640 if (data.devices_status == STATUS_STARTING) return;
1641
1642 if (data.words_cnt == 0) return;
1643
1644 u64 speed_cnt[DEVICES_MAX] = { 0 };
1645 float speed_ms[DEVICES_MAX] = { 0 };
1646
1647 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1648 {
1649 hc_device_param_t *device_param = &data.devices_param[device_id];
1650
1651 if (device_param->skipped) continue;
1652
1653 speed_cnt[device_id] = 0;
1654 speed_ms[device_id] = 0;
1655
1656 for (int i = 0; i < SPEED_CACHE; i++)
1657 {
1658 speed_cnt[device_id] += device_param->speed_cnt[i];
1659 speed_ms[device_id] += device_param->speed_ms[i];
1660 }
1661
1662 speed_cnt[device_id] /= SPEED_CACHE;
1663 speed_ms[device_id] /= SPEED_CACHE;
1664 }
1665
1666 float hashes_all_ms = 0;
1667
1668 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1669
1670 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1671 {
1672 hc_device_param_t *device_param = &data.devices_param[device_id];
1673
1674 if (device_param->skipped) continue;
1675
1676 hashes_dev_ms[device_id] = 0;
1677
1678 if (speed_ms[device_id])
1679 {
1680 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1681
1682 hashes_all_ms += hashes_dev_ms[device_id];
1683 }
1684 }
1685
1686 /**
1687 * exec time
1688 */
1689
1690 double exec_all_ms[DEVICES_MAX] = { 0 };
1691
1692 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1693 {
1694 hc_device_param_t *device_param = &data.devices_param[device_id];
1695
1696 if (device_param->skipped) continue;
1697
1698 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1699
1700 exec_all_ms[device_id] = exec_ms_avg;
1701 }
1702
1703 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1704 {
1705 hc_device_param_t *device_param = &data.devices_param[device_id];
1706
1707 if (device_param->skipped) continue;
1708
1709 char display_dev_cur[16] = { 0 };
1710
1711 strncpy (display_dev_cur, "0.00", 4);
1712
1713 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1714
1715 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1716 }
1717
1718 char display_all_cur[16] = { 0 };
1719
1720 strncpy (display_all_cur, "0.00", 4);
1721
1722 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1723
1724 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1725 }
1726
1727 /**
1728 * oclHashcat -only- functions
1729 */
1730
1731 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1732 {
1733 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1734 {
1735 if (attack_kern == ATTACK_KERN_STRAIGHT)
1736 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1737 else if (attack_kern == ATTACK_KERN_COMBI)
1738 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1739 else if (attack_kern == ATTACK_KERN_BF)
1740 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1741 }
1742 else
1743 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1744 }
1745
1746 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1747 {
1748 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1749 {
1750 if (attack_kern == ATTACK_KERN_STRAIGHT)
1751 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1752 else if (attack_kern == ATTACK_KERN_COMBI)
1753 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1754 else if (attack_kern == ATTACK_KERN_BF)
1755 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1756 }
1757 else
1758 {
1759 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1760 }
1761 }
1762
1763 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1764 {
1765 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1766 {
1767 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1768 }
1769 else
1770 {
1771 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1772 }
1773 }
1774
1775 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1776 {
1777 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1778 {
1779 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1780 }
1781 else
1782 {
1783 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1784 }
1785 }
1786
1787 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1788 {
1789 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1790 }
1791
1792 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1793 {
1794 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1795 }
1796
1797 static uint convert_from_hex (char *line_buf, const uint line_len)
1798 {
1799 if (line_len & 1) return (line_len); // not in hex
1800
1801 if (data.hex_wordlist == 1)
1802 {
1803 uint i;
1804 uint j;
1805
1806 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1807 {
1808 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1809 }
1810
1811 memset (line_buf + i, 0, line_len - i);
1812
1813 return (i);
1814 }
1815 else if (line_len >= 6) // $HEX[] = 6
1816 {
1817 if (line_buf[0] != '$') return (line_len);
1818 if (line_buf[1] != 'H') return (line_len);
1819 if (line_buf[2] != 'E') return (line_len);
1820 if (line_buf[3] != 'X') return (line_len);
1821 if (line_buf[4] != '[') return (line_len);
1822 if (line_buf[line_len - 1] != ']') return (line_len);
1823
1824 uint i;
1825 uint j;
1826
1827 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1828 {
1829 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1830 }
1831
1832 memset (line_buf + i, 0, line_len - i);
1833
1834 return (i);
1835 }
1836
1837 return (line_len);
1838 }
1839
1840 static void clear_prompt ()
1841 {
1842 fputc ('\r', stdout);
1843
1844 for (size_t i = 0; i < strlen (PROMPT); i++)
1845 {
1846 fputc (' ', stdout);
1847 }
1848
1849 fputc ('\r', stdout);
1850
1851 fflush (stdout);
1852 }
1853
1854 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1855 {
1856 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1857 }
1858
1859 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1860 {
1861 char *outfile = data.outfile;
1862 uint quiet = data.quiet;
1863 FILE *pot_fp = data.pot_fp;
1864 uint loopback = data.loopback;
1865 uint debug_mode = data.debug_mode;
1866 char *debug_file = data.debug_file;
1867
1868 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1869 int debug_rule_len = 0; // -1 error
1870 uint debug_plain_len = 0;
1871
1872 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1873
1874 // hash
1875
1876 char out_buf[4096] = { 0 };
1877
1878 ascii_digest (out_buf, salt_pos, digest_pos);
1879
1880 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1881
1882 // plain
1883
1884 plain_t plain;
1885
1886 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1887
1888 uint gidvid = plain.gidvid;
1889 uint il_pos = plain.il_pos;
1890
1891 u64 crackpos = device_param->words_off;
1892
1893 uint plain_buf[16] = { 0 };
1894
1895 u8 *plain_ptr = (u8 *) plain_buf;
1896 unsigned int plain_len = 0;
1897
1898 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1899 {
1900 u64 gidd = gidvid;
1901 u64 gidm = 0;
1902
1903 pw_t pw;
1904
1905 gidd_to_pw_t (device_param, gidd, &pw);
1906
1907 for (int i = 0, j = gidm; i < 16; i++, j++)
1908 {
1909 plain_buf[i] = pw.i[j];
1910 }
1911
1912 plain_len = pw.pw_len;
1913
1914 const uint off = device_param->innerloop_pos + il_pos;
1915
1916 if (debug_mode > 0)
1917 {
1918 debug_rule_len = 0;
1919
1920 // save rule
1921 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1922 {
1923 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1924
1925 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1926 }
1927
1928 // save plain
1929 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1930 {
1931 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1932
1933 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1934
1935 debug_plain_len = plain_len;
1936 }
1937 }
1938
1939 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1940
1941 crackpos += gidvid;
1942 crackpos *= data.kernel_rules_cnt;
1943 crackpos += device_param->innerloop_pos + il_pos;
1944
1945 if (plain_len > data.pw_max) plain_len = data.pw_max;
1946 }
1947 else if (data.attack_mode == ATTACK_MODE_COMBI)
1948 {
1949 u64 gidd = gidvid;
1950 u64 gidm = 0;
1951
1952 pw_t pw;
1953
1954 gidd_to_pw_t (device_param, gidd, &pw);
1955
1956 for (int i = 0, j = gidm; i < 16; i++, j++)
1957 {
1958 plain_buf[i] = pw.i[j];
1959 }
1960
1961 plain_len = pw.pw_len;
1962
1963 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1964 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1965
1966 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1967 {
1968 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1969 }
1970 else
1971 {
1972 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1973
1974 memcpy (plain_ptr, comb_buf, comb_len);
1975 }
1976
1977 plain_len += comb_len;
1978
1979 crackpos += gidvid;
1980 crackpos *= data.combs_cnt;
1981 crackpos += device_param->innerloop_pos + il_pos;
1982
1983 if (data.pw_max != PW_DICTMAX1)
1984 {
1985 if (plain_len > data.pw_max) plain_len = data.pw_max;
1986 }
1987 }
1988 else if (data.attack_mode == ATTACK_MODE_BF)
1989 {
1990 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1991 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1992
1993 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1994 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1995
1996 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1997 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1998
1999 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2000 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2001
2002 plain_len = data.css_cnt;
2003
2004 crackpos += gidvid;
2005 crackpos *= data.bfs_cnt;
2006 crackpos += device_param->innerloop_pos + il_pos;
2007 }
2008 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2009 {
2010 u64 gidd = gidvid;
2011 u64 gidm = 0;
2012
2013 pw_t pw;
2014
2015 gidd_to_pw_t (device_param, gidd, &pw);
2016
2017 for (int i = 0, j = gidm; i < 16; i++, j++)
2018 {
2019 plain_buf[i] = pw.i[j];
2020 }
2021
2022 plain_len = pw.pw_len;
2023
2024 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2025
2026 uint start = 0;
2027 uint stop = device_param->kernel_params_mp_buf32[4];
2028
2029 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2030
2031 plain_len += start + stop;
2032
2033 crackpos += gidvid;
2034 crackpos *= data.combs_cnt;
2035 crackpos += device_param->innerloop_pos + il_pos;
2036
2037 if (data.pw_max != PW_DICTMAX1)
2038 {
2039 if (plain_len > data.pw_max) plain_len = data.pw_max;
2040 }
2041 }
2042 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2043 {
2044 u64 gidd = gidvid;
2045 u64 gidm = 0;
2046
2047 pw_t pw;
2048
2049 gidd_to_pw_t (device_param, gidd, &pw);
2050
2051 for (int i = 0, j = gidm; i < 16; i++, j++)
2052 {
2053 plain_buf[i] = pw.i[j];
2054 }
2055
2056 plain_len = pw.pw_len;
2057
2058 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2059
2060 uint start = 0;
2061 uint stop = device_param->kernel_params_mp_buf32[4];
2062
2063 memmove (plain_ptr + stop, plain_ptr, plain_len);
2064
2065 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2066
2067 plain_len += start + stop;
2068
2069 crackpos += gidvid;
2070 crackpos *= data.combs_cnt;
2071 crackpos += device_param->innerloop_pos + il_pos;
2072
2073 if (data.pw_max != PW_DICTMAX1)
2074 {
2075 if (plain_len > data.pw_max) plain_len = data.pw_max;
2076 }
2077 }
2078
2079 if (data.attack_mode == ATTACK_MODE_BF)
2080 {
2081 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2082 {
2083 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2084 {
2085 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2086 {
2087 plain_len = plain_len - data.salts_buf[0].salt_len;
2088 }
2089 }
2090
2091 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2092 {
2093 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2094 {
2095 plain_ptr[j] = plain_ptr[i];
2096 }
2097
2098 plain_len = plain_len / 2;
2099 }
2100 }
2101 }
2102
2103 // if enabled, update also the potfile
2104
2105 if (pot_fp)
2106 {
2107 lock_file (pot_fp);
2108
2109 fprintf (pot_fp, "%s:", out_buf);
2110
2111 format_plain (pot_fp, plain_ptr, plain_len, 1);
2112
2113 fputc ('\n', pot_fp);
2114
2115 fflush (pot_fp);
2116
2117 unlock_file (pot_fp);
2118 }
2119
2120 // outfile
2121
2122 FILE *out_fp = NULL;
2123
2124 if (outfile != NULL)
2125 {
2126 if ((out_fp = fopen (outfile, "ab")) == NULL)
2127 {
2128 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2129
2130 out_fp = stdout;
2131 }
2132 lock_file (out_fp);
2133 }
2134 else
2135 {
2136 out_fp = stdout;
2137
2138 if (quiet == 0) clear_prompt ();
2139 }
2140
2141 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2142
2143 if (outfile != NULL)
2144 {
2145 if (out_fp != stdout)
2146 {
2147 fclose (out_fp);
2148 }
2149 }
2150 else
2151 {
2152 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2153 {
2154 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2155 {
2156 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2157 if (quiet == 0) fflush (stdout);
2158 }
2159 }
2160 }
2161
2162 // loopback
2163
2164 if (loopback)
2165 {
2166 char *loopback_file = data.loopback_file;
2167
2168 FILE *fb_fp = NULL;
2169
2170 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2171 {
2172 lock_file (fb_fp);
2173
2174 format_plain (fb_fp, plain_ptr, plain_len, 1);
2175
2176 fputc ('\n', fb_fp);
2177
2178 fclose (fb_fp);
2179 }
2180 }
2181
2182 // (rule) debug mode
2183
2184 // the next check implies that:
2185 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2186 // - debug_mode > 0
2187
2188 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2189 {
2190 if (debug_rule_len < 0) debug_rule_len = 0;
2191
2192 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2193
2194 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2195
2196 if ((quiet == 0) && (debug_file == NULL))
2197 {
2198 fprintf (stdout, "%s", PROMPT);
2199 fflush (stdout);
2200 }
2201 }
2202 }
2203
2204 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2205 {
2206 salt_t *salt_buf = &data.salts_buf[salt_pos];
2207
2208 int found = 0;
2209
2210 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2211
2212 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2213
2214 if (found == 1)
2215 {
2216 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2217
2218 log_info_nn ("");
2219
2220 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2221
2222 uint cpt_cracked = 0;
2223
2224 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2225 {
2226 uint idx = salt_buf->digests_offset + digest_pos;
2227
2228 if (data.digests_shown_tmp[idx] == 0) continue;
2229
2230 if (data.digests_shown[idx] == 1) continue;
2231
2232 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2233 {
2234 data.digests_shown[idx] = 1;
2235
2236 data.digests_done++;
2237
2238 cpt_cracked++;
2239
2240 salt_buf->digests_done++;
2241
2242 if (salt_buf->digests_done == salt_buf->digests_cnt)
2243 {
2244 data.salts_shown[salt_pos] = 1;
2245
2246 data.salts_done++;
2247 }
2248 }
2249
2250 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2251
2252 check_hash (device_param, salt_pos, digest_pos);
2253 }
2254
2255 if (cpt_cracked > 0)
2256 {
2257 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2258 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2259
2260 data.cpt_pos++;
2261
2262 data.cpt_total += cpt_cracked;
2263
2264 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2265 }
2266
2267 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2268 {
2269 // we need to reset cracked state on the device
2270 // otherwise host thinks again and again the hash was cracked
2271 // and returns invalid password each time
2272
2273 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2274
2275 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2276 }
2277
2278 memset (device_param->result, 0, device_param->size_results);
2279
2280 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2281 }
2282 }
2283
2284 static void save_hash ()
2285 {
2286 char *hashfile = data.hashfile;
2287
2288 char new_hashfile[256] = { 0 };
2289 char old_hashfile[256] = { 0 };
2290
2291 snprintf (new_hashfile, 255, "%s.new", hashfile);
2292 snprintf (old_hashfile, 255, "%s.old", hashfile);
2293
2294 unlink (new_hashfile);
2295
2296 char separator = data.separator;
2297
2298 FILE *fp = fopen (new_hashfile, "wb");
2299
2300 if (fp == NULL)
2301 {
2302 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2303
2304 exit (-1);
2305 }
2306
2307 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2308 {
2309 if (data.salts_shown[salt_pos] == 1) continue;
2310
2311 salt_t *salt_buf = &data.salts_buf[salt_pos];
2312
2313 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2314 {
2315 uint idx = salt_buf->digests_offset + digest_pos;
2316
2317 if (data.digests_shown[idx] == 1) continue;
2318
2319 if (data.hash_mode != 2500)
2320 {
2321 char out_buf[4096] = { 0 };
2322
2323 if (data.username == 1)
2324 {
2325 user_t *user = data.hash_info[idx]->user;
2326
2327 uint i;
2328
2329 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2330
2331 fputc (separator, fp);
2332 }
2333
2334 ascii_digest (out_buf, salt_pos, digest_pos);
2335
2336 fputs (out_buf, fp);
2337
2338 log_out (fp, "");
2339 }
2340 else
2341 {
2342 hccap_t hccap;
2343
2344 to_hccap_t (&hccap, salt_pos, digest_pos);
2345
2346 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2347 }
2348 }
2349 }
2350
2351 fflush (fp);
2352
2353 fclose (fp);
2354
2355 unlink (old_hashfile);
2356
2357 if (rename (hashfile, old_hashfile) != 0)
2358 {
2359 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2360
2361 exit (-1);
2362 }
2363
2364 unlink (hashfile);
2365
2366 if (rename (new_hashfile, hashfile) != 0)
2367 {
2368 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2369
2370 exit (-1);
2371 }
2372
2373 unlink (old_hashfile);
2374 }
2375
2376 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2377 {
2378 // function called only in case kernel_power_all > words_left
2379
2380 float kernel_power_div = (float) (total_left) / kernel_power_all;
2381
2382 kernel_power_div += kernel_power_div / 100;
2383
2384 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2385
2386 while (kernel_power_new < total_left)
2387 {
2388 kernel_power_div += kernel_power_div / 100;
2389
2390 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2391 }
2392
2393 if (data.quiet == 0)
2394 {
2395 clear_prompt ();
2396
2397 log_info ("");
2398
2399 log_info ("INFO: approaching final keyspace, workload adjusted");
2400
2401 log_info ("");
2402
2403 fprintf (stdout, "%s", PROMPT);
2404
2405 fflush (stdout);
2406 }
2407
2408 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2409
2410 return kernel_power_div;
2411 }
2412
2413 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2414 {
2415 uint num_elements = num;
2416
2417 device_param->kernel_params_buf32[30] = data.combs_mode;
2418 device_param->kernel_params_buf32[31] = num;
2419
2420 uint kernel_threads = device_param->kernel_threads;
2421
2422 while (num_elements % kernel_threads) num_elements++;
2423
2424 cl_kernel kernel = NULL;
2425
2426 switch (kern_run)
2427 {
2428 case KERN_RUN_1: kernel = device_param->kernel1; break;
2429 case KERN_RUN_12: kernel = device_param->kernel12; break;
2430 case KERN_RUN_2: kernel = device_param->kernel2; break;
2431 case KERN_RUN_23: kernel = device_param->kernel23; break;
2432 case KERN_RUN_3: kernel = device_param->kernel3; break;
2433 }
2434
2435 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2436 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2437 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2438 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2439 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2440 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2441 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2442 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2443 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2444 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2445 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2446
2447 hc_timer_t timer;
2448
2449 hc_timer_set (&timer);
2450
2451 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2452 {
2453 const size_t global_work_size[3] = { num_elements, 32, 1 };
2454 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2455
2456 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2457 }
2458 else
2459 {
2460 size_t workgroup_size = 0;
2461
2462 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2463
2464 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2465
2466 const size_t global_work_size[3] = { num_elements, 1, 1 };
2467 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2468
2469 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2470 }
2471
2472 hc_clFlush (data.ocl, device_param->command_queue);
2473
2474 hc_clFinish (data.ocl, device_param->command_queue);
2475
2476 if (event_update)
2477 {
2478 float exec_time;
2479
2480 hc_timer_get (timer, exec_time);
2481
2482 uint exec_pos = device_param->exec_pos;
2483
2484 device_param->exec_ms[exec_pos] = exec_time;
2485
2486 exec_pos++;
2487
2488 if (exec_pos == EXEC_CACHE)
2489 {
2490 exec_pos = 0;
2491 }
2492
2493 device_param->exec_pos = exec_pos;
2494 }
2495 }
2496
2497 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2498 {
2499 uint num_elements = num;
2500
2501 switch (kern_run)
2502 {
2503 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2504 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2505 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2506 }
2507
2508 // causes problems with special threads like in bcrypt
2509 // const uint kernel_threads = device_param->kernel_threads;
2510
2511 uint kernel_threads = KERNEL_THREADS;
2512
2513 while (num_elements % kernel_threads) num_elements++;
2514
2515 cl_kernel kernel = NULL;
2516
2517 switch (kern_run)
2518 {
2519 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2520 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2521 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2522 }
2523
2524 switch (kern_run)
2525 {
2526 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2527 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2528 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2529 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2530 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2531 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2532 break;
2533 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2534 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2535 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2536 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2537 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2538 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2539 break;
2540 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2541 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2542 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2543 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2544 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2545 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2546 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2547 break;
2548 }
2549
2550 size_t workgroup_size = 0;
2551 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
2552 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2553
2554 const size_t global_work_size[3] = { num_elements, 1, 1 };
2555 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2556
2557 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2558
2559 hc_clFlush (data.ocl, device_param->command_queue);
2560
2561 hc_clFinish (data.ocl, device_param->command_queue);
2562 }
2563
2564 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2565 {
2566 uint num_elements = num;
2567
2568 uint kernel_threads = device_param->kernel_threads;
2569
2570 while (num_elements % kernel_threads) num_elements++;
2571
2572 cl_kernel kernel = device_param->kernel_tb;
2573
2574 size_t workgroup_size = 0;
2575 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2576 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2577
2578 const size_t global_work_size[3] = { num_elements, 1, 1 };
2579 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2580
2581 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2582
2583 hc_clFlush (data.ocl, device_param->command_queue);
2584
2585 hc_clFinish (data.ocl, device_param->command_queue);
2586 }
2587
2588 static void run_kernel_tm (hc_device_param_t *device_param)
2589 {
2590 const uint num_elements = 1024; // fixed
2591
2592 uint kernel_threads = 32;
2593
2594 cl_kernel kernel = device_param->kernel_tm;
2595
2596 size_t workgroup_size = 0;
2597 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2598 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2599
2600 const size_t global_work_size[3] = { num_elements, 1, 1 };
2601 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2602
2603 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2604
2605 hc_clFlush (data.ocl, device_param->command_queue);
2606
2607 hc_clFinish (data.ocl, device_param->command_queue);
2608 }
2609
2610 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2611 {
2612 uint num_elements = num;
2613
2614 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2615 device_param->kernel_params_amp_buf32[6] = num_elements;
2616
2617 // causes problems with special threads like in bcrypt
2618 // const uint kernel_threads = device_param->kernel_threads;
2619
2620 uint kernel_threads = KERNEL_THREADS;
2621
2622 while (num_elements % kernel_threads) num_elements++;
2623
2624 cl_kernel kernel = device_param->kernel_amp;
2625
2626 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2627 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2628
2629 size_t workgroup_size = 0;
2630 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2631 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2632
2633 const size_t global_work_size[3] = { num_elements, 1, 1 };
2634 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2635
2636 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2637
2638 hc_clFlush (data.ocl, device_param->command_queue);
2639
2640 hc_clFinish (data.ocl, device_param->command_queue);
2641 }
2642
2643 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2644 {
2645 int rc = -1;
2646
2647 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2648 {
2649 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2650
2651 const cl_uchar zero = 0;
2652
2653 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2654 }
2655
2656 if (rc != 0)
2657 {
2658 // NOTE: clEnqueueFillBuffer () always fails with -59
2659 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2660 // How's that possible, OpenCL 1.2 support is advertised??
2661 // We need to workaround...
2662
2663 #define FILLSZ 0x100000
2664
2665 char *tmp = (char *) mymalloc (FILLSZ);
2666
2667 for (uint i = 0; i < size; i += FILLSZ)
2668 {
2669 const int left = size - i;
2670
2671 const int fillsz = MIN (FILLSZ, left);
2672
2673 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2674 }
2675
2676 myfree (tmp);
2677 }
2678 }
2679
2680 static void choose_kernel (hc_device_param_t *device_param, const uint attack_exec, const uint attack_mode, const uint opts_type, const salt_t *salt_buf, const uint highest_pw_len, const uint pws_cnt)
2681 {
2682 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2683 {
2684 if (attack_mode == ATTACK_MODE_BF)
2685 {
2686 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2687 {
2688 const uint size_tm = 32 * sizeof (bs_word_t);
2689
2690 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2691
2692 run_kernel_tm (device_param);
2693
2694 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2695 }
2696 }
2697
2698 if (highest_pw_len < 16)
2699 {
2700 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2701 }
2702 else if (highest_pw_len < 32)
2703 {
2704 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2705 }
2706 else
2707 {
2708 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2709 }
2710 }
2711 else
2712 {
2713 run_kernel_amp (device_param, pws_cnt);
2714
2715 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2716
2717 if (opts_type & OPTS_TYPE_HOOK12)
2718 {
2719 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2720 }
2721
2722 uint iter = salt_buf->salt_iter;
2723
2724 uint loop_step = device_param->kernel_loops;
2725
2726 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2727 {
2728 uint loop_left = iter - loop_pos;
2729
2730 loop_left = MIN (loop_left, loop_step);
2731
2732 device_param->kernel_params_buf32[25] = loop_pos;
2733 device_param->kernel_params_buf32[26] = loop_left;
2734
2735 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2736
2737 if (data.devices_status == STATUS_CRACKED) break;
2738 if (data.devices_status == STATUS_ABORTED) break;
2739 if (data.devices_status == STATUS_QUIT) break;
2740 }
2741
2742 if (opts_type & OPTS_TYPE_HOOK23)
2743 {
2744 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2745
2746 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2747
2748 // do something with data
2749
2750 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2751 }
2752
2753 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2754 }
2755 }
2756
2757 static int run_rule_engine (const int rule_len, const char *rule_buf)
2758 {
2759 if (rule_len == 0)
2760 {
2761 return 0;
2762 }
2763 else if (rule_len == 1)
2764 {
2765 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2766 }
2767
2768 return 1;
2769 }
2770
2771 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2772 {
2773 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2774 {
2775 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2776 }
2777 else if (data.attack_kern == ATTACK_KERN_COMBI)
2778 {
2779 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2780 {
2781 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2782 {
2783 for (u32 i = 0; i < pws_cnt; i++)
2784 {
2785 const u32 pw_len = device_param->pws_buf[i].pw_len;
2786
2787 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2788
2789 ptr[pw_len] = 0x01;
2790 }
2791 }
2792 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2793 {
2794 for (u32 i = 0; i < pws_cnt; i++)
2795 {
2796 const u32 pw_len = device_param->pws_buf[i].pw_len;
2797
2798 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2799
2800 ptr[pw_len] = 0x80;
2801 }
2802 }
2803 }
2804
2805 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2806 }
2807 else if (data.attack_kern == ATTACK_KERN_BF)
2808 {
2809 const u64 off = device_param->words_off;
2810
2811 device_param->kernel_params_mp_l_buf64[3] = off;
2812
2813 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2814 }
2815 }
2816
2817 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops, const int repeat)
2818 {
2819 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2820
2821 device_param->kernel_params_buf32[26] = kernel_loops;
2822 device_param->kernel_params_buf32[27] = kernel_loops;
2823
2824 // init some fake words
2825
2826 if (data.attack_kern == ATTACK_KERN_BF)
2827 {
2828 run_kernel_mp (KERN_RUN_MP_L, device_param, kernel_power);
2829 run_kernel_mp (KERN_RUN_MP_R, device_param, kernel_loops);
2830 }
2831 else
2832 {
2833 for (u32 i = 0; i < kernel_power; i++)
2834 {
2835 device_param->pws_buf[i].pw_len = i & 7;
2836 }
2837
2838 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2839
2840 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2841 {
2842 run_kernel_amp (device_param, kernel_power);
2843 }
2844 }
2845
2846 // caching run
2847
2848 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2849 {
2850 run_kernel (KERN_RUN_1, device_param, kernel_power, false);
2851 }
2852 else
2853 {
2854 run_kernel (KERN_RUN_2, device_param, kernel_power, false);
2855 }
2856
2857 // now user repeats
2858
2859 for (int i = 0; i < repeat; i++)
2860 {
2861 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2862 {
2863 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2864 }
2865 else
2866 {
2867 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2868 }
2869 }
2870
2871 const double exec_ms_prev = get_avg_exec_time (device_param, repeat);
2872
2873 // reset fake words
2874
2875 memset (device_param->pws_buf, 0, kernel_power * sizeof (pw_t));
2876
2877 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2878 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_amp_buf, CL_TRUE, 0, kernel_power * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2879
2880 return exec_ms_prev;
2881 }
2882
2883 static void autotune (hc_device_param_t *device_param)
2884 {
2885 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2886
2887 const u32 kernel_accel_min = device_param->kernel_accel_min;
2888 const u32 kernel_accel_max = device_param->kernel_accel_max;
2889
2890 const u32 kernel_loops_min = device_param->kernel_loops_min;
2891 const u32 kernel_loops_max = device_param->kernel_loops_max;
2892
2893 u32 kernel_accel = kernel_accel_min;
2894 u32 kernel_loops = kernel_loops_min;
2895
2896 // steps
2897
2898 #define STEPS_CNT 10
2899
2900 #define STEPS_ACCEL_CNT (STEPS_CNT + 2)
2901 #define STEPS_LOOPS_CNT (STEPS_CNT + 2)
2902
2903 u32 steps_accel[STEPS_ACCEL_CNT];
2904 u32 steps_loops[STEPS_LOOPS_CNT];
2905
2906 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2907 {
2908 steps_accel[i] = 1 << i;
2909 }
2910
2911 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2912 {
2913 steps_loops[i] = 1 << i;
2914 }
2915
2916 steps_accel[STEPS_CNT + 0] = kernel_accel_min;
2917 steps_accel[STEPS_CNT + 1] = kernel_accel_max;
2918
2919 steps_loops[STEPS_CNT + 0] = kernel_loops_min;
2920 steps_loops[STEPS_CNT + 1] = kernel_loops_max;
2921
2922 qsort (steps_accel, STEPS_ACCEL_CNT, sizeof (u32), sort_by_u32);
2923 qsort (steps_loops, STEPS_LOOPS_CNT, sizeof (u32), sort_by_u32);
2924
2925 // find out highest kernel-loops that stays below target_ms, we can use it later for multiplication as this is a linear function
2926
2927 u32 kernel_loops_tmp;
2928
2929 for (kernel_loops_tmp = kernel_loops_max; kernel_loops_tmp > kernel_loops_min; kernel_loops_tmp >>= 1)
2930 {
2931 const double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops_tmp, 1);
2932
2933 if (exec_ms < target_ms) break;
2934 }
2935
2936 // kernel-accel
2937
2938 if (kernel_accel_min < kernel_accel_max)
2939 {
2940 double e_best = 0;
2941
2942 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2943 {
2944 const u32 kernel_accel_try = steps_accel[i];
2945
2946 if (kernel_accel_try < kernel_accel_min) continue;
2947 if (kernel_accel_try > kernel_accel_max) break;
2948
2949 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_tmp, 1);
2950
2951 if (exec_ms > target_ms) break;
2952
2953 const double e = kernel_accel_try / exec_ms;
2954
2955 if (e > e_best)
2956 {
2957 kernel_accel = kernel_accel_try;
2958
2959 e_best = e;
2960 }
2961 }
2962 }
2963
2964 // kernel-loops final
2965
2966 if (kernel_loops_min < kernel_loops_max)
2967 {
2968 double e_best = 0;
2969
2970 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2971 {
2972 const u32 kernel_loops_try = steps_loops[i];
2973
2974 if (kernel_loops_try < kernel_loops_min) continue;
2975 if (kernel_loops_try > kernel_loops_max) break;
2976
2977 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops_try, 1);
2978
2979 if (exec_ms > target_ms) break;
2980
2981 const double e = kernel_loops_try / exec_ms;
2982
2983 if (e > e_best)
2984 {
2985 kernel_loops = kernel_loops_try;
2986
2987 e_best = e;
2988 }
2989 }
2990 }
2991
2992 // final balance
2993
2994 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops, 1);
2995
2996 u32 kernel_accel_best = kernel_accel;
2997 u32 kernel_loops_best = kernel_loops;
2998
2999 u32 exec_best = exec_ms;
3000
3001 // reset
3002
3003 if (kernel_accel_min < kernel_accel_max)
3004 {
3005 u32 kernel_accel_try = kernel_accel;
3006 u32 kernel_loops_try = kernel_loops;
3007
3008 for (int i = 0; i < 2; i++)
3009 {
3010 kernel_accel_try >>= 1;
3011 kernel_loops_try <<= 1;
3012
3013 if (kernel_accel_try < kernel_accel_min) break;
3014 if (kernel_loops_try > kernel_loops_max) break;
3015
3016 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
3017
3018 if (exec_ms < exec_best)
3019 {
3020 kernel_accel_best = kernel_accel_try;
3021 kernel_loops_best = kernel_loops_try;
3022
3023 exec_best = exec_ms;
3024 }
3025 }
3026
3027 kernel_accel = kernel_accel_best;
3028 kernel_loops = kernel_loops_best;
3029 }
3030
3031 // reset
3032
3033
3034 if (kernel_loops_min < kernel_loops_max)
3035 {
3036 u32 kernel_accel_try = kernel_accel;
3037 u32 kernel_loops_try = kernel_loops;
3038
3039 for (int i = 0; i < 2; i++)
3040 {
3041 kernel_accel_try <<= 1;
3042 kernel_loops_try >>= 1;
3043
3044 if (kernel_accel_try > kernel_accel_max) break;
3045 if (kernel_loops_try < kernel_loops_min) break;
3046
3047 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
3048
3049 if (exec_ms < exec_best)
3050 {
3051 kernel_accel_best = kernel_accel_try;
3052 kernel_loops_best = kernel_loops_try;
3053
3054 exec_best = exec_ms;
3055 }
3056 }
3057
3058 kernel_accel = kernel_accel_best;
3059 kernel_loops = kernel_loops_best;
3060 }
3061
3062 // reset timer
3063
3064 device_param->exec_pos = 0;
3065
3066 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3067
3068 // store
3069
3070 device_param->kernel_loops = kernel_loops;
3071 device_param->kernel_accel = kernel_accel;
3072
3073 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3074
3075 device_param->kernel_power = kernel_power;
3076
3077 if (data.quiet == 0) log_info ("Device #%u: autotuned kernel-accel to %u", device_param->device_id + 1, kernel_accel);
3078 if (data.quiet == 0) log_info ("Device #%u: autotuned kernel-loops to %u", device_param->device_id + 1, kernel_loops);
3079 if (data.quiet == 0) log_info ("");
3080 }
3081
3082 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3083 {
3084 // init speed timer
3085
3086 uint speed_pos = device_param->speed_pos;
3087
3088 #ifdef _POSIX
3089 if (device_param->timer_speed.tv_sec == 0)
3090 {
3091 hc_timer_set (&device_param->timer_speed);
3092 }
3093 #endif
3094
3095 #ifdef _WIN
3096 if (device_param->timer_speed.QuadPart == 0)
3097 {
3098 hc_timer_set (&device_param->timer_speed);
3099 }
3100 #endif
3101
3102 // find higest password length, this is for optimization stuff
3103
3104 uint highest_pw_len = 0;
3105
3106 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3107 {
3108 }
3109 else if (data.attack_kern == ATTACK_KERN_COMBI)
3110 {
3111 }
3112 else if (data.attack_kern == ATTACK_KERN_BF)
3113 {
3114 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3115 + device_param->kernel_params_mp_l_buf32[5];
3116 }
3117
3118 // bitslice optimization stuff
3119
3120 if (data.attack_mode == ATTACK_MODE_BF)
3121 {
3122 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
3123 {
3124 run_kernel_tb (device_param, pws_cnt);
3125 }
3126 }
3127
3128 // iteration type
3129
3130 uint innerloop_step = 0;
3131 uint innerloop_cnt = 0;
3132
3133 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3134 else innerloop_step = 1;
3135
3136 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3137 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3138 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3139
3140 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3141
3142 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3143 {
3144 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3145
3146 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3147
3148 if (data.devices_status == STATUS_CRACKED) break;
3149 if (data.devices_status == STATUS_ABORTED) break;
3150 if (data.devices_status == STATUS_QUIT) break;
3151 if (data.devices_status == STATUS_BYPASS) break;
3152
3153 if (data.salts_shown[salt_pos] == 1) continue;
3154
3155 salt_t *salt_buf = &data.salts_buf[salt_pos];
3156
3157 device_param->kernel_params_buf32[24] = salt_pos;
3158 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3159 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3160
3161 FILE *combs_fp = device_param->combs_fp;
3162
3163 if (data.attack_mode == ATTACK_MODE_COMBI)
3164 {
3165 rewind (combs_fp);
3166 }
3167
3168 // innerloops
3169
3170 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3171 {
3172 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3173
3174 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3175
3176 if (data.devices_status == STATUS_CRACKED) break;
3177 if (data.devices_status == STATUS_ABORTED) break;
3178 if (data.devices_status == STATUS_QUIT) break;
3179 if (data.devices_status == STATUS_BYPASS) break;
3180
3181 uint innerloop_left = innerloop_cnt - innerloop_pos;
3182
3183 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3184
3185 device_param->innerloop_pos = innerloop_pos;
3186 device_param->innerloop_left = innerloop_left;
3187
3188 device_param->kernel_params_buf32[27] = innerloop_left;
3189
3190 // i think we can get rid of this
3191 if (innerloop_left == 0)
3192 {
3193 puts ("bug, how should this happen????\n");
3194
3195 continue;
3196 }
3197
3198 // initialize amplifiers
3199
3200 if (data.attack_mode == ATTACK_MODE_COMBI)
3201 {
3202 char line_buf[BUFSIZ] = { 0 };
3203
3204 uint i = 0;
3205
3206 while (i < innerloop_left)
3207 {
3208 if (feof (combs_fp)) break;
3209
3210 int line_len = fgetl (combs_fp, line_buf);
3211
3212 if (line_len >= PW_MAX1) continue;
3213
3214 line_len = convert_from_hex (line_buf, line_len);
3215
3216 char *line_buf_new = line_buf;
3217
3218 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3219 {
3220 char rule_buf_out[BLOCK_SIZE] = { 0 };
3221
3222 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3223
3224 if (rule_len_out < 0)
3225 {
3226 data.words_progress_rejected[salt_pos] += pws_cnt;
3227
3228 continue;
3229 }
3230
3231 line_len = rule_len_out;
3232
3233 line_buf_new = rule_buf_out;
3234 }
3235
3236 line_len = MIN (line_len, PW_DICTMAX);
3237
3238 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3239
3240 memcpy (ptr, line_buf_new, line_len);
3241
3242 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3243
3244 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3245 {
3246 uppercase (ptr, line_len);
3247 }
3248
3249 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3250 {
3251 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3252 {
3253 ptr[line_len] = 0x80;
3254 }
3255
3256 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3257 {
3258 ptr[line_len] = 0x01;
3259 }
3260 }
3261
3262 device_param->combs_buf[i].pw_len = line_len;
3263
3264 i++;
3265 }
3266
3267 for (uint j = i; j < innerloop_left; j++)
3268 {
3269 device_param->combs_buf[j].i[0] = 0;
3270 device_param->combs_buf[j].i[1] = 0;
3271 device_param->combs_buf[j].i[2] = 0;
3272 device_param->combs_buf[j].i[3] = 0;
3273 device_param->combs_buf[j].i[4] = 0;
3274 device_param->combs_buf[j].i[5] = 0;
3275 device_param->combs_buf[j].i[6] = 0;
3276 device_param->combs_buf[j].i[7] = 0;
3277
3278 device_param->combs_buf[j].pw_len = 0;
3279 }
3280
3281 innerloop_left = i;
3282 }
3283 else if (data.attack_mode == ATTACK_MODE_BF)
3284 {
3285 u64 off = innerloop_pos;
3286
3287 device_param->kernel_params_mp_r_buf64[3] = off;
3288
3289 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3290 }
3291 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3292 {
3293 u64 off = innerloop_pos;
3294
3295 device_param->kernel_params_mp_buf64[3] = off;
3296
3297 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3298 }
3299 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3300 {
3301 u64 off = innerloop_pos;
3302
3303 device_param->kernel_params_mp_buf64[3] = off;
3304
3305 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3306 }
3307
3308 // copy amplifiers
3309
3310 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3311 {
3312 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, innerloop_pos * sizeof (kernel_rule_t), 0, innerloop_left * sizeof (kernel_rule_t), 0, NULL, NULL);
3313 }
3314 else if (data.attack_mode == ATTACK_MODE_COMBI)
3315 {
3316 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_combs_c, CL_TRUE, 0, innerloop_left * sizeof (comb_t), device_param->combs_buf, 0, NULL, NULL);
3317 }
3318 else if (data.attack_mode == ATTACK_MODE_BF)
3319 {
3320 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_bfs, device_param->d_bfs_c, 0, 0, innerloop_left * sizeof (bf_t), 0, NULL, NULL);
3321 }
3322 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3323 {
3324 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3325 }
3326 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3327 {
3328 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3329 }
3330
3331 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3332
3333 if (data.benchmark == 1)
3334 {
3335 for (u32 i = 0; i < data.benchmark_repeats; i++)
3336 {
3337 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3338 }
3339 }
3340
3341 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3342
3343 if (data.devices_status == STATUS_CRACKED) break;
3344 if (data.devices_status == STATUS_ABORTED) break;
3345 if (data.devices_status == STATUS_QUIT) break;
3346
3347 /**
3348 * result
3349 */
3350
3351 hc_thread_mutex_lock (mux_display);
3352
3353 check_cracked (device_param, salt_pos);
3354
3355 hc_thread_mutex_unlock (mux_display);
3356
3357 /**
3358 * progress
3359 */
3360
3361 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3362
3363 if (data.benchmark == 1)
3364 {
3365 perf_sum_all = (perf_sum_all * data.benchmark_repeats) + perf_sum_all;
3366 }
3367
3368 hc_thread_mutex_lock (mux_counter);
3369
3370 data.words_progress_done[salt_pos] += perf_sum_all;
3371
3372 hc_thread_mutex_unlock (mux_counter);
3373
3374 /**
3375 * speed
3376 */
3377
3378 float speed_ms;
3379
3380 hc_timer_get (device_param->timer_speed, speed_ms);
3381
3382 hc_timer_set (&device_param->timer_speed);
3383
3384 hc_thread_mutex_lock (mux_display);
3385
3386 device_param->speed_cnt[speed_pos] = perf_sum_all;
3387
3388 device_param->speed_ms[speed_pos] = speed_ms;
3389
3390 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3391
3392 hc_thread_mutex_unlock (mux_display);
3393
3394 speed_pos++;
3395
3396 if (speed_pos == SPEED_CACHE)
3397 {
3398 speed_pos = 0;
3399 }
3400
3401 /**
3402 * benchmark
3403 */
3404
3405 if (data.benchmark == 1) break;
3406 }
3407 }
3408
3409 device_param->speed_pos = speed_pos;
3410 }
3411
3412 static void load_segment (wl_data_t *wl_data, FILE *fd)
3413 {
3414 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3415
3416 wl_data->pos = 0;
3417
3418 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3419
3420 wl_data->buf[wl_data->cnt] = 0;
3421
3422 if (wl_data->cnt == 0) return;
3423
3424 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3425
3426 while (!feof (fd))
3427 {
3428 if (wl_data->cnt == wl_data->avail)
3429 {
3430 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3431
3432 wl_data->avail += wl_data->incr;
3433 }
3434
3435 const int c = fgetc (fd);
3436
3437 if (c == EOF) break;
3438
3439 wl_data->buf[wl_data->cnt] = (char) c;
3440
3441 wl_data->cnt++;
3442
3443 if (c == '\n') break;
3444 }
3445
3446 // ensure stream ends with a newline
3447
3448 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3449 {
3450 wl_data->cnt++;
3451
3452 wl_data->buf[wl_data->cnt - 1] = '\n';
3453 }
3454
3455 return;
3456 }
3457
3458 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3459 {
3460 char *ptr = buf;
3461
3462 for (u32 i = 0; i < sz; i++, ptr++)
3463 {
3464 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3465
3466 if (i == 7)
3467 {
3468 *off = i;
3469 *len = i;
3470
3471 return;
3472 }
3473
3474 if (*ptr != '\n') continue;
3475
3476 *off = i + 1;
3477
3478 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3479
3480 *len = i;
3481
3482 return;
3483 }
3484
3485 *off = sz;
3486 *len = sz;
3487 }
3488
3489 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3490 {
3491 char *ptr = buf;
3492
3493 for (u32 i = 0; i < sz; i++, ptr++)
3494 {
3495 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3496
3497 if (*ptr != '\n') continue;
3498
3499 *off = i + 1;
3500
3501 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3502
3503 *len = i;
3504
3505 return;
3506 }
3507
3508 *off = sz;
3509 *len = sz;
3510 }
3511
3512 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3513 {
3514 char *ptr = buf;
3515
3516 for (u32 i = 0; i < sz; i++, ptr++)
3517 {
3518 if (*ptr != '\n') continue;
3519
3520 *off = i + 1;
3521
3522 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3523
3524 *len = i;
3525
3526 return;
3527 }
3528
3529 *off = sz;
3530 *len = sz;
3531 }
3532
3533 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3534 {
3535 while (wl_data->pos < wl_data->cnt)
3536 {
3537 uint off;
3538 uint len;
3539
3540 char *ptr = wl_data->buf + wl_data->pos;
3541
3542 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3543
3544 wl_data->pos += off;
3545
3546 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3547 {
3548 char rule_buf_out[BLOCK_SIZE] = { 0 };
3549
3550 int rule_len_out = -1;
3551
3552 if (len < BLOCK_SIZE)
3553 {
3554 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3555 }
3556
3557 if (rule_len_out < 0)
3558 {
3559 continue;
3560 }
3561
3562 if (rule_len_out > PW_MAX)
3563 {
3564 continue;
3565 }
3566 }
3567 else
3568 {
3569 if (len > PW_MAX)
3570 {
3571 continue;
3572 }
3573 }
3574
3575 *out_buf = ptr;
3576 *out_len = len;
3577
3578 return;
3579 }
3580
3581 if (feof (fd))
3582 {
3583 fprintf (stderr, "BUG feof()!!\n");
3584
3585 return;
3586 }
3587
3588 load_segment (wl_data, fd);
3589
3590 get_next_word (wl_data, fd, out_buf, out_len);
3591 }
3592
3593 #ifdef _POSIX
3594 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3595 #endif
3596
3597 #ifdef _WIN
3598 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3599 #endif
3600 {
3601 hc_signal (NULL);
3602
3603 dictstat_t d;
3604
3605 d.cnt = 0;
3606
3607 #ifdef _POSIX
3608 fstat (fileno (fd), &d.stat);
3609 #endif
3610
3611 #ifdef _WIN
3612 _fstat64 (fileno (fd), &d.stat);
3613 #endif
3614
3615 d.stat.st_mode = 0;
3616 d.stat.st_nlink = 0;
3617 d.stat.st_uid = 0;
3618 d.stat.st_gid = 0;
3619 d.stat.st_rdev = 0;
3620 d.stat.st_atime = 0;
3621
3622 #ifdef _POSIX
3623 d.stat.st_blksize = 0;
3624 d.stat.st_blocks = 0;
3625 #endif
3626
3627 if (d.stat.st_size == 0) return 0;
3628
3629 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3630
3631 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3632 {
3633 if (d_cache)
3634 {
3635 u64 cnt = d_cache->cnt;
3636
3637 u64 keyspace = cnt;
3638
3639 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3640 {
3641 keyspace *= data.kernel_rules_cnt;
3642 }
3643 else if (data.attack_kern == ATTACK_KERN_COMBI)
3644 {
3645 keyspace *= data.combs_cnt;
3646 }
3647
3648 if (data.quiet == 0) log_info ("Cache-hit dictionary stats %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) d.stat.st_size, (unsigned long long int) cnt, (unsigned long long int) keyspace);
3649 if (data.quiet == 0) log_info ("");
3650
3651 hc_signal (sigHandler_default);
3652
3653 return (keyspace);
3654 }
3655 }
3656
3657 time_t now = 0;
3658 time_t prev = 0;
3659
3660 u64 comp = 0;
3661 u64 cnt = 0;
3662 u64 cnt2 = 0;
3663
3664 while (!feof (fd))
3665 {
3666 load_segment (wl_data, fd);
3667
3668 comp += wl_data->cnt;
3669
3670 u32 i = 0;
3671
3672 while (i < wl_data->cnt)
3673 {
3674 u32 len;
3675 u32 off;
3676
3677 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3678
3679 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3680 {
3681 char rule_buf_out[BLOCK_SIZE] = { 0 };
3682
3683 int rule_len_out = -1;
3684
3685 if (len < BLOCK_SIZE)
3686 {
3687 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3688 }
3689
3690 if (rule_len_out < 0)
3691 {
3692 len = PW_MAX1;
3693 }
3694 else
3695 {
3696 len = rule_len_out;
3697 }
3698 }
3699
3700 if (len < PW_MAX1)
3701 {
3702 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3703 {
3704 cnt += data.kernel_rules_cnt;
3705 }
3706 else if (data.attack_kern == ATTACK_KERN_COMBI)
3707 {
3708 cnt += data.combs_cnt;
3709 }
3710
3711 d.cnt++;
3712 }
3713
3714 i += off;
3715
3716 cnt2++;
3717 }
3718
3719 time (&now);
3720
3721 if ((now - prev) == 0) continue;
3722
3723 float percent = (float) comp / (float) d.stat.st_size;
3724
3725 if (data.quiet == 0) log_info_nn ("Generating dictionary stats for %s: %llu bytes (%.2f%%), %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, percent * 100, (unsigned long long int) cnt2, (unsigned long long int) cnt);
3726
3727 time (&prev);
3728 }
3729
3730 if (data.quiet == 0) log_info ("Generated dictionary stats for %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, (unsigned long long int) cnt2, (unsigned long long int) cnt);
3731 if (data.quiet == 0) log_info ("");
3732
3733 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3734
3735 hc_signal (sigHandler_default);
3736
3737 return (cnt);
3738 }
3739
3740 static void *thread_monitor (void *p)
3741 {
3742 uint runtime_check = 0;
3743 uint remove_check = 0;
3744 uint status_check = 0;
3745 uint restore_check = 0;
3746
3747 uint restore_left = data.restore_timer;
3748 uint remove_left = data.remove_timer;
3749 uint status_left = data.status_timer;
3750
3751 #ifdef HAVE_HWMON
3752 uint hwmon_check = 0;
3753
3754 // these variables are mainly used for fan control (AMD only)
3755
3756 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3757
3758 // temperature controller "loopback" values
3759
3760 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3761 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3762
3763 #ifdef HAVE_ADL
3764 int temp_threshold = 1; // degrees celcius
3765
3766 int fan_speed_min = 15; // in percentage
3767 int fan_speed_max = 100;
3768 #endif // HAVE_ADL
3769
3770 time_t last_temp_check_time;
3771 #endif // HAVE_HWMON
3772
3773 uint sleep_time = 1;
3774
3775 if (data.runtime)
3776 {
3777 runtime_check = 1;
3778 }
3779
3780 if (data.restore_timer)
3781 {
3782 restore_check = 1;
3783 }
3784
3785 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3786 {
3787 remove_check = 1;
3788 }
3789
3790 if (data.status == 1)
3791 {
3792 status_check = 1;
3793 }
3794
3795 #ifdef HAVE_HWMON
3796 if (data.gpu_temp_disable == 0)
3797 {
3798 time (&last_temp_check_time);
3799
3800 hwmon_check = 1;
3801 }
3802 #endif
3803
3804 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3805 {
3806 #ifdef HAVE_HWMON
3807 if (hwmon_check == 0)
3808 #endif
3809 return (p);
3810 }
3811
3812 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3813 {
3814 hc_sleep (sleep_time);
3815
3816 if (data.devices_status != STATUS_RUNNING) continue;
3817
3818 #ifdef HAVE_HWMON
3819 if (hwmon_check == 1)
3820 {
3821 hc_thread_mutex_lock (mux_adl);
3822
3823 time_t temp_check_time;
3824
3825 time (&temp_check_time);
3826
3827 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3828
3829 if (Ta == 0) Ta = 1;
3830
3831 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3832 {
3833 hc_device_param_t *device_param = &data.devices_param[device_id];
3834
3835 if (device_param->skipped) continue;
3836
3837 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3838
3839 const int temperature = hm_get_temperature_with_device_id (device_id);
3840
3841 if (temperature > (int) data.gpu_temp_abort)
3842 {
3843 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3844
3845 if (data.devices_status != STATUS_QUIT) myabort ();
3846
3847 break;
3848 }
3849
3850 #ifdef HAVE_ADL
3851 const int gpu_temp_retain = data.gpu_temp_retain;
3852
3853 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3854 {
3855 if (data.hm_device[device_id].fan_supported == 1)
3856 {
3857 int temp_cur = temperature;
3858
3859 int temp_diff_new = gpu_temp_retain - temp_cur;
3860
3861 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3862
3863 // calculate Ta value (time difference in seconds between the last check and this check)
3864
3865 last_temp_check_time = temp_check_time;
3866
3867 float Kp = 1.8;
3868 float Ki = 0.005;
3869 float Kd = 6;
3870
3871 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3872
3873 int fan_diff_required = (int) (Kp * (float)temp_diff_new + Ki * Ta * (float)temp_diff_sum[device_id] + Kd * ((float)(temp_diff_new - temp_diff_old[device_id])) / Ta);
3874
3875 if (abs (fan_diff_required) >= temp_threshold)
3876 {
3877 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3878
3879 int fan_speed_level = fan_speed_cur;
3880
3881 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3882
3883 int fan_speed_new = fan_speed_level - fan_diff_required;
3884
3885 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3886 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3887
3888 if (fan_speed_new != fan_speed_cur)
3889 {
3890 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3891 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3892
3893 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3894 {
3895 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3896
3897 fan_speed_chgd[device_id] = 1;
3898 }
3899
3900 temp_diff_old[device_id] = temp_diff_new;
3901 }
3902 }
3903 }
3904 }
3905 #endif // HAVE_ADL
3906 }
3907
3908 hc_thread_mutex_unlock (mux_adl);
3909 }
3910 #endif // HAVE_HWMON
3911
3912 if (restore_check == 1)
3913 {
3914 restore_left--;
3915
3916 if (restore_left == 0)
3917 {
3918 if (data.restore_disable == 0) cycle_restore ();
3919
3920 restore_left = data.restore_timer;
3921 }
3922 }
3923
3924 if ((runtime_check == 1) && (data.runtime_start > 0))
3925 {
3926 time_t runtime_cur;
3927
3928 time (&runtime_cur);
3929
3930 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3931
3932 if (runtime_left <= 0)
3933 {
3934 if (data.benchmark == 0)
3935 {
3936 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3937 }
3938
3939 if (data.devices_status != STATUS_QUIT) myabort ();
3940 }
3941 }
3942
3943 if (remove_check == 1)
3944 {
3945 remove_left--;
3946
3947 if (remove_left == 0)
3948 {
3949 if (data.digests_saved != data.digests_done)
3950 {
3951 data.digests_saved = data.digests_done;
3952
3953 save_hash ();
3954 }
3955
3956 remove_left = data.remove_timer;
3957 }
3958 }
3959
3960 if (status_check == 1)
3961 {
3962 status_left--;
3963
3964 if (status_left == 0)
3965 {
3966 hc_thread_mutex_lock (mux_display);
3967
3968 if (data.quiet == 0) clear_prompt ();
3969
3970 if (data.quiet == 0) log_info ("");
3971
3972 status_display ();
3973
3974 if (data.quiet == 0) log_info ("");
3975
3976 hc_thread_mutex_unlock (mux_display);
3977
3978 status_left = data.status_timer;
3979 }
3980 }
3981 }
3982
3983 #ifdef HAVE_HWMON
3984 myfree (fan_speed_chgd);
3985
3986 myfree (temp_diff_old);
3987 myfree (temp_diff_sum);
3988 #endif
3989
3990 p = NULL;
3991
3992 return (p);
3993 }
3994
3995 static void *thread_outfile_remove (void *p)
3996 {
3997 // some hash-dependent constants
3998 char *outfile_dir = data.outfile_check_directory;
3999 uint dgst_size = data.dgst_size;
4000 uint isSalted = data.isSalted;
4001 uint esalt_size = data.esalt_size;
4002 uint hash_mode = data.hash_mode;
4003
4004 uint outfile_check_timer = data.outfile_check_timer;
4005
4006 char separator = data.separator;
4007
4008 // some hash-dependent functions
4009 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4010 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4011
4012 // buffers
4013 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4014
4015 hash_buf.digest = mymalloc (dgst_size);
4016
4017 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4018
4019 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4020
4021 uint digest_buf[64] = { 0 };
4022
4023 outfile_data_t *out_info = NULL;
4024
4025 char **out_files = NULL;
4026
4027 time_t folder_mtime = 0;
4028
4029 int out_cnt = 0;
4030
4031 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4032
4033 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4034 {
4035 hc_sleep (1);
4036
4037 if (data.devices_status != STATUS_RUNNING) continue;
4038
4039 check_left--;
4040
4041 if (check_left == 0)
4042 {
4043 struct stat outfile_check_stat;
4044
4045 if (stat (outfile_dir, &outfile_check_stat) == 0)
4046 {
4047 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4048
4049 if (is_dir == 1)
4050 {
4051 if (outfile_check_stat.st_mtime > folder_mtime)
4052 {
4053 char **out_files_new = scan_directory (outfile_dir);
4054
4055 int out_cnt_new = count_dictionaries (out_files_new);
4056
4057 outfile_data_t *out_info_new = NULL;
4058
4059 if (out_cnt_new > 0)
4060 {
4061 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4062
4063 for (int i = 0; i < out_cnt_new; i++)
4064 {
4065 out_info_new[i].file_name = out_files_new[i];
4066
4067 // check if there are files that we have seen/checked before (and not changed)
4068
4069 for (int j = 0; j < out_cnt; j++)
4070 {
4071 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4072 {
4073 struct stat outfile_stat;
4074
4075 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4076 {
4077 if (outfile_stat.st_ctime == out_info[j].ctime)
4078 {
4079 out_info_new[i].ctime = out_info[j].ctime;
4080 out_info_new[i].seek = out_info[j].seek;
4081 }
4082 }
4083 }
4084 }
4085 }
4086 }
4087
4088 local_free (out_info);
4089 local_free (out_files);
4090
4091 out_files = out_files_new;
4092 out_cnt = out_cnt_new;
4093 out_info = out_info_new;
4094
4095 folder_mtime = outfile_check_stat.st_mtime;
4096 }
4097
4098 for (int j = 0; j < out_cnt; j++)
4099 {
4100 FILE *fp = fopen (out_info[j].file_name, "rb");
4101
4102 if (fp != NULL)
4103 {
4104 //hc_thread_mutex_lock (mux_display);
4105
4106 #ifdef _POSIX
4107 struct stat outfile_stat;
4108
4109 fstat (fileno (fp), &outfile_stat);
4110 #endif
4111
4112 #ifdef _WIN
4113 struct stat64 outfile_stat;
4114
4115 _fstat64 (fileno (fp), &outfile_stat);
4116 #endif
4117
4118 if (outfile_stat.st_ctime > out_info[j].ctime)
4119 {
4120 out_info[j].ctime = outfile_stat.st_ctime;
4121 out_info[j].seek = 0;
4122 }
4123
4124 fseek (fp, out_info[j].seek, SEEK_SET);
4125
4126 while (!feof (fp))
4127 {
4128 char line_buf[BUFSIZ] = { 0 };
4129
4130 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
4131
4132 if (ptr == NULL) break;
4133
4134 int line_len = strlen (line_buf);
4135
4136 if (line_len <= 0) continue;
4137
4138 int iter = MAX_CUT_TRIES;
4139
4140 for (uint i = line_len - 1; i && iter; i--, line_len--)
4141 {
4142 if (line_buf[i] != separator) continue;
4143
4144 int parser_status = PARSER_OK;
4145
4146 if ((hash_mode != 2500) && (hash_mode != 6800))
4147 {
4148 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4149 }
4150
4151 uint found = 0;
4152
4153 if (parser_status == PARSER_OK)
4154 {
4155 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4156 {
4157 if (data.salts_shown[salt_pos] == 1) continue;
4158
4159 salt_t *salt_buf = &data.salts_buf[salt_pos];
4160
4161 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4162 {
4163 uint idx = salt_buf->digests_offset + digest_pos;
4164
4165 if (data.digests_shown[idx] == 1) continue;
4166
4167 uint cracked = 0;
4168
4169 if (hash_mode == 6800)
4170 {
4171 if (i == salt_buf->salt_len)
4172 {
4173 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4174 }
4175 }
4176 else if (hash_mode == 2500)
4177 {
4178 // BSSID : MAC1 : MAC2 (:plain)
4179 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4180 {
4181 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4182
4183 if (!cracked) continue;
4184
4185 // now compare MAC1 and MAC2 too, since we have this additional info
4186 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4187 char *mac2_pos = mac1_pos + 12 + 1;
4188
4189 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4190 wpa_t *wpa = &wpas[salt_pos];
4191
4192 uint pke[25] = { 0 };
4193
4194 char *pke_ptr = (char *) pke;
4195
4196 for (uint i = 0; i < 25; i++)
4197 {
4198 pke[i] = byte_swap_32 (wpa->pke[i]);
4199 }
4200
4201 u8 mac1[6] = { 0 };
4202 u8 mac2[6] = { 0 };
4203
4204 memcpy (mac1, pke_ptr + 23, 6);
4205 memcpy (mac2, pke_ptr + 29, 6);
4206
4207 // compare hex string(s) vs binary MAC address(es)
4208
4209 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4210 {
4211 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4212 {
4213 cracked = 0;
4214 break;
4215 }
4216 }
4217
4218 // early skip ;)
4219 if (!cracked) continue;
4220
4221 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4222 {
4223 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4224 {
4225 cracked = 0;
4226 break;
4227 }
4228 }
4229 }
4230 }
4231 else
4232 {
4233 char *digests_buf_ptr = (char *) data.digests_buf;
4234
4235 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4236
4237 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4238 }
4239
4240 if (cracked == 1)
4241 {
4242 found = 1;
4243
4244 data.digests_shown[idx] = 1;
4245
4246 data.digests_done++;
4247
4248 salt_buf->digests_done++;
4249
4250 if (salt_buf->digests_done == salt_buf->digests_cnt)
4251 {
4252 data.salts_shown[salt_pos] = 1;
4253
4254 data.salts_done++;
4255
4256 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4257 }
4258 }
4259 }
4260
4261 if (data.devices_status == STATUS_CRACKED) break;
4262 }
4263 }
4264
4265 if (found) break;
4266
4267 if (data.devices_status == STATUS_CRACKED) break;
4268
4269 iter--;
4270 }
4271
4272 if (data.devices_status == STATUS_CRACKED) break;
4273 }
4274
4275 out_info[j].seek = ftell (fp);
4276
4277 //hc_thread_mutex_unlock (mux_display);
4278
4279 fclose (fp);
4280 }
4281 }
4282 }
4283 }
4284
4285 check_left = outfile_check_timer;
4286 }
4287 }
4288
4289 if (esalt_size) local_free (hash_buf.esalt);
4290
4291 if (isSalted) local_free (hash_buf.salt);
4292
4293 local_free (hash_buf.digest);
4294
4295 local_free (out_info);
4296
4297 local_free (out_files);
4298
4299 p = NULL;
4300
4301 return (p);
4302 }
4303
4304 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4305 {
4306 if (device_param->pws_cnt < device_param->kernel_power)
4307 {
4308 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4309
4310 memcpy (pw->i, pw_buf, pw_len);
4311
4312 memset (pw->i + pw_len, 0, sizeof (pw->i) - pw_len);
4313
4314 pw->pw_len = pw_len;
4315
4316 device_param->pws_cnt++;
4317 }
4318 else
4319 {
4320 fprintf (stderr, "BUG pw_add()!!\n");
4321
4322 return;
4323 }
4324 }
4325
4326 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4327 {
4328 hc_thread_mutex_lock (mux_dispatcher);
4329
4330 const u64 words_cur = data.words_cur;
4331 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4332
4333 device_param->words_off = words_cur;
4334
4335 const u64 words_left = words_base - words_cur;
4336
4337 if (allow_div)
4338 {
4339 if (data.kernel_power_all > words_left)
4340 {
4341 if (data.kernel_power_div == 0)
4342 {
4343 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4344 }
4345 }
4346
4347 if (data.kernel_power_div)
4348 {
4349 if (device_param->kernel_power == device_param->kernel_power_user)
4350 {
4351 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4352
4353 if (kernel_power_new < device_param->kernel_power)
4354 {
4355 device_param->kernel_power = kernel_power_new;
4356 }
4357 }
4358 }
4359 }
4360
4361 const uint kernel_power = device_param->kernel_power;
4362
4363 uint work = MIN (words_left, kernel_power);
4364
4365 work = MIN (work, max);
4366
4367 data.words_cur += work;
4368
4369 hc_thread_mutex_unlock (mux_dispatcher);
4370
4371 return work;
4372 }
4373
4374 static void *thread_calc_stdin (void *p)
4375 {
4376 hc_device_param_t *device_param = (hc_device_param_t *) p;
4377
4378 if (device_param->skipped) return NULL;
4379
4380 autotune (device_param);
4381
4382 const uint attack_kern = data.attack_kern;
4383
4384 const uint kernel_power = device_param->kernel_power;
4385
4386 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4387 {
4388 hc_thread_mutex_lock (mux_dispatcher);
4389
4390 if (feof (stdin) != 0)
4391 {
4392 hc_thread_mutex_unlock (mux_dispatcher);
4393
4394 break;
4395 }
4396
4397 uint words_cur = 0;
4398
4399 while (words_cur < kernel_power)
4400 {
4401 char buf[BUFSIZ] = { 0 };
4402
4403 char *line_buf = fgets (buf, sizeof (buf), stdin);
4404
4405 if (line_buf == NULL) break;
4406
4407 uint line_len = in_superchop (line_buf);
4408
4409 line_len = convert_from_hex (line_buf, line_len);
4410
4411 // post-process rule engine
4412
4413 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4414 {
4415 char rule_buf_out[BLOCK_SIZE] = { 0 };
4416
4417 int rule_len_out = -1;
4418
4419 if (line_len < BLOCK_SIZE)
4420 {
4421 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4422 }
4423
4424 if (rule_len_out < 0) continue;
4425
4426 line_buf = rule_buf_out;
4427 line_len = rule_len_out;
4428 }
4429
4430 if (line_len > PW_MAX)
4431 {
4432 continue;
4433 }
4434
4435 if (attack_kern == ATTACK_KERN_STRAIGHT)
4436 {
4437 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4438 {
4439 hc_thread_mutex_lock (mux_counter);
4440
4441 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4442 {
4443 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4444 }
4445
4446 hc_thread_mutex_unlock (mux_counter);
4447
4448 continue;
4449 }
4450 }
4451 else if (attack_kern == ATTACK_KERN_COMBI)
4452 {
4453 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4454 // since we still need to combine the plains
4455
4456 if (line_len > data.pw_max)
4457 {
4458 hc_thread_mutex_lock (mux_counter);
4459
4460 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4461 {
4462 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4463 }
4464
4465 hc_thread_mutex_unlock (mux_counter);
4466
4467 continue;
4468 }
4469 }
4470
4471 pw_add (device_param, (u8 *) line_buf, line_len);
4472
4473 words_cur++;
4474
4475 if (data.devices_status == STATUS_CRACKED) break;
4476 if (data.devices_status == STATUS_ABORTED) break;
4477 if (data.devices_status == STATUS_QUIT) break;
4478 if (data.devices_status == STATUS_BYPASS) break;
4479 }
4480
4481 hc_thread_mutex_unlock (mux_dispatcher);
4482
4483 if (data.devices_status == STATUS_CRACKED) break;
4484 if (data.devices_status == STATUS_ABORTED) break;
4485 if (data.devices_status == STATUS_QUIT) break;
4486 if (data.devices_status == STATUS_BYPASS) break;
4487
4488 // flush
4489
4490 const uint pws_cnt = device_param->pws_cnt;
4491
4492 if (pws_cnt)
4493 {
4494 run_copy (device_param, pws_cnt);
4495
4496 run_cracker (device_param, pws_cnt);
4497
4498 device_param->pws_cnt = 0;
4499
4500 if (attack_kern == ATTACK_KERN_STRAIGHT)
4501 {
4502 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4503 }
4504 else if (attack_kern == ATTACK_KERN_COMBI)
4505 {
4506 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4507 }
4508 }
4509 }
4510
4511 device_param->kernel_accel = 0;
4512 device_param->kernel_loops = 0;
4513
4514 return NULL;
4515 }
4516
4517 static void *thread_calc (void *p)
4518 {
4519 hc_device_param_t *device_param = (hc_device_param_t *) p;
4520
4521 if (device_param->skipped) return NULL;
4522
4523 autotune (device_param);
4524
4525 const uint attack_mode = data.attack_mode;
4526 const uint attack_kern = data.attack_kern;
4527
4528 if (attack_mode == ATTACK_MODE_BF)
4529 {
4530 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4531 {
4532 const uint work = get_work (device_param, -1, true);
4533
4534 if (work == 0) break;
4535
4536 const u64 words_off = device_param->words_off;
4537 const u64 words_fin = words_off + work;
4538
4539 const uint pws_cnt = work;
4540
4541 device_param->pws_cnt = pws_cnt;
4542
4543 if (pws_cnt)
4544 {
4545 run_copy (device_param, pws_cnt);
4546
4547 run_cracker (device_param, pws_cnt);
4548
4549 device_param->pws_cnt = 0;
4550
4551 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4552 }
4553
4554 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4555
4556 if (data.devices_status == STATUS_CRACKED) break;
4557 if (data.devices_status == STATUS_ABORTED) break;
4558 if (data.devices_status == STATUS_QUIT) break;
4559 if (data.devices_status == STATUS_BYPASS) break;
4560
4561 if (data.benchmark == 1) break;
4562
4563 device_param->words_done = words_fin;
4564 }
4565 }
4566 else
4567 {
4568 const uint segment_size = data.segment_size;
4569
4570 char *dictfile = data.dictfile;
4571
4572 if (attack_mode == ATTACK_MODE_COMBI)
4573 {
4574 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4575 {
4576 dictfile = data.dictfile2;
4577 }
4578 }
4579
4580 FILE *fd = fopen (dictfile, "rb");
4581
4582 if (fd == NULL)
4583 {
4584 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4585
4586 return NULL;
4587 }
4588
4589 if (attack_mode == ATTACK_MODE_COMBI)
4590 {
4591 const uint combs_mode = data.combs_mode;
4592
4593 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4594 {
4595 const char *dictfilec = data.dictfile2;
4596
4597 FILE *combs_fp = fopen (dictfilec, "rb");
4598
4599 if (combs_fp == NULL)
4600 {
4601 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4602
4603 fclose (fd);
4604
4605 return NULL;
4606 }
4607
4608 device_param->combs_fp = combs_fp;
4609 }
4610 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4611 {
4612 const char *dictfilec = data.dictfile;
4613
4614 FILE *combs_fp = fopen (dictfilec, "rb");
4615
4616 if (combs_fp == NULL)
4617 {
4618 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4619
4620 fclose (fd);
4621
4622 return NULL;
4623 }
4624
4625 device_param->combs_fp = combs_fp;
4626 }
4627 }
4628
4629 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4630
4631 wl_data->buf = (char *) mymalloc (segment_size);
4632 wl_data->avail = segment_size;
4633 wl_data->incr = segment_size;
4634 wl_data->cnt = 0;
4635 wl_data->pos = 0;
4636
4637 u64 words_cur = 0;
4638
4639 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4640 {
4641 u64 words_off = 0;
4642 u64 words_fin = 0;
4643
4644 bool allow_div = true;
4645
4646 u64 max = -1;
4647
4648 while (max)
4649 {
4650 const uint work = get_work (device_param, max, allow_div);
4651
4652 allow_div = false;
4653
4654 if (work == 0) break;
4655
4656 words_off = device_param->words_off;
4657 words_fin = words_off + work;
4658
4659 char *line_buf;
4660 uint line_len;
4661
4662 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4663
4664 max = 0;
4665
4666 for ( ; words_cur < words_fin; words_cur++)
4667 {
4668 get_next_word (wl_data, fd, &line_buf, &line_len);
4669
4670 line_len = convert_from_hex (line_buf, line_len);
4671
4672 // post-process rule engine
4673
4674 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4675 {
4676 char rule_buf_out[BLOCK_SIZE] = { 0 };
4677
4678 int rule_len_out = -1;
4679
4680 if (line_len < BLOCK_SIZE)
4681 {
4682 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4683 }
4684
4685 if (rule_len_out < 0) continue;
4686
4687 line_buf = rule_buf_out;
4688 line_len = rule_len_out;
4689 }
4690
4691 if (attack_kern == ATTACK_KERN_STRAIGHT)
4692 {
4693 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4694 {
4695 max++;
4696
4697 hc_thread_mutex_lock (mux_counter);
4698
4699 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4700 {
4701 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4702 }
4703
4704 hc_thread_mutex_unlock (mux_counter);
4705
4706 continue;
4707 }
4708 }
4709 else if (attack_kern == ATTACK_KERN_COMBI)
4710 {
4711 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4712 // since we still need to combine the plains
4713
4714 if (line_len > data.pw_max)
4715 {
4716 max++;
4717
4718 hc_thread_mutex_lock (mux_counter);
4719
4720 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4721 {
4722 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4723 }
4724
4725 hc_thread_mutex_unlock (mux_counter);
4726
4727 continue;
4728 }
4729 }
4730
4731 pw_add (device_param, (u8 *) line_buf, line_len);
4732
4733 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4734
4735 if (data.devices_status == STATUS_CRACKED) break;
4736 if (data.devices_status == STATUS_ABORTED) break;
4737 if (data.devices_status == STATUS_QUIT) break;
4738 if (data.devices_status == STATUS_BYPASS) break;
4739 }
4740
4741 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4742
4743 if (data.devices_status == STATUS_CRACKED) break;
4744 if (data.devices_status == STATUS_ABORTED) break;
4745 if (data.devices_status == STATUS_QUIT) break;
4746 if (data.devices_status == STATUS_BYPASS) break;
4747 }
4748
4749 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4750
4751 if (data.devices_status == STATUS_CRACKED) break;
4752 if (data.devices_status == STATUS_ABORTED) break;
4753 if (data.devices_status == STATUS_QUIT) break;
4754 if (data.devices_status == STATUS_BYPASS) break;
4755
4756 //
4757 // flush
4758 //
4759
4760 const uint pws_cnt = device_param->pws_cnt;
4761
4762 if (pws_cnt)
4763 {
4764 run_copy (device_param, pws_cnt);
4765
4766 run_cracker (device_param, pws_cnt);
4767
4768 device_param->pws_cnt = 0;
4769
4770 if (attack_kern == ATTACK_KERN_STRAIGHT)
4771 {
4772 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4773 }
4774 else if (attack_kern == ATTACK_KERN_COMBI)
4775 {
4776 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4777 }
4778 }
4779
4780 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4781
4782 if (data.devices_status == STATUS_CRACKED) break;
4783 if (data.devices_status == STATUS_ABORTED) break;
4784 if (data.devices_status == STATUS_QUIT) break;
4785 if (data.devices_status == STATUS_BYPASS) break;
4786
4787 if (words_fin == 0) break;
4788
4789 device_param->words_done = words_fin;
4790 }
4791
4792 if (attack_mode == ATTACK_MODE_COMBI)
4793 {
4794 fclose (device_param->combs_fp);
4795 }
4796
4797 free (wl_data->buf);
4798 free (wl_data);
4799
4800 fclose (fd);
4801 }
4802
4803 device_param->kernel_accel = 0;
4804 device_param->kernel_loops = 0;
4805
4806 return NULL;
4807 }
4808
4809 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4810 {
4811 if (!device_param)
4812 {
4813 log_error ("ERROR: %s : Invalid argument", __func__);
4814
4815 exit (-1);
4816 }
4817
4818 salt_t *salt_buf = &data.salts_buf[salt_pos];
4819
4820 device_param->kernel_params_buf32[24] = salt_pos;
4821 device_param->kernel_params_buf32[27] = 1;
4822 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4823 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4824 device_param->kernel_params_buf32[30] = 0;
4825 device_param->kernel_params_buf32[31] = 1;
4826
4827 char *dictfile_old = data.dictfile;
4828
4829 const char *weak_hash_check = "weak-hash-check";
4830
4831 data.dictfile = (char *) weak_hash_check;
4832
4833 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4834
4835 data.kernel_rules_buf[0].cmds[0] = 0;
4836
4837 /**
4838 * run the kernel
4839 */
4840
4841 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4842 {
4843 run_kernel (KERN_RUN_1, device_param, 1, false);
4844 }
4845 else
4846 {
4847 run_kernel (KERN_RUN_1, device_param, 1, false);
4848
4849 uint loop_step = 16;
4850
4851 const uint iter = salt_buf->salt_iter;
4852
4853 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4854 {
4855 uint loop_left = iter - loop_pos;
4856
4857 loop_left = MIN (loop_left, loop_step);
4858
4859 device_param->kernel_params_buf32[25] = loop_pos;
4860 device_param->kernel_params_buf32[26] = loop_left;
4861
4862 run_kernel (KERN_RUN_2, device_param, 1, false);
4863 }
4864
4865 run_kernel (KERN_RUN_3, device_param, 1, false);
4866 }
4867
4868 /**
4869 * result
4870 */
4871
4872 check_cracked (device_param, salt_pos);
4873
4874 /**
4875 * cleanup
4876 */
4877
4878 device_param->kernel_params_buf32[24] = 0;
4879 device_param->kernel_params_buf32[25] = 0;
4880 device_param->kernel_params_buf32[26] = 0;
4881 device_param->kernel_params_buf32[27] = 0;
4882 device_param->kernel_params_buf32[28] = 0;
4883 device_param->kernel_params_buf32[29] = 0;
4884 device_param->kernel_params_buf32[30] = 0;
4885 device_param->kernel_params_buf32[31] = 0;
4886
4887 data.dictfile = dictfile_old;
4888
4889 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4890 }
4891
4892 // hlfmt hashcat
4893
4894 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4895 {
4896 if (data.username == 0)
4897 {
4898 *hashbuf_pos = line_buf;
4899 *hashbuf_len = line_len;
4900 }
4901 else
4902 {
4903 char *pos = line_buf;
4904 int len = line_len;
4905
4906 for (int i = 0; i < line_len; i++, pos++, len--)
4907 {
4908 if (line_buf[i] == data.separator)
4909 {
4910 pos++;
4911
4912 len--;
4913
4914 break;
4915 }
4916 }
4917
4918 *hashbuf_pos = pos;
4919 *hashbuf_len = len;
4920 }
4921 }
4922
4923 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4924 {
4925 char *pos = NULL;
4926 int len = 0;
4927
4928 int sep_cnt = 0;
4929
4930 for (int i = 0; i < line_len; i++)
4931 {
4932 if (line_buf[i] == data.separator)
4933 {
4934 sep_cnt++;
4935
4936 continue;
4937 }
4938
4939 if (sep_cnt == 0)
4940 {
4941 if (pos == NULL) pos = line_buf + i;
4942
4943 len++;
4944 }
4945 }
4946
4947 *userbuf_pos = pos;
4948 *userbuf_len = len;
4949 }
4950
4951 // hlfmt pwdump
4952
4953 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4954 {
4955 int sep_cnt = 0;
4956
4957 int sep2_len = 0;
4958 int sep3_len = 0;
4959
4960 for (int i = 0; i < line_len; i++)
4961 {
4962 if (line_buf[i] == ':')
4963 {
4964 sep_cnt++;
4965
4966 continue;
4967 }
4968
4969 if (sep_cnt == 2) sep2_len++;
4970 if (sep_cnt == 3) sep3_len++;
4971 }
4972
4973 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4974
4975 return 0;
4976 }
4977
4978 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4979 {
4980 char *pos = NULL;
4981 int len = 0;
4982
4983 int sep_cnt = 0;
4984
4985 for (int i = 0; i < line_len; i++)
4986 {
4987 if (line_buf[i] == ':')
4988 {
4989 sep_cnt++;
4990
4991 continue;
4992 }
4993
4994 if (data.hash_mode == 1000)
4995 {
4996 if (sep_cnt == 3)
4997 {
4998 if (pos == NULL) pos = line_buf + i;
4999
5000 len++;
5001 }
5002 }
5003 else if (data.hash_mode == 3000)
5004 {
5005 if (sep_cnt == 2)
5006 {
5007 if (pos == NULL) pos = line_buf + i;
5008
5009 len++;
5010 }
5011 }
5012 }
5013
5014 *hashbuf_pos = pos;
5015 *hashbuf_len = len;
5016 }
5017
5018 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5019 {
5020 char *pos = NULL;
5021 int len = 0;
5022
5023 int sep_cnt = 0;
5024
5025 for (int i = 0; i < line_len; i++)
5026 {
5027 if (line_buf[i] == ':')
5028 {
5029 sep_cnt++;
5030
5031 continue;
5032 }
5033
5034 if (sep_cnt == 0)
5035 {
5036 if (pos == NULL) pos = line_buf + i;
5037
5038 len++;
5039 }
5040 }
5041
5042 *userbuf_pos = pos;
5043 *userbuf_len = len;
5044 }
5045
5046 // hlfmt passwd
5047
5048 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
5049 {
5050 int sep_cnt = 0;
5051
5052 char sep5_first = 0;
5053 char sep6_first = 0;
5054
5055 for (int i = 0; i < line_len; i++)
5056 {
5057 if (line_buf[i] == ':')
5058 {
5059 sep_cnt++;
5060
5061 continue;
5062 }
5063
5064 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5065 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5066 }
5067
5068 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5069
5070 return 0;
5071 }
5072
5073 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5074 {
5075 char *pos = NULL;
5076 int len = 0;
5077
5078 int sep_cnt = 0;
5079
5080 for (int i = 0; i < line_len; i++)
5081 {
5082 if (line_buf[i] == ':')
5083 {
5084 sep_cnt++;
5085
5086 continue;
5087 }
5088
5089 if (sep_cnt == 1)
5090 {
5091 if (pos == NULL) pos = line_buf + i;
5092
5093 len++;
5094 }
5095 }
5096
5097 *hashbuf_pos = pos;
5098 *hashbuf_len = len;
5099 }
5100
5101 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5102 {
5103 char *pos = NULL;
5104 int len = 0;
5105
5106 int sep_cnt = 0;
5107
5108 for (int i = 0; i < line_len; i++)
5109 {
5110 if (line_buf[i] == ':')
5111 {
5112 sep_cnt++;
5113
5114 continue;
5115 }
5116
5117 if (sep_cnt == 0)
5118 {
5119 if (pos == NULL) pos = line_buf + i;
5120
5121 len++;
5122 }
5123 }
5124
5125 *userbuf_pos = pos;
5126 *userbuf_len = len;
5127 }
5128
5129 // hlfmt shadow
5130
5131 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
5132 {
5133 int sep_cnt = 0;
5134
5135 for (int i = 0; i < line_len; i++)
5136 {
5137 if (line_buf[i] == ':') sep_cnt++;
5138 }
5139
5140 if (sep_cnt == 8) return 1;
5141
5142 return 0;
5143 }
5144
5145 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5146 {
5147 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5148 }
5149
5150 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5151 {
5152 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5153 }
5154
5155 // hlfmt main
5156
5157 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5158 {
5159 switch (hashfile_format)
5160 {
5161 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5162 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5163 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5164 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5165 }
5166 }
5167
5168 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5169 {
5170 switch (hashfile_format)
5171 {
5172 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5173 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5174 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5175 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5176 }
5177 }
5178
5179 static uint hlfmt_detect (FILE *fp, uint max_check)
5180 {
5181 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5182
5183 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5184 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5185
5186 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5187
5188 uint num_check = 0;
5189
5190 while (!feof (fp))
5191 {
5192 char line_buf[BUFSIZ] = { 0 };
5193
5194 int line_len = fgetl (fp, line_buf);
5195
5196 if (line_len == 0) continue;
5197
5198 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5199 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5200 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5201
5202 if (num_check == max_check) break;
5203
5204 num_check++;
5205 }
5206
5207 uint hashlist_format = HLFMT_HASHCAT;
5208
5209 for (int i = 1; i < HLFMTS_CNT; i++)
5210 {
5211 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5212
5213 hashlist_format = i;
5214 }
5215
5216 free (formats_cnt);
5217
5218 return hashlist_format;
5219 }
5220
5221 /**
5222 * some further helper function
5223 */
5224
5225 // wrapper around mymalloc for ADL
5226
5227 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5228 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5229 {
5230 return mymalloc (iSize);
5231 }
5232 #endif
5233
5234 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)
5235 {
5236 u64 collisions = 0;
5237
5238 const uint dgst_pos0 = data.dgst_pos0;
5239 const uint dgst_pos1 = data.dgst_pos1;
5240 const uint dgst_pos2 = data.dgst_pos2;
5241 const uint dgst_pos3 = data.dgst_pos3;
5242
5243 memset (bitmap_a, 0, bitmap_size);
5244 memset (bitmap_b, 0, bitmap_size);
5245 memset (bitmap_c, 0, bitmap_size);
5246 memset (bitmap_d, 0, bitmap_size);
5247
5248 for (uint i = 0; i < digests_cnt; i++)
5249 {
5250 uint *digest_ptr = (uint *) digests_buf_ptr;
5251
5252 digests_buf_ptr += dgst_size;
5253
5254 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5255 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5256 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5257 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5258
5259 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5260 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5261 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5262 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5263
5264 if (bitmap_a[idx0] & val0) collisions++;
5265 if (bitmap_b[idx1] & val1) collisions++;
5266 if (bitmap_c[idx2] & val2) collisions++;
5267 if (bitmap_d[idx3] & val3) collisions++;
5268
5269 bitmap_a[idx0] |= val0;
5270 bitmap_b[idx1] |= val1;
5271 bitmap_c[idx2] |= val2;
5272 bitmap_d[idx3] |= val3;
5273
5274 if (collisions >= collisions_max) return 0x7fffffff;
5275 }
5276
5277 return collisions;
5278 }
5279
5280 /**
5281 * main
5282 */
5283
5284 int main (int argc, char **argv)
5285 {
5286 /**
5287 * To help users a bit
5288 */
5289
5290 char *compute = getenv ("COMPUTE");
5291
5292 if (compute)
5293 {
5294 static char display[100];
5295
5296 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5297
5298 putenv (display);
5299 }
5300 else
5301 {
5302 if (getenv ("DISPLAY") == NULL)
5303 putenv ((char *) "DISPLAY=:0");
5304 }
5305
5306 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5307 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5308
5309 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5310 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5311
5312 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5313 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5314
5315 /**
5316 * Real init
5317 */
5318
5319 memset (&data, 0, sizeof (hc_global_data_t));
5320
5321 time_t proc_start;
5322
5323 time (&proc_start);
5324
5325 data.proc_start = proc_start;
5326
5327 int myargc = argc;
5328 char **myargv = argv;
5329
5330 hc_thread_mutex_init (mux_dispatcher);
5331 hc_thread_mutex_init (mux_counter);
5332 hc_thread_mutex_init (mux_display);
5333 hc_thread_mutex_init (mux_adl);
5334
5335 /**
5336 * commandline parameters
5337 */
5338
5339 uint usage = USAGE;
5340 uint version = VERSION;
5341 uint quiet = QUIET;
5342 uint benchmark = BENCHMARK;
5343 uint benchmark_repeats = BENCHMARK_REPEATS;
5344 uint show = SHOW;
5345 uint left = LEFT;
5346 uint username = USERNAME;
5347 uint remove = REMOVE;
5348 uint remove_timer = REMOVE_TIMER;
5349 u64 skip = SKIP;
5350 u64 limit = LIMIT;
5351 uint keyspace = KEYSPACE;
5352 uint potfile_disable = POTFILE_DISABLE;
5353 uint debug_mode = DEBUG_MODE;
5354 char *debug_file = NULL;
5355 char *induction_dir = NULL;
5356 char *outfile_check_dir = NULL;
5357 uint force = FORCE;
5358 uint runtime = RUNTIME;
5359 uint hash_mode = HASH_MODE;
5360 uint attack_mode = ATTACK_MODE;
5361 uint markov_disable = MARKOV_DISABLE;
5362 uint markov_classic = MARKOV_CLASSIC;
5363 uint markov_threshold = MARKOV_THRESHOLD;
5364 char *markov_hcstat = NULL;
5365 char *outfile = NULL;
5366 uint outfile_format = OUTFILE_FORMAT;
5367 uint outfile_autohex = OUTFILE_AUTOHEX;
5368 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5369 uint restore = RESTORE;
5370 uint restore_timer = RESTORE_TIMER;
5371 uint restore_disable = RESTORE_DISABLE;
5372 uint status = STATUS;
5373 uint status_timer = STATUS_TIMER;
5374 uint status_automat = STATUS_AUTOMAT;
5375 uint loopback = LOOPBACK;
5376 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5377 char *session = NULL;
5378 uint hex_charset = HEX_CHARSET;
5379 uint hex_salt = HEX_SALT;
5380 uint hex_wordlist = HEX_WORDLIST;
5381 uint rp_gen = RP_GEN;
5382 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5383 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5384 uint rp_gen_seed = RP_GEN_SEED;
5385 char *rule_buf_l = (char *) RULE_BUF_L;
5386 char *rule_buf_r = (char *) RULE_BUF_R;
5387 uint increment = INCREMENT;
5388 uint increment_min = INCREMENT_MIN;
5389 uint increment_max = INCREMENT_MAX;
5390 char *cpu_affinity = NULL;
5391 OCL_PTR *ocl = NULL;
5392 char *opencl_devices = NULL;
5393 char *opencl_platforms = NULL;
5394 char *opencl_device_types = NULL;
5395 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5396 char *truecrypt_keyfiles = NULL;
5397 uint workload_profile = WORKLOAD_PROFILE;
5398 uint kernel_accel = KERNEL_ACCEL;
5399 uint kernel_loops = KERNEL_LOOPS;
5400 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5401 #ifdef HAVE_HWMON
5402 uint gpu_temp_abort = GPU_TEMP_ABORT;
5403 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5404 #ifdef HAVE_ADL
5405 uint powertune_enable = POWERTUNE_ENABLE;
5406 #endif
5407 #endif
5408 uint logfile_disable = LOGFILE_DISABLE;
5409 uint segment_size = SEGMENT_SIZE;
5410 uint scrypt_tmto = SCRYPT_TMTO;
5411 char separator = SEPARATOR;
5412 uint bitmap_min = BITMAP_MIN;
5413 uint bitmap_max = BITMAP_MAX;
5414 char *custom_charset_1 = NULL;
5415 char *custom_charset_2 = NULL;
5416 char *custom_charset_3 = NULL;
5417 char *custom_charset_4 = NULL;
5418
5419 #define IDX_HELP 'h'
5420 #define IDX_VERSION 'V'
5421 #define IDX_VERSION_LOWER 'v'
5422 #define IDX_QUIET 0xff02
5423 #define IDX_SHOW 0xff03
5424 #define IDX_LEFT 0xff04
5425 #define IDX_REMOVE 0xff05
5426 #define IDX_REMOVE_TIMER 0xff37
5427 #define IDX_SKIP 's'
5428 #define IDX_LIMIT 'l'
5429 #define IDX_KEYSPACE 0xff35
5430 #define IDX_POTFILE_DISABLE 0xff06
5431 #define IDX_DEBUG_MODE 0xff43
5432 #define IDX_DEBUG_FILE 0xff44
5433 #define IDX_INDUCTION_DIR 0xff46
5434 #define IDX_OUTFILE_CHECK_DIR 0xff47
5435 #define IDX_USERNAME 0xff07
5436 #define IDX_FORCE 0xff08
5437 #define IDX_RUNTIME 0xff09
5438 #define IDX_BENCHMARK 'b'
5439 #define IDX_BENCHMARK_REPEATS 0xff78
5440 #define IDX_HASH_MODE 'm'
5441 #define IDX_ATTACK_MODE 'a'
5442 #define IDX_RP_FILE 'r'
5443 #define IDX_RP_GEN 'g'
5444 #define IDX_RP_GEN_FUNC_MIN 0xff10
5445 #define IDX_RP_GEN_FUNC_MAX 0xff11
5446 #define IDX_RP_GEN_SEED 0xff34
5447 #define IDX_RULE_BUF_L 'j'
5448 #define IDX_RULE_BUF_R 'k'
5449 #define IDX_INCREMENT 'i'
5450 #define IDX_INCREMENT_MIN 0xff12
5451 #define IDX_INCREMENT_MAX 0xff13
5452 #define IDX_OUTFILE 'o'
5453 #define IDX_OUTFILE_FORMAT 0xff14
5454 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5455 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5456 #define IDX_RESTORE 0xff15
5457 #define IDX_RESTORE_DISABLE 0xff27
5458 #define IDX_STATUS 0xff17
5459 #define IDX_STATUS_TIMER 0xff18
5460 #define IDX_STATUS_AUTOMAT 0xff50
5461 #define IDX_LOOPBACK 0xff38
5462 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5463 #define IDX_SESSION 0xff19
5464 #define IDX_HEX_CHARSET 0xff20
5465 #define IDX_HEX_SALT 0xff21
5466 #define IDX_HEX_WORDLIST 0xff40
5467 #define IDX_MARKOV_DISABLE 0xff22
5468 #define IDX_MARKOV_CLASSIC 0xff23
5469 #define IDX_MARKOV_THRESHOLD 't'
5470 #define IDX_MARKOV_HCSTAT 0xff24
5471 #define IDX_CPU_AFFINITY 0xff25
5472 #define IDX_OPENCL_DEVICES 'd'
5473 #define IDX_OPENCL_PLATFORMS 0xff72
5474 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5475 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5476 #define IDX_WORKLOAD_PROFILE 'w'
5477 #define IDX_KERNEL_ACCEL 'n'
5478 #define IDX_KERNEL_LOOPS 'u'
5479 #define IDX_GPU_TEMP_DISABLE 0xff29
5480 #define IDX_GPU_TEMP_ABORT 0xff30
5481 #define IDX_GPU_TEMP_RETAIN 0xff31
5482 #define IDX_POWERTUNE_ENABLE 0xff41
5483 #define IDX_LOGFILE_DISABLE 0xff51
5484 #define IDX_TRUECRYPT_KEYFILES 0xff52
5485 #define IDX_SCRYPT_TMTO 0xff61
5486 #define IDX_SEGMENT_SIZE 'c'
5487 #define IDX_SEPARATOR 'p'
5488 #define IDX_BITMAP_MIN 0xff70
5489 #define IDX_BITMAP_MAX 0xff71
5490 #define IDX_CUSTOM_CHARSET_1 '1'
5491 #define IDX_CUSTOM_CHARSET_2 '2'
5492 #define IDX_CUSTOM_CHARSET_3 '3'
5493 #define IDX_CUSTOM_CHARSET_4 '4'
5494
5495 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5496
5497 struct option long_options[] =
5498 {
5499 {"help", no_argument, 0, IDX_HELP},
5500 {"version", no_argument, 0, IDX_VERSION},
5501 {"quiet", no_argument, 0, IDX_QUIET},
5502 {"show", no_argument, 0, IDX_SHOW},
5503 {"left", no_argument, 0, IDX_LEFT},
5504 {"username", no_argument, 0, IDX_USERNAME},
5505 {"remove", no_argument, 0, IDX_REMOVE},
5506 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5507 {"skip", required_argument, 0, IDX_SKIP},
5508 {"limit", required_argument, 0, IDX_LIMIT},
5509 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5510 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5511 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5512 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5513 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5514 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5515 {"force", no_argument, 0, IDX_FORCE},
5516 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5517 {"benchmark-repeats", required_argument, 0, IDX_BENCHMARK_REPEATS},
5518 {"restore", no_argument, 0, IDX_RESTORE},
5519 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5520 {"status", no_argument, 0, IDX_STATUS},
5521 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5522 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5523 {"loopback", no_argument, 0, IDX_LOOPBACK},
5524 {"weak-hash-threshold",
5525 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5526 {"session", required_argument, 0, IDX_SESSION},
5527 {"runtime", required_argument, 0, IDX_RUNTIME},
5528 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5529 {"generate-rules-func-min",
5530 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5531 {"generate-rules-func-max",
5532 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5533 {"generate-rules-seed",
5534 required_argument, 0, IDX_RP_GEN_SEED},
5535 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5536 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5537 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5538 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5539 {"rules-file", required_argument, 0, IDX_RP_FILE},
5540 {"outfile", required_argument, 0, IDX_OUTFILE},
5541 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5542 {"outfile-autohex-disable",
5543 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5544 {"outfile-check-timer",
5545 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5546 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5547 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5548 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5549 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5550 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5551 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5552 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5553 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5554 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5555 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5556 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5557 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5558 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5559 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5560 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5561 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5562 #ifdef HAVE_HWMON
5563 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5564 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5565 #ifdef HAVE_ADL
5566 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5567 #endif
5568 #endif // HAVE_HWMON
5569 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5570 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5571 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5572 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5573 // deprecated
5574 {"seperator", required_argument, 0, IDX_SEPARATOR},
5575 {"separator", required_argument, 0, IDX_SEPARATOR},
5576 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5577 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5578 {"increment", no_argument, 0, IDX_INCREMENT},
5579 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5580 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5581 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5582 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5583 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5584 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5585
5586 {0, 0, 0, 0}
5587 };
5588
5589 uint rp_files_cnt = 0;
5590
5591 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5592
5593 int option_index = 0;
5594 int c = -1;
5595
5596 optind = 1;
5597 optopt = 0;
5598
5599 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5600 {
5601 switch (c)
5602 {
5603 case IDX_HELP: usage = 1; break;
5604 case IDX_VERSION:
5605 case IDX_VERSION_LOWER: version = 1; break;
5606 case IDX_RESTORE: restore = 1; break;
5607 case IDX_SESSION: session = optarg; break;
5608 case IDX_SHOW: show = 1; break;
5609 case IDX_LEFT: left = 1; break;
5610 case '?': return (-1);
5611 }
5612 }
5613
5614 if (optopt != 0)
5615 {
5616 log_error ("ERROR: Invalid argument specified");
5617
5618 return (-1);
5619 }
5620
5621 /**
5622 * exit functions
5623 */
5624
5625 if (version)
5626 {
5627 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5628
5629 return (0);
5630 }
5631
5632 if (usage)
5633 {
5634 usage_big_print (PROGNAME);
5635
5636 return (0);
5637 }
5638
5639 /**
5640 * session needs to be set, always!
5641 */
5642
5643 if (session == NULL) session = (char *) PROGNAME;
5644
5645 /**
5646 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5647 */
5648
5649 char *exec_path = get_exec_path ();
5650
5651 #ifdef LINUX
5652
5653 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5654 char *resolved_exec_path = realpath (exec_path, NULL);
5655
5656 char *install_dir = get_install_dir (resolved_exec_path);
5657 char *profile_dir = NULL;
5658 char *session_dir = NULL;
5659 char *shared_dir = NULL;
5660
5661 if (strcmp (install_dir, resolved_install_folder) == 0)
5662 {
5663 struct passwd *pw = getpwuid (getuid ());
5664
5665 const char *homedir = pw->pw_dir;
5666
5667 profile_dir = get_profile_dir (homedir);
5668 session_dir = get_session_dir (profile_dir);
5669 shared_dir = strdup (SHARED_FOLDER);
5670
5671 mkdir (profile_dir, 0700);
5672 mkdir (session_dir, 0700);
5673 }
5674 else
5675 {
5676 profile_dir = install_dir;
5677 session_dir = install_dir;
5678 shared_dir = install_dir;
5679 }
5680
5681 myfree (resolved_install_folder);
5682 myfree (resolved_exec_path);
5683
5684 #else
5685
5686 char *install_dir = get_install_dir (exec_path);
5687 char *profile_dir = install_dir;
5688 char *session_dir = install_dir;
5689 char *shared_dir = install_dir;
5690
5691 #endif
5692
5693 data.install_dir = install_dir;
5694 data.profile_dir = profile_dir;
5695 data.session_dir = session_dir;
5696 data.shared_dir = shared_dir;
5697
5698 myfree (exec_path);
5699
5700 /**
5701 * kernel cache, we need to make sure folder exist
5702 */
5703
5704 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5705
5706 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5707
5708 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5709
5710 mkdir (kernels_folder, 0700);
5711
5712 myfree (kernels_folder);
5713
5714 /**
5715 * session
5716 */
5717
5718 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5719
5720 data.session = session;
5721
5722 char *eff_restore_file = (char *) mymalloc (session_size);
5723 char *new_restore_file = (char *) mymalloc (session_size);
5724
5725 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5726 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5727
5728 data.eff_restore_file = eff_restore_file;
5729 data.new_restore_file = new_restore_file;
5730
5731 if (((show == 1) || (left == 1)) && (restore == 1))
5732 {
5733 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5734 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5735
5736 return (-1);
5737 }
5738
5739 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5740 if ((show == 1) || (left == 1))
5741 {
5742 restore_disable = 1;
5743
5744 restore = 0;
5745 }
5746
5747 data.restore_disable = restore_disable;
5748
5749 restore_data_t *rd = init_restore (argc, argv);
5750
5751 data.rd = rd;
5752
5753 /**
5754 * restore file
5755 */
5756
5757 if (restore == 1)
5758 {
5759 read_restore (eff_restore_file, rd);
5760
5761 if (rd->version_bin < RESTORE_MIN)
5762 {
5763 log_error ("ERROR: Incompatible restore-file version");
5764
5765 return (-1);
5766 }
5767
5768 myargc = rd->argc;
5769 myargv = rd->argv;
5770
5771 #ifdef _POSIX
5772 rd->pid = getpid ();
5773 #elif _WIN
5774 rd->pid = GetCurrentProcessId ();
5775 #endif
5776 }
5777
5778 uint hash_mode_chgd = 0;
5779 uint runtime_chgd = 0;
5780 uint kernel_loops_chgd = 0;
5781 uint kernel_accel_chgd = 0;
5782 uint attack_mode_chgd = 0;
5783 uint outfile_format_chgd = 0;
5784 uint rp_gen_seed_chgd = 0;
5785 uint remove_timer_chgd = 0;
5786 uint increment_min_chgd = 0;
5787 uint increment_max_chgd = 0;
5788 uint workload_profile_chgd = 0;
5789 uint opencl_vector_width_chgd = 0;
5790
5791 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5792 uint gpu_temp_retain_chgd = 0;
5793 uint gpu_temp_abort_chgd = 0;
5794 #endif
5795
5796 optind = 1;
5797 optopt = 0;
5798 option_index = 0;
5799
5800 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5801 {
5802 switch (c)
5803 {
5804 //case IDX_HELP: usage = 1; break;
5805 //case IDX_VERSION: version = 1; break;
5806 //case IDX_RESTORE: restore = 1; break;
5807 case IDX_QUIET: quiet = 1; break;
5808 //case IDX_SHOW: show = 1; break;
5809 case IDX_SHOW: break;
5810 //case IDX_LEFT: left = 1; break;
5811 case IDX_LEFT: break;
5812 case IDX_USERNAME: username = 1; break;
5813 case IDX_REMOVE: remove = 1; break;
5814 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5815 remove_timer_chgd = 1; break;
5816 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5817 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5818 case IDX_DEBUG_FILE: debug_file = optarg; break;
5819 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5820 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5821 case IDX_FORCE: force = 1; break;
5822 case IDX_SKIP: skip = atoll (optarg); break;
5823 case IDX_LIMIT: limit = atoll (optarg); break;
5824 case IDX_KEYSPACE: keyspace = 1; break;
5825 case IDX_BENCHMARK: benchmark = 1; break;
5826 case IDX_BENCHMARK_REPEATS: benchmark_repeats = atoi (optarg); break;
5827 case IDX_RESTORE: break;
5828 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5829 case IDX_STATUS: status = 1; break;
5830 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5831 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5832 case IDX_LOOPBACK: loopback = 1; break;
5833 case IDX_WEAK_HASH_THRESHOLD:
5834 weak_hash_threshold = atoi (optarg); break;
5835 //case IDX_SESSION: session = optarg; break;
5836 case IDX_SESSION: break;
5837 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5838 hash_mode_chgd = 1; break;
5839 case IDX_RUNTIME: runtime = atoi (optarg);
5840 runtime_chgd = 1; break;
5841 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5842 attack_mode_chgd = 1; break;
5843 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5844 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5845 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5846 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5847 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5848 rp_gen_seed_chgd = 1; break;
5849 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5850 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5851 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5852 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5853 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5854 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5855 case IDX_OUTFILE: outfile = optarg; break;
5856 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5857 outfile_format_chgd = 1; break;
5858 case IDX_OUTFILE_AUTOHEX_DISABLE:
5859 outfile_autohex = 0; break;
5860 case IDX_OUTFILE_CHECK_TIMER:
5861 outfile_check_timer = atoi (optarg); break;
5862 case IDX_HEX_CHARSET: hex_charset = 1; break;
5863 case IDX_HEX_SALT: hex_salt = 1; break;
5864 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5865 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5866 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5867 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5868 case IDX_OPENCL_DEVICE_TYPES:
5869 opencl_device_types = optarg; break;
5870 case IDX_OPENCL_VECTOR_WIDTH:
5871 opencl_vector_width = atoi (optarg);
5872 opencl_vector_width_chgd = 1; break;
5873 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5874 workload_profile_chgd = 1; break;
5875 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5876 kernel_accel_chgd = 1; break;
5877 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5878 kernel_loops_chgd = 1; break;
5879 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5880 #ifdef HAVE_HWMON
5881 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5882 #ifdef HAVE_ADL
5883 gpu_temp_abort_chgd = 1;
5884 #endif
5885 break;
5886 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5887 #ifdef HAVE_ADL
5888 gpu_temp_retain_chgd = 1;
5889 #endif
5890 break;
5891 #ifdef HAVE_ADL
5892 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5893 #endif
5894 #endif // HAVE_HWMON
5895 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5896 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5897 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5898 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5899 case IDX_SEPARATOR: separator = optarg[0]; break;
5900 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5901 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5902 case IDX_INCREMENT: increment = 1; break;
5903 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5904 increment_min_chgd = 1; break;
5905 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5906 increment_max_chgd = 1; break;
5907 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5908 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5909 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5910 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5911
5912 default:
5913 log_error ("ERROR: Invalid argument specified");
5914 return (-1);
5915 }
5916 }
5917
5918 if (optopt != 0)
5919 {
5920 log_error ("ERROR: Invalid argument specified");
5921
5922 return (-1);
5923 }
5924
5925 /**
5926 * Inform user things getting started,
5927 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5928 * - we do not need to check algorithm_pos
5929 */
5930
5931 if (quiet == 0)
5932 {
5933 if (benchmark == 1)
5934 {
5935 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5936
5937 log_info ("");
5938 }
5939 else if (restore == 1)
5940 {
5941 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5942
5943 log_info ("");
5944 }
5945 else
5946 {
5947 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5948
5949 log_info ("");
5950 }
5951 }
5952
5953 /**
5954 * sanity check
5955 */
5956
5957 if (attack_mode > 7)
5958 {
5959 log_error ("ERROR: Invalid attack-mode specified");
5960
5961 return (-1);
5962 }
5963
5964 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5965 {
5966 log_error ("ERROR: Invalid runtime specified");
5967
5968 return (-1);
5969 }
5970
5971 if (hash_mode_chgd && hash_mode > 13100) // just added to remove compiler warnings for hash_mode_chgd
5972 {
5973 log_error ("ERROR: Invalid hash-type specified");
5974
5975 return (-1);
5976 }
5977
5978 // renamed hash modes
5979
5980 if (hash_mode_chgd)
5981 {
5982 int n = -1;
5983
5984 switch (hash_mode)
5985 {
5986 case 123: n = 124;
5987 break;
5988 }
5989
5990 if (n >= 0)
5991 {
5992 log_error ("Old -m specified, use -m %d instead", n);
5993
5994 return (-1);
5995 }
5996 }
5997
5998 if (username == 1)
5999 {
6000 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
6001 {
6002 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6003
6004 return (-1);
6005 }
6006 }
6007
6008 if (outfile_format > 16)
6009 {
6010 log_error ("ERROR: Invalid outfile-format specified");
6011
6012 return (-1);
6013 }
6014
6015 if (left == 1)
6016 {
6017 if (outfile_format_chgd == 1)
6018 {
6019 if (outfile_format > 1)
6020 {
6021 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6022
6023 return (-1);
6024 }
6025 }
6026 else
6027 {
6028 outfile_format = OUTFILE_FMT_HASH;
6029 }
6030 }
6031
6032 if (show == 1)
6033 {
6034 if (outfile_format_chgd == 1)
6035 {
6036 if ((outfile_format > 7) && (outfile_format < 16))
6037 {
6038 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6039
6040 return (-1);
6041 }
6042 }
6043 }
6044
6045 if (increment_min < INCREMENT_MIN)
6046 {
6047 log_error ("ERROR: Invalid increment-min specified");
6048
6049 return (-1);
6050 }
6051
6052 if (increment_max > INCREMENT_MAX)
6053 {
6054 log_error ("ERROR: Invalid increment-max specified");
6055
6056 return (-1);
6057 }
6058
6059 if (increment_min > increment_max)
6060 {
6061 log_error ("ERROR: Invalid increment-min specified");
6062
6063 return (-1);
6064 }
6065
6066 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6067 {
6068 log_error ("ERROR: increment is not allowed in attack-mode 0");
6069
6070 return (-1);
6071 }
6072
6073 if ((increment == 0) && (increment_min_chgd == 1))
6074 {
6075 log_error ("ERROR: increment-min is only supported together with increment switch");
6076
6077 return (-1);
6078 }
6079
6080 if ((increment == 0) && (increment_max_chgd == 1))
6081 {
6082 log_error ("ERROR: increment-max is only supported together with increment switch");
6083
6084 return (-1);
6085 }
6086
6087 if (rp_files_cnt && rp_gen)
6088 {
6089 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6090
6091 return (-1);
6092 }
6093
6094 if (rp_files_cnt || rp_gen)
6095 {
6096 if (attack_mode != ATTACK_MODE_STRAIGHT)
6097 {
6098 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6099
6100 return (-1);
6101 }
6102 }
6103
6104 if (rp_gen_func_min > rp_gen_func_max)
6105 {
6106 log_error ("ERROR: Invalid rp-gen-func-min specified");
6107
6108 return (-1);
6109 }
6110
6111 if (kernel_accel_chgd == 1)
6112 {
6113 if (kernel_accel < 1)
6114 {
6115 log_error ("ERROR: Invalid kernel-accel specified");
6116
6117 return (-1);
6118 }
6119
6120 if (kernel_accel > 1024)
6121 {
6122 log_error ("ERROR: Invalid kernel-accel specified");
6123
6124 return (-1);
6125 }
6126 }
6127
6128 if (kernel_loops_chgd == 1)
6129 {
6130 if (kernel_loops < 1)
6131 {
6132 log_error ("ERROR: Invalid kernel-loops specified");
6133
6134 return (-1);
6135 }
6136
6137 if (kernel_loops > 1024)
6138 {
6139 log_error ("ERROR: Invalid kernel-loops specified");
6140
6141 return (-1);
6142 }
6143 }
6144
6145 if ((workload_profile < 1) || (workload_profile > 3))
6146 {
6147 log_error ("ERROR: workload-profile %i not available", workload_profile);
6148
6149 return (-1);
6150 }
6151
6152 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6153 {
6154 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6155
6156 return (-1);
6157 }
6158
6159 if (show == 1 || left == 1)
6160 {
6161 attack_mode = ATTACK_MODE_NONE;
6162
6163 if (remove == 1)
6164 {
6165 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6166
6167 return (-1);
6168 }
6169
6170 if (potfile_disable == 1)
6171 {
6172 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6173
6174 return (-1);
6175 }
6176 }
6177
6178 uint attack_kern = ATTACK_KERN_NONE;
6179
6180 switch (attack_mode)
6181 {
6182 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6183 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6184 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6185 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6186 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6187 }
6188
6189 if (benchmark == 0)
6190 {
6191 if (keyspace == 1)
6192 {
6193 int num_additional_params = 1;
6194
6195 if (attack_kern == ATTACK_KERN_COMBI)
6196 {
6197 num_additional_params = 2;
6198 }
6199
6200 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6201
6202 if (keyspace_wordlist_specified == 0) optind--;
6203 }
6204
6205 if (attack_kern == ATTACK_KERN_NONE)
6206 {
6207 if ((optind + 1) != myargc)
6208 {
6209 usage_mini_print (myargv[0]);
6210
6211 return (-1);
6212 }
6213 }
6214 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6215 {
6216 if ((optind + 1) > myargc)
6217 {
6218 usage_mini_print (myargv[0]);
6219
6220 return (-1);
6221 }
6222 }
6223 else if (attack_kern == ATTACK_KERN_COMBI)
6224 {
6225 if ((optind + 3) != myargc)
6226 {
6227 usage_mini_print (myargv[0]);
6228
6229 return (-1);
6230 }
6231 }
6232 else if (attack_kern == ATTACK_KERN_BF)
6233 {
6234 if ((optind + 1) > myargc)
6235 {
6236 usage_mini_print (myargv[0]);
6237
6238 return (-1);
6239 }
6240 }
6241 else
6242 {
6243 usage_mini_print (myargv[0]);
6244
6245 return (-1);
6246 }
6247 }
6248 else
6249 {
6250 if (myargv[optind] != 0)
6251 {
6252 log_error ("ERROR: Invalid argument for benchmark mode specified");
6253
6254 return (-1);
6255 }
6256
6257 if (attack_mode_chgd == 1)
6258 {
6259 if (attack_mode != ATTACK_MODE_BF)
6260 {
6261 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6262
6263 return (-1);
6264 }
6265 }
6266 }
6267
6268 if (skip != 0 && limit != 0)
6269 {
6270 limit += skip;
6271 }
6272
6273 if (keyspace == 1)
6274 {
6275 if (show == 1)
6276 {
6277 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6278
6279 return (-1);
6280 }
6281 else if (left == 1)
6282 {
6283 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6284
6285 return (-1);
6286 }
6287
6288 potfile_disable = 1;
6289
6290 restore_disable = 1;
6291
6292 restore = 0;
6293
6294 weak_hash_threshold = 0;
6295
6296 quiet = 1;
6297 }
6298
6299 if (remove_timer_chgd == 1)
6300 {
6301 if (remove == 0)
6302 {
6303 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6304
6305 return (-1);
6306 }
6307
6308 if (remove_timer < 1)
6309 {
6310 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6311
6312 return (-1);
6313 }
6314 }
6315
6316 if (loopback == 1)
6317 {
6318 if (attack_mode == ATTACK_MODE_BF)
6319 {
6320 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6321
6322 return (-1);
6323 }
6324 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6325 {
6326 if ((rp_files_cnt == 0) && (rp_gen == 0))
6327 {
6328 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6329
6330 return (-1);
6331 }
6332 }
6333 }
6334
6335 if (debug_mode > 0)
6336 {
6337 if (attack_mode != ATTACK_MODE_STRAIGHT)
6338 {
6339 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6340
6341 return (-1);
6342 }
6343
6344 if ((rp_files_cnt == 0) && (rp_gen == 0))
6345 {
6346 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6347
6348 return (-1);
6349 }
6350 }
6351
6352 if (debug_mode > 4)
6353 {
6354 log_error ("ERROR: Invalid debug-mode specified");
6355
6356 return (-1);
6357 }
6358
6359 if (debug_file != NULL)
6360 {
6361 if (debug_mode < 1)
6362 {
6363 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6364
6365 return (-1);
6366 }
6367 }
6368
6369 if (induction_dir != NULL)
6370 {
6371 if (attack_mode == ATTACK_MODE_BF)
6372 {
6373 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6374
6375 return (-1);
6376 }
6377 }
6378
6379 if (attack_mode != ATTACK_MODE_STRAIGHT)
6380 {
6381 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6382 {
6383 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6384
6385 return (-1);
6386 }
6387
6388 weak_hash_threshold = 0;
6389 }
6390
6391 /**
6392 * induction directory
6393 */
6394
6395 char *induction_directory = NULL;
6396
6397 if (attack_mode != ATTACK_MODE_BF)
6398 {
6399 if (induction_dir == NULL)
6400 {
6401 induction_directory = (char *) mymalloc (session_size);
6402
6403 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6404
6405 // create induction folder if it does not already exist
6406
6407 if (keyspace == 0)
6408 {
6409 if (rmdir (induction_directory) == -1)
6410 {
6411 if (errno == ENOENT)
6412 {
6413 // good, we can ignore
6414 }
6415 else if (errno == ENOTEMPTY)
6416 {
6417 char *induction_directory_mv = (char *) mymalloc (session_size);
6418
6419 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6420
6421 if (rename (induction_directory, induction_directory_mv) != 0)
6422 {
6423 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6424
6425 return (-1);
6426 }
6427 }
6428 else
6429 {
6430 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6431
6432 return (-1);
6433 }
6434 }
6435
6436 if (mkdir (induction_directory, 0700) == -1)
6437 {
6438 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6439
6440 return (-1);
6441 }
6442 }
6443 }
6444 else
6445 {
6446 induction_directory = induction_dir;
6447 }
6448 }
6449
6450 data.induction_directory = induction_directory;
6451
6452 /**
6453 * loopback
6454 */
6455
6456 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6457
6458 char *loopback_file = (char *) mymalloc (loopback_size);
6459
6460 /**
6461 * tuning db
6462 */
6463
6464 char tuning_db_file[256] = { 0 };
6465
6466 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6467
6468 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6469
6470 /**
6471 * outfile-check directory
6472 */
6473
6474 char *outfile_check_directory = NULL;
6475
6476 if (outfile_check_dir == NULL)
6477 {
6478 outfile_check_directory = (char *) mymalloc (session_size);
6479
6480 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6481 }
6482 else
6483 {
6484 outfile_check_directory = outfile_check_dir;
6485 }
6486
6487 data.outfile_check_directory = outfile_check_directory;
6488
6489 if (keyspace == 0)
6490 {
6491 struct stat outfile_check_stat;
6492
6493 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6494 {
6495 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6496
6497 if (is_dir == 0)
6498 {
6499 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6500
6501 return (-1);
6502 }
6503 }
6504 else if (outfile_check_dir == NULL)
6505 {
6506 if (mkdir (outfile_check_directory, 0700) == -1)
6507 {
6508 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6509
6510 return (-1);
6511 }
6512 }
6513 }
6514
6515 /**
6516 * special other stuff
6517 */
6518
6519 if (hash_mode == 9710)
6520 {
6521 outfile_format = 5;
6522 outfile_format_chgd = 1;
6523 }
6524
6525 if (hash_mode == 9810)
6526 {
6527 outfile_format = 5;
6528 outfile_format_chgd = 1;
6529 }
6530
6531 if (hash_mode == 10410)
6532 {
6533 outfile_format = 5;
6534 outfile_format_chgd = 1;
6535 }
6536
6537 /**
6538 * store stuff
6539 */
6540
6541 data.hash_mode = hash_mode;
6542 data.restore = restore;
6543 data.restore_timer = restore_timer;
6544 data.restore_disable = restore_disable;
6545 data.status = status;
6546 data.status_timer = status_timer;
6547 data.status_automat = status_automat;
6548 data.loopback = loopback;
6549 data.runtime = runtime;
6550 data.remove = remove;
6551 data.remove_timer = remove_timer;
6552 data.debug_mode = debug_mode;
6553 data.debug_file = debug_file;
6554 data.username = username;
6555 data.quiet = quiet;
6556 data.outfile = outfile;
6557 data.outfile_format = outfile_format;
6558 data.outfile_autohex = outfile_autohex;
6559 data.hex_charset = hex_charset;
6560 data.hex_salt = hex_salt;
6561 data.hex_wordlist = hex_wordlist;
6562 data.separator = separator;
6563 data.rp_files = rp_files;
6564 data.rp_files_cnt = rp_files_cnt;
6565 data.rp_gen = rp_gen;
6566 data.rp_gen_seed = rp_gen_seed;
6567 data.force = force;
6568 data.benchmark = benchmark;
6569 data.benchmark_repeats = benchmark_repeats;
6570 data.skip = skip;
6571 data.limit = limit;
6572 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6573 data.powertune_enable = powertune_enable;
6574 #endif
6575 data.logfile_disable = logfile_disable;
6576 data.truecrypt_keyfiles = truecrypt_keyfiles;
6577 data.scrypt_tmto = scrypt_tmto;
6578 data.workload_profile = workload_profile;
6579
6580 /**
6581 * cpu affinity
6582 */
6583
6584 if (cpu_affinity)
6585 {
6586 set_cpu_affinity (cpu_affinity);
6587 }
6588
6589 if (rp_gen_seed_chgd == 0)
6590 {
6591 srand (proc_start);
6592 }
6593 else
6594 {
6595 srand (rp_gen_seed);
6596 }
6597
6598 /**
6599 * logfile init
6600 */
6601
6602 if (logfile_disable == 0)
6603 {
6604 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6605
6606 char *logfile = (char *) mymalloc (logfile_size);
6607
6608 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6609
6610 data.logfile = logfile;
6611
6612 char *topid = logfile_generate_topid ();
6613
6614 data.topid = topid;
6615 }
6616
6617 // logfile_append() checks for logfile_disable internally to make it easier from here
6618
6619 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6620 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6621 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6622 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6623 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6624 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6625 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6626 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6627 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6628 #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));
6629
6630 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6631 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6632 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6633 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6634 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6635 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6636 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6637 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6638
6639 logfile_top_msg ("START");
6640
6641 logfile_top_uint (attack_mode);
6642 logfile_top_uint (attack_kern);
6643 logfile_top_uint (benchmark);
6644 logfile_top_uint (benchmark_repeats);
6645 logfile_top_uint (bitmap_min);
6646 logfile_top_uint (bitmap_max);
6647 logfile_top_uint (debug_mode);
6648 logfile_top_uint (force);
6649 logfile_top_uint (kernel_accel);
6650 logfile_top_uint (kernel_loops);
6651 logfile_top_uint (gpu_temp_disable);
6652 #ifdef HAVE_HWMON
6653 logfile_top_uint (gpu_temp_abort);
6654 logfile_top_uint (gpu_temp_retain);
6655 #endif
6656 logfile_top_uint (hash_mode);
6657 logfile_top_uint (hex_charset);
6658 logfile_top_uint (hex_salt);
6659 logfile_top_uint (hex_wordlist);
6660 logfile_top_uint (increment);
6661 logfile_top_uint (increment_max);
6662 logfile_top_uint (increment_min);
6663 logfile_top_uint (keyspace);
6664 logfile_top_uint (left);
6665 logfile_top_uint (logfile_disable);
6666 logfile_top_uint (loopback);
6667 logfile_top_uint (markov_classic);
6668 logfile_top_uint (markov_disable);
6669 logfile_top_uint (markov_threshold);
6670 logfile_top_uint (outfile_autohex);
6671 logfile_top_uint (outfile_check_timer);
6672 logfile_top_uint (outfile_format);
6673 logfile_top_uint (potfile_disable);
6674 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6675 logfile_top_uint (powertune_enable);
6676 #endif
6677 logfile_top_uint (scrypt_tmto);
6678 logfile_top_uint (quiet);
6679 logfile_top_uint (remove);
6680 logfile_top_uint (remove_timer);
6681 logfile_top_uint (restore);
6682 logfile_top_uint (restore_disable);
6683 logfile_top_uint (restore_timer);
6684 logfile_top_uint (rp_gen);
6685 logfile_top_uint (rp_gen_func_max);
6686 logfile_top_uint (rp_gen_func_min);
6687 logfile_top_uint (rp_gen_seed);
6688 logfile_top_uint (runtime);
6689 logfile_top_uint (segment_size);
6690 logfile_top_uint (show);
6691 logfile_top_uint (status);
6692 logfile_top_uint (status_automat);
6693 logfile_top_uint (status_timer);
6694 logfile_top_uint (usage);
6695 logfile_top_uint (username);
6696 logfile_top_uint (version);
6697 logfile_top_uint (weak_hash_threshold);
6698 logfile_top_uint (workload_profile);
6699 logfile_top_uint64 (limit);
6700 logfile_top_uint64 (skip);
6701 logfile_top_char (separator);
6702 logfile_top_string (cpu_affinity);
6703 logfile_top_string (custom_charset_1);
6704 logfile_top_string (custom_charset_2);
6705 logfile_top_string (custom_charset_3);
6706 logfile_top_string (custom_charset_4);
6707 logfile_top_string (debug_file);
6708 logfile_top_string (opencl_devices);
6709 logfile_top_string (opencl_platforms);
6710 logfile_top_string (opencl_device_types);
6711 logfile_top_uint (opencl_vector_width);
6712 logfile_top_string (induction_dir);
6713 logfile_top_string (markov_hcstat);
6714 logfile_top_string (outfile);
6715 logfile_top_string (outfile_check_dir);
6716 logfile_top_string (rule_buf_l);
6717 logfile_top_string (rule_buf_r);
6718 logfile_top_string (session);
6719 logfile_top_string (truecrypt_keyfiles);
6720
6721 /**
6722 * Init OpenCL library loader
6723 */
6724
6725 if (keyspace == 0)
6726 {
6727 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6728
6729 ocl_init (ocl);
6730
6731 data.ocl = ocl;
6732 }
6733
6734 /**
6735 * OpenCL platform selection
6736 */
6737
6738 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6739
6740 /**
6741 * OpenCL device selection
6742 */
6743
6744 u32 devices_filter = setup_devices_filter (opencl_devices);
6745
6746 /**
6747 * OpenCL device type selection
6748 */
6749
6750 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6751
6752 /**
6753 * benchmark
6754 */
6755
6756 if (benchmark == 1)
6757 {
6758 /**
6759 * disable useless stuff for benchmark
6760 */
6761
6762 status_timer = 0;
6763 restore_timer = 0;
6764 restore_disable = 1;
6765 potfile_disable = 1;
6766 weak_hash_threshold = 0;
6767 gpu_temp_disable = 1;
6768
6769 data.status_timer = status_timer;
6770 data.restore_timer = restore_timer;
6771 data.restore_disable = restore_disable;
6772
6773 /**
6774 * force attack mode to be bruteforce
6775 */
6776
6777 attack_mode = ATTACK_MODE_BF;
6778 attack_kern = ATTACK_KERN_BF;
6779
6780 if (workload_profile_chgd == 0)
6781 {
6782 workload_profile = 3;
6783
6784 data.workload_profile = workload_profile;
6785 }
6786 }
6787
6788 /**
6789 * config
6790 */
6791
6792 uint hash_type = 0;
6793 uint salt_type = 0;
6794 uint attack_exec = 0;
6795 uint opts_type = 0;
6796 uint kern_type = 0;
6797 uint dgst_size = 0;
6798 uint esalt_size = 0;
6799 uint opti_type = 0;
6800 uint dgst_pos0 = -1;
6801 uint dgst_pos1 = -1;
6802 uint dgst_pos2 = -1;
6803 uint dgst_pos3 = -1;
6804
6805 int (*parse_func) (char *, uint, hash_t *);
6806 int (*sort_by_digest) (const void *, const void *);
6807
6808 uint algorithm_pos = 0;
6809 uint algorithm_max = 1;
6810
6811 uint *algorithms = default_benchmark_algorithms;
6812
6813 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6814
6815 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6816 {
6817 /*
6818 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6819 * the following algos are skipped entirely
6820 */
6821
6822 if (algorithm_pos > 0)
6823 {
6824 local_free (rd);
6825
6826 rd = init_restore (argc, argv);
6827
6828 data.rd = rd;
6829 }
6830
6831 /**
6832 * update hash_mode in case of multihash benchmark
6833 */
6834
6835 if (benchmark == 1)
6836 {
6837 if (hash_mode_chgd == 0)
6838 {
6839 hash_mode = algorithms[algorithm_pos];
6840
6841 data.hash_mode = hash_mode;
6842 }
6843
6844 quiet = 1;
6845
6846 data.quiet = quiet;
6847 }
6848
6849 switch (hash_mode)
6850 {
6851 case 0: hash_type = HASH_TYPE_MD5;
6852 salt_type = SALT_TYPE_NONE;
6853 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6854 opts_type = OPTS_TYPE_PT_GENERATE_LE
6855 | OPTS_TYPE_PT_ADD80
6856 | OPTS_TYPE_PT_ADDBITS14;
6857 kern_type = KERN_TYPE_MD5;
6858 dgst_size = DGST_SIZE_4_4;
6859 parse_func = md5_parse_hash;
6860 sort_by_digest = sort_by_digest_4_4;
6861 opti_type = OPTI_TYPE_ZERO_BYTE
6862 | OPTI_TYPE_PRECOMPUTE_INIT
6863 | OPTI_TYPE_PRECOMPUTE_MERKLE
6864 | OPTI_TYPE_MEET_IN_MIDDLE
6865 | OPTI_TYPE_EARLY_SKIP
6866 | OPTI_TYPE_NOT_ITERATED
6867 | OPTI_TYPE_NOT_SALTED
6868 | OPTI_TYPE_RAW_HASH;
6869 dgst_pos0 = 0;
6870 dgst_pos1 = 3;
6871 dgst_pos2 = 2;
6872 dgst_pos3 = 1;
6873 break;
6874
6875 case 10: hash_type = HASH_TYPE_MD5;
6876 salt_type = SALT_TYPE_INTERN;
6877 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6878 opts_type = OPTS_TYPE_PT_GENERATE_LE
6879 | OPTS_TYPE_ST_ADD80
6880 | OPTS_TYPE_ST_ADDBITS14;
6881 kern_type = KERN_TYPE_MD5_PWSLT;
6882 dgst_size = DGST_SIZE_4_4;
6883 parse_func = md5s_parse_hash;
6884 sort_by_digest = sort_by_digest_4_4;
6885 opti_type = OPTI_TYPE_ZERO_BYTE
6886 | OPTI_TYPE_PRECOMPUTE_INIT
6887 | OPTI_TYPE_PRECOMPUTE_MERKLE
6888 | OPTI_TYPE_MEET_IN_MIDDLE
6889 | OPTI_TYPE_EARLY_SKIP
6890 | OPTI_TYPE_NOT_ITERATED
6891 | OPTI_TYPE_APPENDED_SALT
6892 | OPTI_TYPE_RAW_HASH;
6893 dgst_pos0 = 0;
6894 dgst_pos1 = 3;
6895 dgst_pos2 = 2;
6896 dgst_pos3 = 1;
6897 break;
6898
6899 case 11: hash_type = HASH_TYPE_MD5;
6900 salt_type = SALT_TYPE_INTERN;
6901 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6902 opts_type = OPTS_TYPE_PT_GENERATE_LE
6903 | OPTS_TYPE_ST_ADD80
6904 | OPTS_TYPE_ST_ADDBITS14;
6905 kern_type = KERN_TYPE_MD5_PWSLT;
6906 dgst_size = DGST_SIZE_4_4;
6907 parse_func = joomla_parse_hash;
6908 sort_by_digest = sort_by_digest_4_4;
6909 opti_type = OPTI_TYPE_ZERO_BYTE
6910 | OPTI_TYPE_PRECOMPUTE_INIT
6911 | OPTI_TYPE_PRECOMPUTE_MERKLE
6912 | OPTI_TYPE_MEET_IN_MIDDLE
6913 | OPTI_TYPE_EARLY_SKIP
6914 | OPTI_TYPE_NOT_ITERATED
6915 | OPTI_TYPE_APPENDED_SALT
6916 | OPTI_TYPE_RAW_HASH;
6917 dgst_pos0 = 0;
6918 dgst_pos1 = 3;
6919 dgst_pos2 = 2;
6920 dgst_pos3 = 1;
6921 break;
6922
6923 case 12: hash_type = HASH_TYPE_MD5;
6924 salt_type = SALT_TYPE_INTERN;
6925 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6926 opts_type = OPTS_TYPE_PT_GENERATE_LE
6927 | OPTS_TYPE_ST_ADD80
6928 | OPTS_TYPE_ST_ADDBITS14;
6929 kern_type = KERN_TYPE_MD5_PWSLT;
6930 dgst_size = DGST_SIZE_4_4;
6931 parse_func = postgresql_parse_hash;
6932 sort_by_digest = sort_by_digest_4_4;
6933 opti_type = OPTI_TYPE_ZERO_BYTE
6934 | OPTI_TYPE_PRECOMPUTE_INIT
6935 | OPTI_TYPE_PRECOMPUTE_MERKLE
6936 | OPTI_TYPE_MEET_IN_MIDDLE
6937 | OPTI_TYPE_EARLY_SKIP
6938 | OPTI_TYPE_NOT_ITERATED
6939 | OPTI_TYPE_APPENDED_SALT
6940 | OPTI_TYPE_RAW_HASH;
6941 dgst_pos0 = 0;
6942 dgst_pos1 = 3;
6943 dgst_pos2 = 2;
6944 dgst_pos3 = 1;
6945 break;
6946
6947 case 20: hash_type = HASH_TYPE_MD5;
6948 salt_type = SALT_TYPE_INTERN;
6949 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6950 opts_type = OPTS_TYPE_PT_GENERATE_LE
6951 | OPTS_TYPE_PT_ADD80
6952 | OPTS_TYPE_PT_ADDBITS14;
6953 kern_type = KERN_TYPE_MD5_SLTPW;
6954 dgst_size = DGST_SIZE_4_4;
6955 parse_func = md5s_parse_hash;
6956 sort_by_digest = sort_by_digest_4_4;
6957 opti_type = OPTI_TYPE_ZERO_BYTE
6958 | OPTI_TYPE_PRECOMPUTE_INIT
6959 | OPTI_TYPE_PRECOMPUTE_MERKLE
6960 | OPTI_TYPE_EARLY_SKIP
6961 | OPTI_TYPE_NOT_ITERATED
6962 | OPTI_TYPE_PREPENDED_SALT
6963 | OPTI_TYPE_RAW_HASH;
6964 dgst_pos0 = 0;
6965 dgst_pos1 = 3;
6966 dgst_pos2 = 2;
6967 dgst_pos3 = 1;
6968 break;
6969
6970 case 21: hash_type = HASH_TYPE_MD5;
6971 salt_type = SALT_TYPE_INTERN;
6972 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6973 opts_type = OPTS_TYPE_PT_GENERATE_LE
6974 | OPTS_TYPE_PT_ADD80
6975 | OPTS_TYPE_PT_ADDBITS14;
6976 kern_type = KERN_TYPE_MD5_SLTPW;
6977 dgst_size = DGST_SIZE_4_4;
6978 parse_func = osc_parse_hash;
6979 sort_by_digest = sort_by_digest_4_4;
6980 opti_type = OPTI_TYPE_ZERO_BYTE
6981 | OPTI_TYPE_PRECOMPUTE_INIT
6982 | OPTI_TYPE_PRECOMPUTE_MERKLE
6983 | OPTI_TYPE_EARLY_SKIP
6984 | OPTI_TYPE_NOT_ITERATED
6985 | OPTI_TYPE_PREPENDED_SALT
6986 | OPTI_TYPE_RAW_HASH;
6987 dgst_pos0 = 0;
6988 dgst_pos1 = 3;
6989 dgst_pos2 = 2;
6990 dgst_pos3 = 1;
6991 break;
6992
6993 case 22: hash_type = HASH_TYPE_MD5;
6994 salt_type = SALT_TYPE_EMBEDDED;
6995 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6996 opts_type = OPTS_TYPE_PT_GENERATE_LE
6997 | OPTS_TYPE_PT_ADD80
6998 | OPTS_TYPE_PT_ADDBITS14;
6999 kern_type = KERN_TYPE_MD5_SLTPW;
7000 dgst_size = DGST_SIZE_4_4;
7001 parse_func = netscreen_parse_hash;
7002 sort_by_digest = sort_by_digest_4_4;
7003 opti_type = OPTI_TYPE_ZERO_BYTE
7004 | OPTI_TYPE_PRECOMPUTE_INIT
7005 | OPTI_TYPE_PRECOMPUTE_MERKLE
7006 | OPTI_TYPE_EARLY_SKIP
7007 | OPTI_TYPE_NOT_ITERATED
7008 | OPTI_TYPE_PREPENDED_SALT
7009 | OPTI_TYPE_RAW_HASH;
7010 dgst_pos0 = 0;
7011 dgst_pos1 = 3;
7012 dgst_pos2 = 2;
7013 dgst_pos3 = 1;
7014 break;
7015
7016 case 23: hash_type = HASH_TYPE_MD5;
7017 salt_type = SALT_TYPE_EMBEDDED;
7018 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7019 opts_type = OPTS_TYPE_PT_GENERATE_LE
7020 | OPTS_TYPE_PT_ADD80
7021 | OPTS_TYPE_PT_ADDBITS14;
7022 kern_type = KERN_TYPE_MD5_SLTPW;
7023 dgst_size = DGST_SIZE_4_4;
7024 parse_func = skype_parse_hash;
7025 sort_by_digest = sort_by_digest_4_4;
7026 opti_type = OPTI_TYPE_ZERO_BYTE
7027 | OPTI_TYPE_PRECOMPUTE_INIT
7028 | OPTI_TYPE_PRECOMPUTE_MERKLE
7029 | OPTI_TYPE_EARLY_SKIP
7030 | OPTI_TYPE_NOT_ITERATED
7031 | OPTI_TYPE_PREPENDED_SALT
7032 | OPTI_TYPE_RAW_HASH;
7033 dgst_pos0 = 0;
7034 dgst_pos1 = 3;
7035 dgst_pos2 = 2;
7036 dgst_pos3 = 1;
7037 break;
7038
7039 case 30: hash_type = HASH_TYPE_MD5;
7040 salt_type = SALT_TYPE_INTERN;
7041 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7042 opts_type = OPTS_TYPE_PT_GENERATE_LE
7043 | OPTS_TYPE_PT_UNICODE
7044 | OPTS_TYPE_ST_ADD80
7045 | OPTS_TYPE_ST_ADDBITS14;
7046 kern_type = KERN_TYPE_MD5_PWUSLT;
7047 dgst_size = DGST_SIZE_4_4;
7048 parse_func = md5s_parse_hash;
7049 sort_by_digest = sort_by_digest_4_4;
7050 opti_type = OPTI_TYPE_ZERO_BYTE
7051 | OPTI_TYPE_PRECOMPUTE_INIT
7052 | OPTI_TYPE_PRECOMPUTE_MERKLE
7053 | OPTI_TYPE_MEET_IN_MIDDLE
7054 | OPTI_TYPE_EARLY_SKIP
7055 | OPTI_TYPE_NOT_ITERATED
7056 | OPTI_TYPE_APPENDED_SALT
7057 | OPTI_TYPE_RAW_HASH;
7058 dgst_pos0 = 0;
7059 dgst_pos1 = 3;
7060 dgst_pos2 = 2;
7061 dgst_pos3 = 1;
7062 break;
7063
7064 case 40: hash_type = HASH_TYPE_MD5;
7065 salt_type = SALT_TYPE_INTERN;
7066 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7067 opts_type = OPTS_TYPE_PT_GENERATE_LE
7068 | OPTS_TYPE_PT_ADD80
7069 | OPTS_TYPE_PT_ADDBITS14
7070 | OPTS_TYPE_PT_UNICODE;
7071 kern_type = KERN_TYPE_MD5_SLTPWU;
7072 dgst_size = DGST_SIZE_4_4;
7073 parse_func = md5s_parse_hash;
7074 sort_by_digest = sort_by_digest_4_4;
7075 opti_type = OPTI_TYPE_ZERO_BYTE
7076 | OPTI_TYPE_PRECOMPUTE_INIT
7077 | OPTI_TYPE_PRECOMPUTE_MERKLE
7078 | OPTI_TYPE_EARLY_SKIP
7079 | OPTI_TYPE_NOT_ITERATED
7080 | OPTI_TYPE_PREPENDED_SALT
7081 | OPTI_TYPE_RAW_HASH;
7082 dgst_pos0 = 0;
7083 dgst_pos1 = 3;
7084 dgst_pos2 = 2;
7085 dgst_pos3 = 1;
7086 break;
7087
7088 case 50: hash_type = HASH_TYPE_MD5;
7089 salt_type = SALT_TYPE_INTERN;
7090 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7091 opts_type = OPTS_TYPE_PT_GENERATE_LE
7092 | OPTS_TYPE_ST_ADD80
7093 | OPTS_TYPE_ST_ADDBITS14;
7094 kern_type = KERN_TYPE_HMACMD5_PW;
7095 dgst_size = DGST_SIZE_4_4;
7096 parse_func = hmacmd5_parse_hash;
7097 sort_by_digest = sort_by_digest_4_4;
7098 opti_type = OPTI_TYPE_ZERO_BYTE
7099 | OPTI_TYPE_NOT_ITERATED;
7100 dgst_pos0 = 0;
7101 dgst_pos1 = 3;
7102 dgst_pos2 = 2;
7103 dgst_pos3 = 1;
7104 break;
7105
7106 case 60: hash_type = HASH_TYPE_MD5;
7107 salt_type = SALT_TYPE_INTERN;
7108 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7109 opts_type = OPTS_TYPE_PT_GENERATE_LE
7110 | OPTS_TYPE_PT_ADD80
7111 | OPTS_TYPE_PT_ADDBITS14;
7112 kern_type = KERN_TYPE_HMACMD5_SLT;
7113 dgst_size = DGST_SIZE_4_4;
7114 parse_func = hmacmd5_parse_hash;
7115 sort_by_digest = sort_by_digest_4_4;
7116 opti_type = OPTI_TYPE_ZERO_BYTE
7117 | OPTI_TYPE_NOT_ITERATED;
7118 dgst_pos0 = 0;
7119 dgst_pos1 = 3;
7120 dgst_pos2 = 2;
7121 dgst_pos3 = 1;
7122 break;
7123
7124 case 100: hash_type = HASH_TYPE_SHA1;
7125 salt_type = SALT_TYPE_NONE;
7126 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7127 opts_type = OPTS_TYPE_PT_GENERATE_BE
7128 | OPTS_TYPE_PT_ADD80
7129 | OPTS_TYPE_PT_ADDBITS15;
7130 kern_type = KERN_TYPE_SHA1;
7131 dgst_size = DGST_SIZE_4_5;
7132 parse_func = sha1_parse_hash;
7133 sort_by_digest = sort_by_digest_4_5;
7134 opti_type = OPTI_TYPE_ZERO_BYTE
7135 | OPTI_TYPE_PRECOMPUTE_INIT
7136 | OPTI_TYPE_PRECOMPUTE_MERKLE
7137 | OPTI_TYPE_EARLY_SKIP
7138 | OPTI_TYPE_NOT_ITERATED
7139 | OPTI_TYPE_NOT_SALTED
7140 | OPTI_TYPE_RAW_HASH;
7141 dgst_pos0 = 3;
7142 dgst_pos1 = 4;
7143 dgst_pos2 = 2;
7144 dgst_pos3 = 1;
7145 break;
7146
7147 case 101: hash_type = HASH_TYPE_SHA1;
7148 salt_type = SALT_TYPE_NONE;
7149 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7150 opts_type = OPTS_TYPE_PT_GENERATE_BE
7151 | OPTS_TYPE_PT_ADD80
7152 | OPTS_TYPE_PT_ADDBITS15;
7153 kern_type = KERN_TYPE_SHA1;
7154 dgst_size = DGST_SIZE_4_5;
7155 parse_func = sha1b64_parse_hash;
7156 sort_by_digest = sort_by_digest_4_5;
7157 opti_type = OPTI_TYPE_ZERO_BYTE
7158 | OPTI_TYPE_PRECOMPUTE_INIT
7159 | OPTI_TYPE_PRECOMPUTE_MERKLE
7160 | OPTI_TYPE_EARLY_SKIP
7161 | OPTI_TYPE_NOT_ITERATED
7162 | OPTI_TYPE_NOT_SALTED
7163 | OPTI_TYPE_RAW_HASH;
7164 dgst_pos0 = 3;
7165 dgst_pos1 = 4;
7166 dgst_pos2 = 2;
7167 dgst_pos3 = 1;
7168 break;
7169
7170 case 110: hash_type = HASH_TYPE_SHA1;
7171 salt_type = SALT_TYPE_INTERN;
7172 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7173 opts_type = OPTS_TYPE_PT_GENERATE_BE
7174 | OPTS_TYPE_ST_ADD80
7175 | OPTS_TYPE_ST_ADDBITS15;
7176 kern_type = KERN_TYPE_SHA1_PWSLT;
7177 dgst_size = DGST_SIZE_4_5;
7178 parse_func = sha1s_parse_hash;
7179 sort_by_digest = sort_by_digest_4_5;
7180 opti_type = OPTI_TYPE_ZERO_BYTE
7181 | OPTI_TYPE_PRECOMPUTE_INIT
7182 | OPTI_TYPE_PRECOMPUTE_MERKLE
7183 | OPTI_TYPE_EARLY_SKIP
7184 | OPTI_TYPE_NOT_ITERATED
7185 | OPTI_TYPE_APPENDED_SALT
7186 | OPTI_TYPE_RAW_HASH;
7187 dgst_pos0 = 3;
7188 dgst_pos1 = 4;
7189 dgst_pos2 = 2;
7190 dgst_pos3 = 1;
7191 break;
7192
7193 case 111: hash_type = HASH_TYPE_SHA1;
7194 salt_type = SALT_TYPE_EMBEDDED;
7195 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7196 opts_type = OPTS_TYPE_PT_GENERATE_BE
7197 | OPTS_TYPE_ST_ADD80
7198 | OPTS_TYPE_ST_ADDBITS15;
7199 kern_type = KERN_TYPE_SHA1_PWSLT;
7200 dgst_size = DGST_SIZE_4_5;
7201 parse_func = sha1b64s_parse_hash;
7202 sort_by_digest = sort_by_digest_4_5;
7203 opti_type = OPTI_TYPE_ZERO_BYTE
7204 | OPTI_TYPE_PRECOMPUTE_INIT
7205 | OPTI_TYPE_PRECOMPUTE_MERKLE
7206 | OPTI_TYPE_EARLY_SKIP
7207 | OPTI_TYPE_NOT_ITERATED
7208 | OPTI_TYPE_APPENDED_SALT
7209 | OPTI_TYPE_RAW_HASH;
7210 dgst_pos0 = 3;
7211 dgst_pos1 = 4;
7212 dgst_pos2 = 2;
7213 dgst_pos3 = 1;
7214 break;
7215
7216 case 112: hash_type = HASH_TYPE_SHA1;
7217 salt_type = SALT_TYPE_INTERN;
7218 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7219 opts_type = OPTS_TYPE_PT_GENERATE_BE
7220 | OPTS_TYPE_ST_ADD80
7221 | OPTS_TYPE_ST_ADDBITS15
7222 | OPTS_TYPE_ST_HEX;
7223 kern_type = KERN_TYPE_SHA1_PWSLT;
7224 dgst_size = DGST_SIZE_4_5;
7225 parse_func = oracles_parse_hash;
7226 sort_by_digest = sort_by_digest_4_5;
7227 opti_type = OPTI_TYPE_ZERO_BYTE
7228 | OPTI_TYPE_PRECOMPUTE_INIT
7229 | OPTI_TYPE_PRECOMPUTE_MERKLE
7230 | OPTI_TYPE_EARLY_SKIP
7231 | OPTI_TYPE_NOT_ITERATED
7232 | OPTI_TYPE_APPENDED_SALT
7233 | OPTI_TYPE_RAW_HASH;
7234 dgst_pos0 = 3;
7235 dgst_pos1 = 4;
7236 dgst_pos2 = 2;
7237 dgst_pos3 = 1;
7238 break;
7239
7240 case 120: hash_type = HASH_TYPE_SHA1;
7241 salt_type = SALT_TYPE_INTERN;
7242 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7243 opts_type = OPTS_TYPE_PT_GENERATE_BE
7244 | OPTS_TYPE_PT_ADD80
7245 | OPTS_TYPE_PT_ADDBITS15;
7246 kern_type = KERN_TYPE_SHA1_SLTPW;
7247 dgst_size = DGST_SIZE_4_5;
7248 parse_func = sha1s_parse_hash;
7249 sort_by_digest = sort_by_digest_4_5;
7250 opti_type = OPTI_TYPE_ZERO_BYTE
7251 | OPTI_TYPE_PRECOMPUTE_INIT
7252 | OPTI_TYPE_PRECOMPUTE_MERKLE
7253 | OPTI_TYPE_EARLY_SKIP
7254 | OPTI_TYPE_NOT_ITERATED
7255 | OPTI_TYPE_PREPENDED_SALT
7256 | OPTI_TYPE_RAW_HASH;
7257 dgst_pos0 = 3;
7258 dgst_pos1 = 4;
7259 dgst_pos2 = 2;
7260 dgst_pos3 = 1;
7261 break;
7262
7263 case 121: hash_type = HASH_TYPE_SHA1;
7264 salt_type = SALT_TYPE_INTERN;
7265 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7266 opts_type = OPTS_TYPE_PT_GENERATE_BE
7267 | OPTS_TYPE_PT_ADD80
7268 | OPTS_TYPE_PT_ADDBITS15
7269 | OPTS_TYPE_ST_LOWER;
7270 kern_type = KERN_TYPE_SHA1_SLTPW;
7271 dgst_size = DGST_SIZE_4_5;
7272 parse_func = smf_parse_hash;
7273 sort_by_digest = sort_by_digest_4_5;
7274 opti_type = OPTI_TYPE_ZERO_BYTE
7275 | OPTI_TYPE_PRECOMPUTE_INIT
7276 | OPTI_TYPE_PRECOMPUTE_MERKLE
7277 | OPTI_TYPE_EARLY_SKIP
7278 | OPTI_TYPE_NOT_ITERATED
7279 | OPTI_TYPE_PREPENDED_SALT
7280 | OPTI_TYPE_RAW_HASH;
7281 dgst_pos0 = 3;
7282 dgst_pos1 = 4;
7283 dgst_pos2 = 2;
7284 dgst_pos3 = 1;
7285 break;
7286
7287 case 122: hash_type = HASH_TYPE_SHA1;
7288 salt_type = SALT_TYPE_EMBEDDED;
7289 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7290 opts_type = OPTS_TYPE_PT_GENERATE_BE
7291 | OPTS_TYPE_PT_ADD80
7292 | OPTS_TYPE_PT_ADDBITS15
7293 | OPTS_TYPE_ST_HEX;
7294 kern_type = KERN_TYPE_SHA1_SLTPW;
7295 dgst_size = DGST_SIZE_4_5;
7296 parse_func = osx1_parse_hash;
7297 sort_by_digest = sort_by_digest_4_5;
7298 opti_type = OPTI_TYPE_ZERO_BYTE
7299 | OPTI_TYPE_PRECOMPUTE_INIT
7300 | OPTI_TYPE_PRECOMPUTE_MERKLE
7301 | OPTI_TYPE_EARLY_SKIP
7302 | OPTI_TYPE_NOT_ITERATED
7303 | OPTI_TYPE_PREPENDED_SALT
7304 | OPTI_TYPE_RAW_HASH;
7305 dgst_pos0 = 3;
7306 dgst_pos1 = 4;
7307 dgst_pos2 = 2;
7308 dgst_pos3 = 1;
7309 break;
7310
7311 case 124: hash_type = HASH_TYPE_SHA1;
7312 salt_type = SALT_TYPE_EMBEDDED;
7313 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7314 opts_type = OPTS_TYPE_PT_GENERATE_BE
7315 | OPTS_TYPE_PT_ADD80
7316 | OPTS_TYPE_PT_ADDBITS15;
7317 kern_type = KERN_TYPE_SHA1_SLTPW;
7318 dgst_size = DGST_SIZE_4_5;
7319 parse_func = djangosha1_parse_hash;
7320 sort_by_digest = sort_by_digest_4_5;
7321 opti_type = OPTI_TYPE_ZERO_BYTE
7322 | OPTI_TYPE_PRECOMPUTE_INIT
7323 | OPTI_TYPE_PRECOMPUTE_MERKLE
7324 | OPTI_TYPE_EARLY_SKIP
7325 | OPTI_TYPE_NOT_ITERATED
7326 | OPTI_TYPE_PREPENDED_SALT
7327 | OPTI_TYPE_RAW_HASH;
7328 dgst_pos0 = 3;
7329 dgst_pos1 = 4;
7330 dgst_pos2 = 2;
7331 dgst_pos3 = 1;
7332 break;
7333
7334 case 130: hash_type = HASH_TYPE_SHA1;
7335 salt_type = SALT_TYPE_INTERN;
7336 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7337 opts_type = OPTS_TYPE_PT_GENERATE_BE
7338 | OPTS_TYPE_PT_UNICODE
7339 | OPTS_TYPE_ST_ADD80
7340 | OPTS_TYPE_ST_ADDBITS15;
7341 kern_type = KERN_TYPE_SHA1_PWUSLT;
7342 dgst_size = DGST_SIZE_4_5;
7343 parse_func = sha1s_parse_hash;
7344 sort_by_digest = sort_by_digest_4_5;
7345 opti_type = OPTI_TYPE_ZERO_BYTE
7346 | OPTI_TYPE_PRECOMPUTE_INIT
7347 | OPTI_TYPE_PRECOMPUTE_MERKLE
7348 | OPTI_TYPE_EARLY_SKIP
7349 | OPTI_TYPE_NOT_ITERATED
7350 | OPTI_TYPE_APPENDED_SALT
7351 | OPTI_TYPE_RAW_HASH;
7352 dgst_pos0 = 3;
7353 dgst_pos1 = 4;
7354 dgst_pos2 = 2;
7355 dgst_pos3 = 1;
7356 break;
7357
7358 case 131: hash_type = HASH_TYPE_SHA1;
7359 salt_type = SALT_TYPE_EMBEDDED;
7360 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7361 opts_type = OPTS_TYPE_PT_GENERATE_BE
7362 | OPTS_TYPE_PT_UNICODE
7363 | OPTS_TYPE_PT_UPPER
7364 | OPTS_TYPE_ST_ADD80
7365 | OPTS_TYPE_ST_ADDBITS15
7366 | OPTS_TYPE_ST_HEX;
7367 kern_type = KERN_TYPE_SHA1_PWUSLT;
7368 dgst_size = DGST_SIZE_4_5;
7369 parse_func = mssql2000_parse_hash;
7370 sort_by_digest = sort_by_digest_4_5;
7371 opti_type = OPTI_TYPE_ZERO_BYTE
7372 | OPTI_TYPE_PRECOMPUTE_INIT
7373 | OPTI_TYPE_PRECOMPUTE_MERKLE
7374 | OPTI_TYPE_EARLY_SKIP
7375 | OPTI_TYPE_NOT_ITERATED
7376 | OPTI_TYPE_APPENDED_SALT
7377 | OPTI_TYPE_RAW_HASH;
7378 dgst_pos0 = 3;
7379 dgst_pos1 = 4;
7380 dgst_pos2 = 2;
7381 dgst_pos3 = 1;
7382 break;
7383
7384 case 132: hash_type = HASH_TYPE_SHA1;
7385 salt_type = SALT_TYPE_EMBEDDED;
7386 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7387 opts_type = OPTS_TYPE_PT_GENERATE_BE
7388 | OPTS_TYPE_PT_UNICODE
7389 | OPTS_TYPE_ST_ADD80
7390 | OPTS_TYPE_ST_ADDBITS15
7391 | OPTS_TYPE_ST_HEX;
7392 kern_type = KERN_TYPE_SHA1_PWUSLT;
7393 dgst_size = DGST_SIZE_4_5;
7394 parse_func = mssql2005_parse_hash;
7395 sort_by_digest = sort_by_digest_4_5;
7396 opti_type = OPTI_TYPE_ZERO_BYTE
7397 | OPTI_TYPE_PRECOMPUTE_INIT
7398 | OPTI_TYPE_PRECOMPUTE_MERKLE
7399 | OPTI_TYPE_EARLY_SKIP
7400 | OPTI_TYPE_NOT_ITERATED
7401 | OPTI_TYPE_APPENDED_SALT
7402 | OPTI_TYPE_RAW_HASH;
7403 dgst_pos0 = 3;
7404 dgst_pos1 = 4;
7405 dgst_pos2 = 2;
7406 dgst_pos3 = 1;
7407 break;
7408
7409 case 133: hash_type = HASH_TYPE_SHA1;
7410 salt_type = SALT_TYPE_EMBEDDED;
7411 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7412 opts_type = OPTS_TYPE_PT_GENERATE_BE
7413 | OPTS_TYPE_PT_UNICODE
7414 | OPTS_TYPE_ST_ADD80
7415 | OPTS_TYPE_ST_ADDBITS15;
7416 kern_type = KERN_TYPE_SHA1_PWUSLT;
7417 dgst_size = DGST_SIZE_4_5;
7418 parse_func = peoplesoft_parse_hash;
7419 sort_by_digest = sort_by_digest_4_5;
7420 opti_type = OPTI_TYPE_ZERO_BYTE
7421 | OPTI_TYPE_PRECOMPUTE_INIT
7422 | OPTI_TYPE_PRECOMPUTE_MERKLE
7423 | OPTI_TYPE_EARLY_SKIP
7424 | OPTI_TYPE_NOT_ITERATED
7425 | OPTI_TYPE_APPENDED_SALT
7426 | OPTI_TYPE_RAW_HASH;
7427 dgst_pos0 = 3;
7428 dgst_pos1 = 4;
7429 dgst_pos2 = 2;
7430 dgst_pos3 = 1;
7431 break;
7432
7433 case 140: hash_type = HASH_TYPE_SHA1;
7434 salt_type = SALT_TYPE_INTERN;
7435 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7436 opts_type = OPTS_TYPE_PT_GENERATE_BE
7437 | OPTS_TYPE_PT_ADD80
7438 | OPTS_TYPE_PT_ADDBITS15
7439 | OPTS_TYPE_PT_UNICODE;
7440 kern_type = KERN_TYPE_SHA1_SLTPWU;
7441 dgst_size = DGST_SIZE_4_5;
7442 parse_func = sha1s_parse_hash;
7443 sort_by_digest = sort_by_digest_4_5;
7444 opti_type = OPTI_TYPE_ZERO_BYTE
7445 | OPTI_TYPE_PRECOMPUTE_INIT
7446 | OPTI_TYPE_PRECOMPUTE_MERKLE
7447 | OPTI_TYPE_EARLY_SKIP
7448 | OPTI_TYPE_NOT_ITERATED
7449 | OPTI_TYPE_PREPENDED_SALT
7450 | OPTI_TYPE_RAW_HASH;
7451 dgst_pos0 = 3;
7452 dgst_pos1 = 4;
7453 dgst_pos2 = 2;
7454 dgst_pos3 = 1;
7455 break;
7456
7457 case 141: hash_type = HASH_TYPE_SHA1;
7458 salt_type = SALT_TYPE_EMBEDDED;
7459 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7460 opts_type = OPTS_TYPE_PT_GENERATE_BE
7461 | OPTS_TYPE_PT_ADD80
7462 | OPTS_TYPE_PT_ADDBITS15
7463 | OPTS_TYPE_PT_UNICODE
7464 | OPTS_TYPE_ST_BASE64;
7465 kern_type = KERN_TYPE_SHA1_SLTPWU;
7466 dgst_size = DGST_SIZE_4_5;
7467 parse_func = episerver_parse_hash;
7468 sort_by_digest = sort_by_digest_4_5;
7469 opti_type = OPTI_TYPE_ZERO_BYTE
7470 | OPTI_TYPE_PRECOMPUTE_INIT
7471 | OPTI_TYPE_PRECOMPUTE_MERKLE
7472 | OPTI_TYPE_EARLY_SKIP
7473 | OPTI_TYPE_NOT_ITERATED
7474 | OPTI_TYPE_PREPENDED_SALT
7475 | OPTI_TYPE_RAW_HASH;
7476 dgst_pos0 = 3;
7477 dgst_pos1 = 4;
7478 dgst_pos2 = 2;
7479 dgst_pos3 = 1;
7480 break;
7481
7482 case 150: hash_type = HASH_TYPE_SHA1;
7483 salt_type = SALT_TYPE_INTERN;
7484 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7485 opts_type = OPTS_TYPE_PT_GENERATE_BE
7486 | OPTS_TYPE_ST_ADD80
7487 | OPTS_TYPE_ST_ADDBITS15;
7488 kern_type = KERN_TYPE_HMACSHA1_PW;
7489 dgst_size = DGST_SIZE_4_5;
7490 parse_func = hmacsha1_parse_hash;
7491 sort_by_digest = sort_by_digest_4_5;
7492 opti_type = OPTI_TYPE_ZERO_BYTE
7493 | OPTI_TYPE_NOT_ITERATED;
7494 dgst_pos0 = 3;
7495 dgst_pos1 = 4;
7496 dgst_pos2 = 2;
7497 dgst_pos3 = 1;
7498 break;
7499
7500 case 160: hash_type = HASH_TYPE_SHA1;
7501 salt_type = SALT_TYPE_INTERN;
7502 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7503 opts_type = OPTS_TYPE_PT_GENERATE_BE
7504 | OPTS_TYPE_PT_ADD80
7505 | OPTS_TYPE_PT_ADDBITS15;
7506 kern_type = KERN_TYPE_HMACSHA1_SLT;
7507 dgst_size = DGST_SIZE_4_5;
7508 parse_func = hmacsha1_parse_hash;
7509 sort_by_digest = sort_by_digest_4_5;
7510 opti_type = OPTI_TYPE_ZERO_BYTE
7511 | OPTI_TYPE_NOT_ITERATED;
7512 dgst_pos0 = 3;
7513 dgst_pos1 = 4;
7514 dgst_pos2 = 2;
7515 dgst_pos3 = 1;
7516 break;
7517
7518 case 190: hash_type = HASH_TYPE_SHA1;
7519 salt_type = SALT_TYPE_NONE;
7520 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7521 opts_type = OPTS_TYPE_PT_GENERATE_BE
7522 | OPTS_TYPE_PT_ADD80
7523 | OPTS_TYPE_PT_ADDBITS15;
7524 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7525 dgst_size = DGST_SIZE_4_5;
7526 parse_func = sha1linkedin_parse_hash;
7527 sort_by_digest = sort_by_digest_4_5;
7528 opti_type = OPTI_TYPE_ZERO_BYTE
7529 | OPTI_TYPE_PRECOMPUTE_INIT
7530 | OPTI_TYPE_EARLY_SKIP
7531 | OPTI_TYPE_NOT_ITERATED
7532 | OPTI_TYPE_NOT_SALTED;
7533 dgst_pos0 = 0;
7534 dgst_pos1 = 4;
7535 dgst_pos2 = 3;
7536 dgst_pos3 = 2;
7537 break;
7538
7539 case 200: hash_type = HASH_TYPE_MYSQL;
7540 salt_type = SALT_TYPE_NONE;
7541 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7542 opts_type = 0;
7543 kern_type = KERN_TYPE_MYSQL;
7544 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7545 parse_func = mysql323_parse_hash;
7546 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7547 opti_type = OPTI_TYPE_ZERO_BYTE;
7548 dgst_pos0 = 0;
7549 dgst_pos1 = 1;
7550 dgst_pos2 = 2;
7551 dgst_pos3 = 3;
7552 break;
7553
7554 case 300: hash_type = HASH_TYPE_SHA1;
7555 salt_type = SALT_TYPE_NONE;
7556 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7557 opts_type = OPTS_TYPE_PT_GENERATE_BE
7558 | OPTS_TYPE_PT_ADD80
7559 | OPTS_TYPE_PT_ADDBITS15;
7560 kern_type = KERN_TYPE_MYSQL41;
7561 dgst_size = DGST_SIZE_4_5;
7562 parse_func = sha1_parse_hash;
7563 sort_by_digest = sort_by_digest_4_5;
7564 opti_type = OPTI_TYPE_ZERO_BYTE
7565 | OPTI_TYPE_PRECOMPUTE_INIT
7566 | OPTI_TYPE_PRECOMPUTE_MERKLE
7567 | OPTI_TYPE_EARLY_SKIP
7568 | OPTI_TYPE_NOT_ITERATED
7569 | OPTI_TYPE_NOT_SALTED;
7570 dgst_pos0 = 3;
7571 dgst_pos1 = 4;
7572 dgst_pos2 = 2;
7573 dgst_pos3 = 1;
7574 break;
7575
7576 case 400: hash_type = HASH_TYPE_MD5;
7577 salt_type = SALT_TYPE_EMBEDDED;
7578 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7579 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7580 kern_type = KERN_TYPE_PHPASS;
7581 dgst_size = DGST_SIZE_4_4;
7582 parse_func = phpass_parse_hash;
7583 sort_by_digest = sort_by_digest_4_4;
7584 opti_type = OPTI_TYPE_ZERO_BYTE;
7585 dgst_pos0 = 0;
7586 dgst_pos1 = 1;
7587 dgst_pos2 = 2;
7588 dgst_pos3 = 3;
7589 break;
7590
7591 case 500: hash_type = HASH_TYPE_MD5;
7592 salt_type = SALT_TYPE_EMBEDDED;
7593 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7594 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7595 kern_type = KERN_TYPE_MD5CRYPT;
7596 dgst_size = DGST_SIZE_4_4;
7597 parse_func = md5crypt_parse_hash;
7598 sort_by_digest = sort_by_digest_4_4;
7599 opti_type = OPTI_TYPE_ZERO_BYTE;
7600 dgst_pos0 = 0;
7601 dgst_pos1 = 1;
7602 dgst_pos2 = 2;
7603 dgst_pos3 = 3;
7604 break;
7605
7606 case 501: hash_type = HASH_TYPE_MD5;
7607 salt_type = SALT_TYPE_EMBEDDED;
7608 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7609 opts_type = OPTS_TYPE_PT_GENERATE_LE
7610 | OPTS_TYPE_HASH_COPY;
7611 kern_type = KERN_TYPE_MD5CRYPT;
7612 dgst_size = DGST_SIZE_4_4;
7613 parse_func = juniper_parse_hash;
7614 sort_by_digest = sort_by_digest_4_4;
7615 opti_type = OPTI_TYPE_ZERO_BYTE;
7616 dgst_pos0 = 0;
7617 dgst_pos1 = 1;
7618 dgst_pos2 = 2;
7619 dgst_pos3 = 3;
7620 break;
7621
7622 case 900: hash_type = HASH_TYPE_MD4;
7623 salt_type = SALT_TYPE_NONE;
7624 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7625 opts_type = OPTS_TYPE_PT_GENERATE_LE
7626 | OPTS_TYPE_PT_ADD80
7627 | OPTS_TYPE_PT_ADDBITS14;
7628 kern_type = KERN_TYPE_MD4;
7629 dgst_size = DGST_SIZE_4_4;
7630 parse_func = md4_parse_hash;
7631 sort_by_digest = sort_by_digest_4_4;
7632 opti_type = OPTI_TYPE_ZERO_BYTE
7633 | OPTI_TYPE_PRECOMPUTE_INIT
7634 | OPTI_TYPE_PRECOMPUTE_MERKLE
7635 | OPTI_TYPE_MEET_IN_MIDDLE
7636 | OPTI_TYPE_EARLY_SKIP
7637 | OPTI_TYPE_NOT_ITERATED
7638 | OPTI_TYPE_NOT_SALTED
7639 | OPTI_TYPE_RAW_HASH;
7640 dgst_pos0 = 0;
7641 dgst_pos1 = 3;
7642 dgst_pos2 = 2;
7643 dgst_pos3 = 1;
7644 break;
7645
7646 case 1000: hash_type = HASH_TYPE_MD4;
7647 salt_type = SALT_TYPE_NONE;
7648 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7649 opts_type = OPTS_TYPE_PT_GENERATE_LE
7650 | OPTS_TYPE_PT_ADD80
7651 | OPTS_TYPE_PT_ADDBITS14
7652 | OPTS_TYPE_PT_UNICODE;
7653 kern_type = KERN_TYPE_MD4_PWU;
7654 dgst_size = DGST_SIZE_4_4;
7655 parse_func = md4_parse_hash;
7656 sort_by_digest = sort_by_digest_4_4;
7657 opti_type = OPTI_TYPE_ZERO_BYTE
7658 | OPTI_TYPE_PRECOMPUTE_INIT
7659 | OPTI_TYPE_PRECOMPUTE_MERKLE
7660 | OPTI_TYPE_MEET_IN_MIDDLE
7661 | OPTI_TYPE_EARLY_SKIP
7662 | OPTI_TYPE_NOT_ITERATED
7663 | OPTI_TYPE_NOT_SALTED
7664 | OPTI_TYPE_RAW_HASH;
7665 dgst_pos0 = 0;
7666 dgst_pos1 = 3;
7667 dgst_pos2 = 2;
7668 dgst_pos3 = 1;
7669 break;
7670
7671 case 1100: hash_type = HASH_TYPE_MD4;
7672 salt_type = SALT_TYPE_INTERN;
7673 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7674 opts_type = OPTS_TYPE_PT_GENERATE_LE
7675 | OPTS_TYPE_PT_ADD80
7676 | OPTS_TYPE_PT_ADDBITS14
7677 | OPTS_TYPE_PT_UNICODE
7678 | OPTS_TYPE_ST_ADD80
7679 | OPTS_TYPE_ST_UNICODE
7680 | OPTS_TYPE_ST_LOWER;
7681 kern_type = KERN_TYPE_MD44_PWUSLT;
7682 dgst_size = DGST_SIZE_4_4;
7683 parse_func = dcc_parse_hash;
7684 sort_by_digest = sort_by_digest_4_4;
7685 opti_type = OPTI_TYPE_ZERO_BYTE
7686 | OPTI_TYPE_PRECOMPUTE_INIT
7687 | OPTI_TYPE_PRECOMPUTE_MERKLE
7688 | OPTI_TYPE_EARLY_SKIP
7689 | OPTI_TYPE_NOT_ITERATED;
7690 dgst_pos0 = 0;
7691 dgst_pos1 = 3;
7692 dgst_pos2 = 2;
7693 dgst_pos3 = 1;
7694 break;
7695
7696 case 1400: hash_type = HASH_TYPE_SHA256;
7697 salt_type = SALT_TYPE_NONE;
7698 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7699 opts_type = OPTS_TYPE_PT_GENERATE_BE
7700 | OPTS_TYPE_PT_ADD80
7701 | OPTS_TYPE_PT_ADDBITS15;
7702 kern_type = KERN_TYPE_SHA256;
7703 dgst_size = DGST_SIZE_4_8;
7704 parse_func = sha256_parse_hash;
7705 sort_by_digest = sort_by_digest_4_8;
7706 opti_type = OPTI_TYPE_ZERO_BYTE
7707 | OPTI_TYPE_PRECOMPUTE_INIT
7708 | OPTI_TYPE_PRECOMPUTE_MERKLE
7709 | OPTI_TYPE_EARLY_SKIP
7710 | OPTI_TYPE_NOT_ITERATED
7711 | OPTI_TYPE_NOT_SALTED
7712 | OPTI_TYPE_RAW_HASH;
7713 dgst_pos0 = 3;
7714 dgst_pos1 = 7;
7715 dgst_pos2 = 2;
7716 dgst_pos3 = 6;
7717 break;
7718
7719 case 1410: hash_type = HASH_TYPE_SHA256;
7720 salt_type = SALT_TYPE_INTERN;
7721 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7722 opts_type = OPTS_TYPE_PT_GENERATE_BE
7723 | OPTS_TYPE_ST_ADD80
7724 | OPTS_TYPE_ST_ADDBITS15;
7725 kern_type = KERN_TYPE_SHA256_PWSLT;
7726 dgst_size = DGST_SIZE_4_8;
7727 parse_func = sha256s_parse_hash;
7728 sort_by_digest = sort_by_digest_4_8;
7729 opti_type = OPTI_TYPE_ZERO_BYTE
7730 | OPTI_TYPE_PRECOMPUTE_INIT
7731 | OPTI_TYPE_PRECOMPUTE_MERKLE
7732 | OPTI_TYPE_EARLY_SKIP
7733 | OPTI_TYPE_NOT_ITERATED
7734 | OPTI_TYPE_APPENDED_SALT
7735 | OPTI_TYPE_RAW_HASH;
7736 dgst_pos0 = 3;
7737 dgst_pos1 = 7;
7738 dgst_pos2 = 2;
7739 dgst_pos3 = 6;
7740 break;
7741
7742 case 1420: hash_type = HASH_TYPE_SHA256;
7743 salt_type = SALT_TYPE_INTERN;
7744 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7745 opts_type = OPTS_TYPE_PT_GENERATE_BE
7746 | OPTS_TYPE_PT_ADD80
7747 | OPTS_TYPE_PT_ADDBITS15;
7748 kern_type = KERN_TYPE_SHA256_SLTPW;
7749 dgst_size = DGST_SIZE_4_8;
7750 parse_func = sha256s_parse_hash;
7751 sort_by_digest = sort_by_digest_4_8;
7752 opti_type = OPTI_TYPE_ZERO_BYTE
7753 | OPTI_TYPE_PRECOMPUTE_INIT
7754 | OPTI_TYPE_PRECOMPUTE_MERKLE
7755 | OPTI_TYPE_EARLY_SKIP
7756 | OPTI_TYPE_NOT_ITERATED
7757 | OPTI_TYPE_PREPENDED_SALT
7758 | OPTI_TYPE_RAW_HASH;
7759 dgst_pos0 = 3;
7760 dgst_pos1 = 7;
7761 dgst_pos2 = 2;
7762 dgst_pos3 = 6;
7763 break;
7764
7765 case 1421: hash_type = HASH_TYPE_SHA256;
7766 salt_type = SALT_TYPE_EMBEDDED;
7767 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7768 opts_type = OPTS_TYPE_PT_GENERATE_BE
7769 | OPTS_TYPE_PT_ADD80
7770 | OPTS_TYPE_PT_ADDBITS15;
7771 kern_type = KERN_TYPE_SHA256_SLTPW;
7772 dgst_size = DGST_SIZE_4_8;
7773 parse_func = hmailserver_parse_hash;
7774 sort_by_digest = sort_by_digest_4_8;
7775 opti_type = OPTI_TYPE_ZERO_BYTE
7776 | OPTI_TYPE_PRECOMPUTE_INIT
7777 | OPTI_TYPE_PRECOMPUTE_MERKLE
7778 | OPTI_TYPE_EARLY_SKIP
7779 | OPTI_TYPE_NOT_ITERATED
7780 | OPTI_TYPE_PREPENDED_SALT
7781 | OPTI_TYPE_RAW_HASH;
7782 dgst_pos0 = 3;
7783 dgst_pos1 = 7;
7784 dgst_pos2 = 2;
7785 dgst_pos3 = 6;
7786 break;
7787
7788 case 1430: hash_type = HASH_TYPE_SHA256;
7789 salt_type = SALT_TYPE_INTERN;
7790 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7791 opts_type = OPTS_TYPE_PT_GENERATE_BE
7792 | OPTS_TYPE_PT_UNICODE
7793 | OPTS_TYPE_ST_ADD80
7794 | OPTS_TYPE_ST_ADDBITS15;
7795 kern_type = KERN_TYPE_SHA256_PWUSLT;
7796 dgst_size = DGST_SIZE_4_8;
7797 parse_func = sha256s_parse_hash;
7798 sort_by_digest = sort_by_digest_4_8;
7799 opti_type = OPTI_TYPE_ZERO_BYTE
7800 | OPTI_TYPE_PRECOMPUTE_INIT
7801 | OPTI_TYPE_PRECOMPUTE_MERKLE
7802 | OPTI_TYPE_EARLY_SKIP
7803 | OPTI_TYPE_NOT_ITERATED
7804 | OPTI_TYPE_APPENDED_SALT
7805 | OPTI_TYPE_RAW_HASH;
7806 dgst_pos0 = 3;
7807 dgst_pos1 = 7;
7808 dgst_pos2 = 2;
7809 dgst_pos3 = 6;
7810 break;
7811
7812 case 1440: hash_type = HASH_TYPE_SHA256;
7813 salt_type = SALT_TYPE_INTERN;
7814 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7815 opts_type = OPTS_TYPE_PT_GENERATE_BE
7816 | OPTS_TYPE_PT_ADD80
7817 | OPTS_TYPE_PT_ADDBITS15
7818 | OPTS_TYPE_PT_UNICODE;
7819 kern_type = KERN_TYPE_SHA256_SLTPWU;
7820 dgst_size = DGST_SIZE_4_8;
7821 parse_func = sha256s_parse_hash;
7822 sort_by_digest = sort_by_digest_4_8;
7823 opti_type = OPTI_TYPE_ZERO_BYTE
7824 | OPTI_TYPE_PRECOMPUTE_INIT
7825 | OPTI_TYPE_PRECOMPUTE_MERKLE
7826 | OPTI_TYPE_EARLY_SKIP
7827 | OPTI_TYPE_NOT_ITERATED
7828 | OPTI_TYPE_PREPENDED_SALT
7829 | OPTI_TYPE_RAW_HASH;
7830 dgst_pos0 = 3;
7831 dgst_pos1 = 7;
7832 dgst_pos2 = 2;
7833 dgst_pos3 = 6;
7834 break;
7835
7836 case 1441: hash_type = HASH_TYPE_SHA256;
7837 salt_type = SALT_TYPE_EMBEDDED;
7838 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7839 opts_type = OPTS_TYPE_PT_GENERATE_BE
7840 | OPTS_TYPE_PT_ADD80
7841 | OPTS_TYPE_PT_ADDBITS15
7842 | OPTS_TYPE_PT_UNICODE
7843 | OPTS_TYPE_ST_BASE64;
7844 kern_type = KERN_TYPE_SHA256_SLTPWU;
7845 dgst_size = DGST_SIZE_4_8;
7846 parse_func = episerver4_parse_hash;
7847 sort_by_digest = sort_by_digest_4_8;
7848 opti_type = OPTI_TYPE_ZERO_BYTE
7849 | OPTI_TYPE_PRECOMPUTE_INIT
7850 | OPTI_TYPE_PRECOMPUTE_MERKLE
7851 | OPTI_TYPE_EARLY_SKIP
7852 | OPTI_TYPE_NOT_ITERATED
7853 | OPTI_TYPE_PREPENDED_SALT
7854 | OPTI_TYPE_RAW_HASH;
7855 dgst_pos0 = 3;
7856 dgst_pos1 = 7;
7857 dgst_pos2 = 2;
7858 dgst_pos3 = 6;
7859 break;
7860
7861 case 1450: hash_type = HASH_TYPE_SHA256;
7862 salt_type = SALT_TYPE_INTERN;
7863 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7864 opts_type = OPTS_TYPE_PT_GENERATE_BE
7865 | OPTS_TYPE_ST_ADD80;
7866 kern_type = KERN_TYPE_HMACSHA256_PW;
7867 dgst_size = DGST_SIZE_4_8;
7868 parse_func = hmacsha256_parse_hash;
7869 sort_by_digest = sort_by_digest_4_8;
7870 opti_type = OPTI_TYPE_ZERO_BYTE
7871 | OPTI_TYPE_NOT_ITERATED;
7872 dgst_pos0 = 3;
7873 dgst_pos1 = 7;
7874 dgst_pos2 = 2;
7875 dgst_pos3 = 6;
7876 break;
7877
7878 case 1460: hash_type = HASH_TYPE_SHA256;
7879 salt_type = SALT_TYPE_INTERN;
7880 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7881 opts_type = OPTS_TYPE_PT_GENERATE_BE
7882 | OPTS_TYPE_PT_ADD80
7883 | OPTS_TYPE_PT_ADDBITS15;
7884 kern_type = KERN_TYPE_HMACSHA256_SLT;
7885 dgst_size = DGST_SIZE_4_8;
7886 parse_func = hmacsha256_parse_hash;
7887 sort_by_digest = sort_by_digest_4_8;
7888 opti_type = OPTI_TYPE_ZERO_BYTE
7889 | OPTI_TYPE_NOT_ITERATED;
7890 dgst_pos0 = 3;
7891 dgst_pos1 = 7;
7892 dgst_pos2 = 2;
7893 dgst_pos3 = 6;
7894 break;
7895
7896 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7897 salt_type = SALT_TYPE_EMBEDDED;
7898 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7899 opts_type = OPTS_TYPE_PT_GENERATE_LE
7900 | OPTS_TYPE_PT_BITSLICE;
7901 kern_type = KERN_TYPE_DESCRYPT;
7902 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7903 parse_func = descrypt_parse_hash;
7904 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7905 opti_type = OPTI_TYPE_ZERO_BYTE
7906 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7907 dgst_pos0 = 0;
7908 dgst_pos1 = 1;
7909 dgst_pos2 = 2;
7910 dgst_pos3 = 3;
7911 break;
7912
7913 case 1600: hash_type = HASH_TYPE_MD5;
7914 salt_type = SALT_TYPE_EMBEDDED;
7915 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7916 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7917 kern_type = KERN_TYPE_APR1CRYPT;
7918 dgst_size = DGST_SIZE_4_4;
7919 parse_func = md5apr1_parse_hash;
7920 sort_by_digest = sort_by_digest_4_4;
7921 opti_type = OPTI_TYPE_ZERO_BYTE;
7922 dgst_pos0 = 0;
7923 dgst_pos1 = 1;
7924 dgst_pos2 = 2;
7925 dgst_pos3 = 3;
7926 break;
7927
7928 case 1700: hash_type = HASH_TYPE_SHA512;
7929 salt_type = SALT_TYPE_NONE;
7930 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7931 opts_type = OPTS_TYPE_PT_GENERATE_BE
7932 | OPTS_TYPE_PT_ADD80
7933 | OPTS_TYPE_PT_ADDBITS15;
7934 kern_type = KERN_TYPE_SHA512;
7935 dgst_size = DGST_SIZE_8_8;
7936 parse_func = sha512_parse_hash;
7937 sort_by_digest = sort_by_digest_8_8;
7938 opti_type = OPTI_TYPE_ZERO_BYTE
7939 | OPTI_TYPE_PRECOMPUTE_INIT
7940 | OPTI_TYPE_PRECOMPUTE_MERKLE
7941 | OPTI_TYPE_EARLY_SKIP
7942 | OPTI_TYPE_NOT_ITERATED
7943 | OPTI_TYPE_NOT_SALTED
7944 | OPTI_TYPE_USES_BITS_64
7945 | OPTI_TYPE_RAW_HASH;
7946 dgst_pos0 = 14;
7947 dgst_pos1 = 15;
7948 dgst_pos2 = 6;
7949 dgst_pos3 = 7;
7950 break;
7951
7952 case 1710: hash_type = HASH_TYPE_SHA512;
7953 salt_type = SALT_TYPE_INTERN;
7954 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7955 opts_type = OPTS_TYPE_PT_GENERATE_BE
7956 | OPTS_TYPE_ST_ADD80
7957 | OPTS_TYPE_ST_ADDBITS15;
7958 kern_type = KERN_TYPE_SHA512_PWSLT;
7959 dgst_size = DGST_SIZE_8_8;
7960 parse_func = sha512s_parse_hash;
7961 sort_by_digest = sort_by_digest_8_8;
7962 opti_type = OPTI_TYPE_ZERO_BYTE
7963 | OPTI_TYPE_PRECOMPUTE_INIT
7964 | OPTI_TYPE_PRECOMPUTE_MERKLE
7965 | OPTI_TYPE_EARLY_SKIP
7966 | OPTI_TYPE_NOT_ITERATED
7967 | OPTI_TYPE_APPENDED_SALT
7968 | OPTI_TYPE_USES_BITS_64
7969 | OPTI_TYPE_RAW_HASH;
7970 dgst_pos0 = 14;
7971 dgst_pos1 = 15;
7972 dgst_pos2 = 6;
7973 dgst_pos3 = 7;
7974 break;
7975
7976 case 1711: hash_type = HASH_TYPE_SHA512;
7977 salt_type = SALT_TYPE_EMBEDDED;
7978 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7979 opts_type = OPTS_TYPE_PT_GENERATE_BE
7980 | OPTS_TYPE_ST_ADD80
7981 | OPTS_TYPE_ST_ADDBITS15;
7982 kern_type = KERN_TYPE_SHA512_PWSLT;
7983 dgst_size = DGST_SIZE_8_8;
7984 parse_func = sha512b64s_parse_hash;
7985 sort_by_digest = sort_by_digest_8_8;
7986 opti_type = OPTI_TYPE_ZERO_BYTE
7987 | OPTI_TYPE_PRECOMPUTE_INIT
7988 | OPTI_TYPE_PRECOMPUTE_MERKLE
7989 | OPTI_TYPE_EARLY_SKIP
7990 | OPTI_TYPE_NOT_ITERATED
7991 | OPTI_TYPE_APPENDED_SALT
7992 | OPTI_TYPE_USES_BITS_64
7993 | OPTI_TYPE_RAW_HASH;
7994 dgst_pos0 = 14;
7995 dgst_pos1 = 15;
7996 dgst_pos2 = 6;
7997 dgst_pos3 = 7;
7998 break;
7999
8000 case 1720: hash_type = HASH_TYPE_SHA512;
8001 salt_type = SALT_TYPE_INTERN;
8002 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8003 opts_type = OPTS_TYPE_PT_GENERATE_BE
8004 | OPTS_TYPE_PT_ADD80
8005 | OPTS_TYPE_PT_ADDBITS15;
8006 kern_type = KERN_TYPE_SHA512_SLTPW;
8007 dgst_size = DGST_SIZE_8_8;
8008 parse_func = sha512s_parse_hash;
8009 sort_by_digest = sort_by_digest_8_8;
8010 opti_type = OPTI_TYPE_ZERO_BYTE
8011 | OPTI_TYPE_PRECOMPUTE_INIT
8012 | OPTI_TYPE_PRECOMPUTE_MERKLE
8013 | OPTI_TYPE_EARLY_SKIP
8014 | OPTI_TYPE_NOT_ITERATED
8015 | OPTI_TYPE_PREPENDED_SALT
8016 | OPTI_TYPE_USES_BITS_64
8017 | OPTI_TYPE_RAW_HASH;
8018 dgst_pos0 = 14;
8019 dgst_pos1 = 15;
8020 dgst_pos2 = 6;
8021 dgst_pos3 = 7;
8022 break;
8023
8024 case 1722: hash_type = HASH_TYPE_SHA512;
8025 salt_type = SALT_TYPE_EMBEDDED;
8026 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8027 opts_type = OPTS_TYPE_PT_GENERATE_BE
8028 | OPTS_TYPE_PT_ADD80
8029 | OPTS_TYPE_PT_ADDBITS15
8030 | OPTS_TYPE_ST_HEX;
8031 kern_type = KERN_TYPE_SHA512_SLTPW;
8032 dgst_size = DGST_SIZE_8_8;
8033 parse_func = osx512_parse_hash;
8034 sort_by_digest = sort_by_digest_8_8;
8035 opti_type = OPTI_TYPE_ZERO_BYTE
8036 | OPTI_TYPE_PRECOMPUTE_INIT
8037 | OPTI_TYPE_PRECOMPUTE_MERKLE
8038 | OPTI_TYPE_EARLY_SKIP
8039 | OPTI_TYPE_NOT_ITERATED
8040 | OPTI_TYPE_PREPENDED_SALT
8041 | OPTI_TYPE_USES_BITS_64
8042 | OPTI_TYPE_RAW_HASH;
8043 dgst_pos0 = 14;
8044 dgst_pos1 = 15;
8045 dgst_pos2 = 6;
8046 dgst_pos3 = 7;
8047 break;
8048
8049 case 1730: hash_type = HASH_TYPE_SHA512;
8050 salt_type = SALT_TYPE_INTERN;
8051 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8052 opts_type = OPTS_TYPE_PT_GENERATE_BE
8053 | OPTS_TYPE_PT_UNICODE
8054 | OPTS_TYPE_ST_ADD80
8055 | OPTS_TYPE_ST_ADDBITS15;
8056 kern_type = KERN_TYPE_SHA512_PWSLTU;
8057 dgst_size = DGST_SIZE_8_8;
8058 parse_func = sha512s_parse_hash;
8059 sort_by_digest = sort_by_digest_8_8;
8060 opti_type = OPTI_TYPE_ZERO_BYTE
8061 | OPTI_TYPE_PRECOMPUTE_INIT
8062 | OPTI_TYPE_PRECOMPUTE_MERKLE
8063 | OPTI_TYPE_EARLY_SKIP
8064 | OPTI_TYPE_NOT_ITERATED
8065 | OPTI_TYPE_APPENDED_SALT
8066 | OPTI_TYPE_USES_BITS_64
8067 | OPTI_TYPE_RAW_HASH;
8068 dgst_pos0 = 14;
8069 dgst_pos1 = 15;
8070 dgst_pos2 = 6;
8071 dgst_pos3 = 7;
8072 break;
8073
8074 case 1731: hash_type = HASH_TYPE_SHA512;
8075 salt_type = SALT_TYPE_EMBEDDED;
8076 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8077 opts_type = OPTS_TYPE_PT_GENERATE_BE
8078 | OPTS_TYPE_PT_UNICODE
8079 | OPTS_TYPE_ST_ADD80
8080 | OPTS_TYPE_ST_ADDBITS15
8081 | OPTS_TYPE_ST_HEX;
8082 kern_type = KERN_TYPE_SHA512_PWSLTU;
8083 dgst_size = DGST_SIZE_8_8;
8084 parse_func = mssql2012_parse_hash;
8085 sort_by_digest = sort_by_digest_8_8;
8086 opti_type = OPTI_TYPE_ZERO_BYTE
8087 | OPTI_TYPE_PRECOMPUTE_INIT
8088 | OPTI_TYPE_PRECOMPUTE_MERKLE
8089 | OPTI_TYPE_EARLY_SKIP
8090 | OPTI_TYPE_NOT_ITERATED
8091 | OPTI_TYPE_APPENDED_SALT
8092 | OPTI_TYPE_USES_BITS_64
8093 | OPTI_TYPE_RAW_HASH;
8094 dgst_pos0 = 14;
8095 dgst_pos1 = 15;
8096 dgst_pos2 = 6;
8097 dgst_pos3 = 7;
8098 break;
8099
8100 case 1740: hash_type = HASH_TYPE_SHA512;
8101 salt_type = SALT_TYPE_INTERN;
8102 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8103 opts_type = OPTS_TYPE_PT_GENERATE_BE
8104 | OPTS_TYPE_PT_ADD80
8105 | OPTS_TYPE_PT_ADDBITS15
8106 | OPTS_TYPE_PT_UNICODE;
8107 kern_type = KERN_TYPE_SHA512_SLTPWU;
8108 dgst_size = DGST_SIZE_8_8;
8109 parse_func = sha512s_parse_hash;
8110 sort_by_digest = sort_by_digest_8_8;
8111 opti_type = OPTI_TYPE_ZERO_BYTE
8112 | OPTI_TYPE_PRECOMPUTE_INIT
8113 | OPTI_TYPE_PRECOMPUTE_MERKLE
8114 | OPTI_TYPE_EARLY_SKIP
8115 | OPTI_TYPE_NOT_ITERATED
8116 | OPTI_TYPE_PREPENDED_SALT
8117 | OPTI_TYPE_USES_BITS_64
8118 | OPTI_TYPE_RAW_HASH;
8119 dgst_pos0 = 14;
8120 dgst_pos1 = 15;
8121 dgst_pos2 = 6;
8122 dgst_pos3 = 7;
8123 break;
8124
8125 case 1750: hash_type = HASH_TYPE_SHA512;
8126 salt_type = SALT_TYPE_INTERN;
8127 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8128 opts_type = OPTS_TYPE_PT_GENERATE_BE
8129 | OPTS_TYPE_ST_ADD80;
8130 kern_type = KERN_TYPE_HMACSHA512_PW;
8131 dgst_size = DGST_SIZE_8_8;
8132 parse_func = hmacsha512_parse_hash;
8133 sort_by_digest = sort_by_digest_8_8;
8134 opti_type = OPTI_TYPE_ZERO_BYTE
8135 | OPTI_TYPE_USES_BITS_64
8136 | OPTI_TYPE_NOT_ITERATED;
8137 dgst_pos0 = 14;
8138 dgst_pos1 = 15;
8139 dgst_pos2 = 6;
8140 dgst_pos3 = 7;
8141 break;
8142
8143 case 1760: hash_type = HASH_TYPE_SHA512;
8144 salt_type = SALT_TYPE_INTERN;
8145 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8146 opts_type = OPTS_TYPE_PT_GENERATE_BE
8147 | OPTS_TYPE_PT_ADD80
8148 | OPTS_TYPE_PT_ADDBITS15;
8149 kern_type = KERN_TYPE_HMACSHA512_SLT;
8150 dgst_size = DGST_SIZE_8_8;
8151 parse_func = hmacsha512_parse_hash;
8152 sort_by_digest = sort_by_digest_8_8;
8153 opti_type = OPTI_TYPE_ZERO_BYTE
8154 | OPTI_TYPE_USES_BITS_64
8155 | OPTI_TYPE_NOT_ITERATED;
8156 dgst_pos0 = 14;
8157 dgst_pos1 = 15;
8158 dgst_pos2 = 6;
8159 dgst_pos3 = 7;
8160 break;
8161
8162 case 1800: hash_type = HASH_TYPE_SHA512;
8163 salt_type = SALT_TYPE_EMBEDDED;
8164 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8165 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8166 kern_type = KERN_TYPE_SHA512CRYPT;
8167 dgst_size = DGST_SIZE_8_8;
8168 parse_func = sha512crypt_parse_hash;
8169 sort_by_digest = sort_by_digest_8_8;
8170 opti_type = OPTI_TYPE_ZERO_BYTE
8171 | OPTI_TYPE_USES_BITS_64;
8172 dgst_pos0 = 0;
8173 dgst_pos1 = 1;
8174 dgst_pos2 = 2;
8175 dgst_pos3 = 3;
8176 break;
8177
8178 case 2100: hash_type = HASH_TYPE_DCC2;
8179 salt_type = SALT_TYPE_EMBEDDED;
8180 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8181 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8182 | OPTS_TYPE_ST_LOWER
8183 | OPTS_TYPE_ST_UNICODE;
8184 kern_type = KERN_TYPE_DCC2;
8185 dgst_size = DGST_SIZE_4_4;
8186 parse_func = dcc2_parse_hash;
8187 sort_by_digest = sort_by_digest_4_4;
8188 opti_type = OPTI_TYPE_ZERO_BYTE;
8189 dgst_pos0 = 0;
8190 dgst_pos1 = 1;
8191 dgst_pos2 = 2;
8192 dgst_pos3 = 3;
8193 break;
8194
8195 case 2400: hash_type = HASH_TYPE_MD5;
8196 salt_type = SALT_TYPE_NONE;
8197 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8198 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8199 kern_type = KERN_TYPE_MD5PIX;
8200 dgst_size = DGST_SIZE_4_4;
8201 parse_func = md5pix_parse_hash;
8202 sort_by_digest = sort_by_digest_4_4;
8203 opti_type = OPTI_TYPE_ZERO_BYTE
8204 | OPTI_TYPE_PRECOMPUTE_INIT
8205 | OPTI_TYPE_PRECOMPUTE_MERKLE
8206 | OPTI_TYPE_EARLY_SKIP
8207 | OPTI_TYPE_NOT_ITERATED
8208 | OPTI_TYPE_NOT_SALTED;
8209 dgst_pos0 = 0;
8210 dgst_pos1 = 3;
8211 dgst_pos2 = 2;
8212 dgst_pos3 = 1;
8213 break;
8214
8215 case 2410: hash_type = HASH_TYPE_MD5;
8216 salt_type = SALT_TYPE_INTERN;
8217 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8218 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8219 kern_type = KERN_TYPE_MD5ASA;
8220 dgst_size = DGST_SIZE_4_4;
8221 parse_func = md5asa_parse_hash;
8222 sort_by_digest = sort_by_digest_4_4;
8223 opti_type = OPTI_TYPE_ZERO_BYTE
8224 | OPTI_TYPE_PRECOMPUTE_INIT
8225 | OPTI_TYPE_PRECOMPUTE_MERKLE
8226 | OPTI_TYPE_EARLY_SKIP
8227 | OPTI_TYPE_NOT_ITERATED;
8228 dgst_pos0 = 0;
8229 dgst_pos1 = 3;
8230 dgst_pos2 = 2;
8231 dgst_pos3 = 1;
8232 break;
8233
8234 case 2500: hash_type = HASH_TYPE_WPA;
8235 salt_type = SALT_TYPE_EMBEDDED;
8236 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8237 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8238 kern_type = KERN_TYPE_WPA;
8239 dgst_size = DGST_SIZE_4_4;
8240 parse_func = wpa_parse_hash;
8241 sort_by_digest = sort_by_digest_4_4;
8242 opti_type = OPTI_TYPE_ZERO_BYTE;
8243 dgst_pos0 = 0;
8244 dgst_pos1 = 1;
8245 dgst_pos2 = 2;
8246 dgst_pos3 = 3;
8247 break;
8248
8249 case 2600: hash_type = HASH_TYPE_MD5;
8250 salt_type = SALT_TYPE_VIRTUAL;
8251 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8252 opts_type = OPTS_TYPE_PT_GENERATE_LE
8253 | OPTS_TYPE_PT_ADD80
8254 | OPTS_TYPE_PT_ADDBITS14
8255 | OPTS_TYPE_ST_ADD80;
8256 kern_type = KERN_TYPE_MD55_PWSLT1;
8257 dgst_size = DGST_SIZE_4_4;
8258 parse_func = md5md5_parse_hash;
8259 sort_by_digest = sort_by_digest_4_4;
8260 opti_type = OPTI_TYPE_ZERO_BYTE
8261 | OPTI_TYPE_PRECOMPUTE_INIT
8262 | OPTI_TYPE_PRECOMPUTE_MERKLE
8263 | OPTI_TYPE_EARLY_SKIP;
8264 dgst_pos0 = 0;
8265 dgst_pos1 = 3;
8266 dgst_pos2 = 2;
8267 dgst_pos3 = 1;
8268 break;
8269
8270 case 2611: hash_type = HASH_TYPE_MD5;
8271 salt_type = SALT_TYPE_INTERN;
8272 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8273 opts_type = OPTS_TYPE_PT_GENERATE_LE
8274 | OPTS_TYPE_PT_ADD80
8275 | OPTS_TYPE_PT_ADDBITS14
8276 | OPTS_TYPE_ST_ADD80;
8277 kern_type = KERN_TYPE_MD55_PWSLT1;
8278 dgst_size = DGST_SIZE_4_4;
8279 parse_func = vb3_parse_hash;
8280 sort_by_digest = sort_by_digest_4_4;
8281 opti_type = OPTI_TYPE_ZERO_BYTE
8282 | OPTI_TYPE_PRECOMPUTE_INIT
8283 | OPTI_TYPE_PRECOMPUTE_MERKLE
8284 | OPTI_TYPE_EARLY_SKIP;
8285 dgst_pos0 = 0;
8286 dgst_pos1 = 3;
8287 dgst_pos2 = 2;
8288 dgst_pos3 = 1;
8289 break;
8290
8291 case 2612: hash_type = HASH_TYPE_MD5;
8292 salt_type = SALT_TYPE_EMBEDDED;
8293 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8294 opts_type = OPTS_TYPE_PT_GENERATE_LE
8295 | OPTS_TYPE_PT_ADD80
8296 | OPTS_TYPE_PT_ADDBITS14
8297 | OPTS_TYPE_ST_ADD80
8298 | OPTS_TYPE_ST_HEX;
8299 kern_type = KERN_TYPE_MD55_PWSLT1;
8300 dgst_size = DGST_SIZE_4_4;
8301 parse_func = phps_parse_hash;
8302 sort_by_digest = sort_by_digest_4_4;
8303 opti_type = OPTI_TYPE_ZERO_BYTE
8304 | OPTI_TYPE_PRECOMPUTE_INIT
8305 | OPTI_TYPE_PRECOMPUTE_MERKLE
8306 | OPTI_TYPE_EARLY_SKIP;
8307 dgst_pos0 = 0;
8308 dgst_pos1 = 3;
8309 dgst_pos2 = 2;
8310 dgst_pos3 = 1;
8311 break;
8312
8313 case 2711: hash_type = HASH_TYPE_MD5;
8314 salt_type = SALT_TYPE_INTERN;
8315 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8316 opts_type = OPTS_TYPE_PT_GENERATE_LE
8317 | OPTS_TYPE_PT_ADD80
8318 | OPTS_TYPE_PT_ADDBITS14
8319 | OPTS_TYPE_ST_ADD80;
8320 kern_type = KERN_TYPE_MD55_PWSLT2;
8321 dgst_size = DGST_SIZE_4_4;
8322 parse_func = vb30_parse_hash;
8323 sort_by_digest = sort_by_digest_4_4;
8324 opti_type = OPTI_TYPE_ZERO_BYTE
8325 | OPTI_TYPE_PRECOMPUTE_INIT
8326 | OPTI_TYPE_EARLY_SKIP;
8327 dgst_pos0 = 0;
8328 dgst_pos1 = 3;
8329 dgst_pos2 = 2;
8330 dgst_pos3 = 1;
8331 break;
8332
8333 case 2811: hash_type = HASH_TYPE_MD5;
8334 salt_type = SALT_TYPE_INTERN;
8335 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8336 opts_type = OPTS_TYPE_PT_GENERATE_LE
8337 | OPTS_TYPE_PT_ADD80
8338 | OPTS_TYPE_PT_ADDBITS14;
8339 kern_type = KERN_TYPE_MD55_SLTPW;
8340 dgst_size = DGST_SIZE_4_4;
8341 parse_func = ipb2_parse_hash;
8342 sort_by_digest = sort_by_digest_4_4;
8343 opti_type = OPTI_TYPE_ZERO_BYTE
8344 | OPTI_TYPE_PRECOMPUTE_INIT
8345 | OPTI_TYPE_EARLY_SKIP;
8346 dgst_pos0 = 0;
8347 dgst_pos1 = 3;
8348 dgst_pos2 = 2;
8349 dgst_pos3 = 1;
8350 break;
8351
8352 case 3000: hash_type = HASH_TYPE_LM;
8353 salt_type = SALT_TYPE_NONE;
8354 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8355 opts_type = OPTS_TYPE_PT_GENERATE_LE
8356 | OPTS_TYPE_PT_UPPER
8357 | OPTS_TYPE_PT_BITSLICE;
8358 kern_type = KERN_TYPE_LM;
8359 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8360 parse_func = lm_parse_hash;
8361 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8362 opti_type = OPTI_TYPE_ZERO_BYTE
8363 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8364 dgst_pos0 = 0;
8365 dgst_pos1 = 1;
8366 dgst_pos2 = 2;
8367 dgst_pos3 = 3;
8368 break;
8369
8370 case 3100: hash_type = HASH_TYPE_ORACLEH;
8371 salt_type = SALT_TYPE_INTERN;
8372 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8373 opts_type = OPTS_TYPE_PT_GENERATE_LE
8374 | OPTS_TYPE_PT_UPPER
8375 | OPTS_TYPE_ST_UPPER;
8376 kern_type = KERN_TYPE_ORACLEH;
8377 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8378 parse_func = oracleh_parse_hash;
8379 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8380 opti_type = OPTI_TYPE_ZERO_BYTE;
8381 dgst_pos0 = 0;
8382 dgst_pos1 = 1;
8383 dgst_pos2 = 2;
8384 dgst_pos3 = 3;
8385 break;
8386
8387 case 3200: hash_type = HASH_TYPE_BCRYPT;
8388 salt_type = SALT_TYPE_EMBEDDED;
8389 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8390 opts_type = OPTS_TYPE_PT_GENERATE_LE
8391 | OPTS_TYPE_ST_GENERATE_LE;
8392 kern_type = KERN_TYPE_BCRYPT;
8393 dgst_size = DGST_SIZE_4_6;
8394 parse_func = bcrypt_parse_hash;
8395 sort_by_digest = sort_by_digest_4_6;
8396 opti_type = OPTI_TYPE_ZERO_BYTE;
8397 dgst_pos0 = 0;
8398 dgst_pos1 = 1;
8399 dgst_pos2 = 2;
8400 dgst_pos3 = 3;
8401 break;
8402
8403 case 3710: hash_type = HASH_TYPE_MD5;
8404 salt_type = SALT_TYPE_INTERN;
8405 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8406 opts_type = OPTS_TYPE_PT_GENERATE_LE
8407 | OPTS_TYPE_PT_ADD80
8408 | OPTS_TYPE_PT_ADDBITS14;
8409 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8410 dgst_size = DGST_SIZE_4_4;
8411 parse_func = md5s_parse_hash;
8412 sort_by_digest = sort_by_digest_4_4;
8413 opti_type = OPTI_TYPE_ZERO_BYTE
8414 | OPTI_TYPE_PRECOMPUTE_INIT
8415 | OPTI_TYPE_PRECOMPUTE_MERKLE
8416 | OPTI_TYPE_EARLY_SKIP;
8417 dgst_pos0 = 0;
8418 dgst_pos1 = 3;
8419 dgst_pos2 = 2;
8420 dgst_pos3 = 1;
8421 break;
8422
8423 case 3711: hash_type = HASH_TYPE_MD5;
8424 salt_type = SALT_TYPE_EMBEDDED;
8425 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8426 opts_type = OPTS_TYPE_PT_GENERATE_LE
8427 | OPTS_TYPE_PT_ADD80
8428 | OPTS_TYPE_PT_ADDBITS14;
8429 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8430 dgst_size = DGST_SIZE_4_4;
8431 parse_func = mediawiki_b_parse_hash;
8432 sort_by_digest = sort_by_digest_4_4;
8433 opti_type = OPTI_TYPE_ZERO_BYTE
8434 | OPTI_TYPE_PRECOMPUTE_INIT
8435 | OPTI_TYPE_PRECOMPUTE_MERKLE
8436 | OPTI_TYPE_EARLY_SKIP;
8437 dgst_pos0 = 0;
8438 dgst_pos1 = 3;
8439 dgst_pos2 = 2;
8440 dgst_pos3 = 1;
8441 break;
8442
8443 case 3800: hash_type = HASH_TYPE_MD5;
8444 salt_type = SALT_TYPE_INTERN;
8445 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8446 opts_type = OPTS_TYPE_PT_GENERATE_LE
8447 | OPTS_TYPE_ST_ADDBITS14;
8448 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8449 dgst_size = DGST_SIZE_4_4;
8450 parse_func = md5s_parse_hash;
8451 sort_by_digest = sort_by_digest_4_4;
8452 opti_type = OPTI_TYPE_ZERO_BYTE
8453 | OPTI_TYPE_PRECOMPUTE_INIT
8454 | OPTI_TYPE_PRECOMPUTE_MERKLE
8455 | OPTI_TYPE_EARLY_SKIP
8456 | OPTI_TYPE_NOT_ITERATED
8457 | OPTI_TYPE_RAW_HASH;
8458 dgst_pos0 = 0;
8459 dgst_pos1 = 3;
8460 dgst_pos2 = 2;
8461 dgst_pos3 = 1;
8462 break;
8463
8464 case 4300: hash_type = HASH_TYPE_MD5;
8465 salt_type = SALT_TYPE_VIRTUAL;
8466 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8467 opts_type = OPTS_TYPE_PT_GENERATE_LE
8468 | OPTS_TYPE_PT_ADD80
8469 | OPTS_TYPE_PT_ADDBITS14
8470 | OPTS_TYPE_ST_ADD80;
8471 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8472 dgst_size = DGST_SIZE_4_4;
8473 parse_func = md5md5_parse_hash;
8474 sort_by_digest = sort_by_digest_4_4;
8475 opti_type = OPTI_TYPE_ZERO_BYTE
8476 | OPTI_TYPE_PRECOMPUTE_INIT
8477 | OPTI_TYPE_PRECOMPUTE_MERKLE
8478 | OPTI_TYPE_EARLY_SKIP;
8479 dgst_pos0 = 0;
8480 dgst_pos1 = 3;
8481 dgst_pos2 = 2;
8482 dgst_pos3 = 1;
8483 break;
8484
8485
8486 case 4400: hash_type = HASH_TYPE_MD5;
8487 salt_type = SALT_TYPE_NONE;
8488 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8489 opts_type = OPTS_TYPE_PT_GENERATE_BE
8490 | OPTS_TYPE_PT_ADD80
8491 | OPTS_TYPE_PT_ADDBITS15;
8492 kern_type = KERN_TYPE_MD5_SHA1;
8493 dgst_size = DGST_SIZE_4_4;
8494 parse_func = md5_parse_hash;
8495 sort_by_digest = sort_by_digest_4_4;
8496 opti_type = OPTI_TYPE_ZERO_BYTE
8497 | OPTI_TYPE_PRECOMPUTE_INIT
8498 | OPTI_TYPE_PRECOMPUTE_MERKLE
8499 | OPTI_TYPE_EARLY_SKIP
8500 | OPTI_TYPE_NOT_ITERATED
8501 | OPTI_TYPE_NOT_SALTED
8502 | OPTI_TYPE_RAW_HASH;
8503 dgst_pos0 = 0;
8504 dgst_pos1 = 3;
8505 dgst_pos2 = 2;
8506 dgst_pos3 = 1;
8507 break;
8508
8509 case 4500: hash_type = HASH_TYPE_SHA1;
8510 salt_type = SALT_TYPE_NONE;
8511 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8512 opts_type = OPTS_TYPE_PT_GENERATE_BE
8513 | OPTS_TYPE_PT_ADD80
8514 | OPTS_TYPE_PT_ADDBITS15;
8515 kern_type = KERN_TYPE_SHA11;
8516 dgst_size = DGST_SIZE_4_5;
8517 parse_func = sha1_parse_hash;
8518 sort_by_digest = sort_by_digest_4_5;
8519 opti_type = OPTI_TYPE_ZERO_BYTE
8520 | OPTI_TYPE_PRECOMPUTE_INIT
8521 | OPTI_TYPE_PRECOMPUTE_MERKLE
8522 | OPTI_TYPE_EARLY_SKIP
8523 | OPTI_TYPE_NOT_SALTED;
8524 dgst_pos0 = 3;
8525 dgst_pos1 = 4;
8526 dgst_pos2 = 2;
8527 dgst_pos3 = 1;
8528 break;
8529
8530 case 4700: hash_type = HASH_TYPE_SHA1;
8531 salt_type = SALT_TYPE_NONE;
8532 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8533 opts_type = OPTS_TYPE_PT_GENERATE_LE
8534 | OPTS_TYPE_PT_ADD80
8535 | OPTS_TYPE_PT_ADDBITS14;
8536 kern_type = KERN_TYPE_SHA1_MD5;
8537 dgst_size = DGST_SIZE_4_5;
8538 parse_func = sha1_parse_hash;
8539 sort_by_digest = sort_by_digest_4_5;
8540 opti_type = OPTI_TYPE_ZERO_BYTE
8541 | OPTI_TYPE_PRECOMPUTE_INIT
8542 | OPTI_TYPE_PRECOMPUTE_MERKLE
8543 | OPTI_TYPE_EARLY_SKIP
8544 | OPTI_TYPE_NOT_ITERATED
8545 | OPTI_TYPE_NOT_SALTED
8546 | OPTI_TYPE_RAW_HASH;
8547 dgst_pos0 = 3;
8548 dgst_pos1 = 4;
8549 dgst_pos2 = 2;
8550 dgst_pos3 = 1;
8551 break;
8552
8553 case 4800: hash_type = HASH_TYPE_MD5;
8554 salt_type = SALT_TYPE_EMBEDDED;
8555 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8556 opts_type = OPTS_TYPE_PT_GENERATE_LE
8557 | OPTS_TYPE_PT_ADDBITS14;
8558 kern_type = KERN_TYPE_MD5_CHAP;
8559 dgst_size = DGST_SIZE_4_4;
8560 parse_func = chap_parse_hash;
8561 sort_by_digest = sort_by_digest_4_4;
8562 opti_type = OPTI_TYPE_ZERO_BYTE
8563 | OPTI_TYPE_PRECOMPUTE_INIT
8564 | OPTI_TYPE_PRECOMPUTE_MERKLE
8565 | OPTI_TYPE_MEET_IN_MIDDLE
8566 | OPTI_TYPE_EARLY_SKIP
8567 | OPTI_TYPE_NOT_ITERATED
8568 | OPTI_TYPE_RAW_HASH;
8569 dgst_pos0 = 0;
8570 dgst_pos1 = 3;
8571 dgst_pos2 = 2;
8572 dgst_pos3 = 1;
8573 break;
8574
8575 case 4900: hash_type = HASH_TYPE_SHA1;
8576 salt_type = SALT_TYPE_INTERN;
8577 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8578 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8579 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8580 dgst_size = DGST_SIZE_4_5;
8581 parse_func = sha1s_parse_hash;
8582 sort_by_digest = sort_by_digest_4_5;
8583 opti_type = OPTI_TYPE_ZERO_BYTE
8584 | OPTI_TYPE_PRECOMPUTE_INIT
8585 | OPTI_TYPE_PRECOMPUTE_MERKLE
8586 | OPTI_TYPE_EARLY_SKIP;
8587 dgst_pos0 = 3;
8588 dgst_pos1 = 4;
8589 dgst_pos2 = 2;
8590 dgst_pos3 = 1;
8591 break;
8592
8593 case 5000: hash_type = HASH_TYPE_KECCAK;
8594 salt_type = SALT_TYPE_EMBEDDED;
8595 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8596 opts_type = OPTS_TYPE_PT_GENERATE_LE
8597 | OPTS_TYPE_PT_ADD01;
8598 kern_type = KERN_TYPE_KECCAK;
8599 dgst_size = DGST_SIZE_8_25;
8600 parse_func = keccak_parse_hash;
8601 sort_by_digest = sort_by_digest_8_25;
8602 opti_type = OPTI_TYPE_ZERO_BYTE
8603 | OPTI_TYPE_USES_BITS_64
8604 | OPTI_TYPE_RAW_HASH;
8605 dgst_pos0 = 2;
8606 dgst_pos1 = 3;
8607 dgst_pos2 = 4;
8608 dgst_pos3 = 5;
8609 break;
8610
8611 case 5100: hash_type = HASH_TYPE_MD5H;
8612 salt_type = SALT_TYPE_NONE;
8613 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8614 opts_type = OPTS_TYPE_PT_GENERATE_LE
8615 | OPTS_TYPE_PT_ADD80
8616 | OPTS_TYPE_PT_ADDBITS14;
8617 kern_type = KERN_TYPE_MD5H;
8618 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8619 parse_func = md5half_parse_hash;
8620 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8621 opti_type = OPTI_TYPE_ZERO_BYTE
8622 | OPTI_TYPE_RAW_HASH;
8623 dgst_pos0 = 0;
8624 dgst_pos1 = 1;
8625 dgst_pos2 = 2;
8626 dgst_pos3 = 3;
8627 break;
8628
8629 case 5200: hash_type = HASH_TYPE_SHA256;
8630 salt_type = SALT_TYPE_EMBEDDED;
8631 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8632 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8633 kern_type = KERN_TYPE_PSAFE3;
8634 dgst_size = DGST_SIZE_4_8;
8635 parse_func = psafe3_parse_hash;
8636 sort_by_digest = sort_by_digest_4_8;
8637 opti_type = OPTI_TYPE_ZERO_BYTE;
8638 dgst_pos0 = 0;
8639 dgst_pos1 = 1;
8640 dgst_pos2 = 2;
8641 dgst_pos3 = 3;
8642 break;
8643
8644 case 5300: hash_type = HASH_TYPE_MD5;
8645 salt_type = SALT_TYPE_EMBEDDED;
8646 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8647 opts_type = OPTS_TYPE_PT_GENERATE_LE
8648 | OPTS_TYPE_ST_ADD80;
8649 kern_type = KERN_TYPE_IKEPSK_MD5;
8650 dgst_size = DGST_SIZE_4_4;
8651 parse_func = ikepsk_md5_parse_hash;
8652 sort_by_digest = sort_by_digest_4_4;
8653 opti_type = OPTI_TYPE_ZERO_BYTE;
8654 dgst_pos0 = 0;
8655 dgst_pos1 = 3;
8656 dgst_pos2 = 2;
8657 dgst_pos3 = 1;
8658 break;
8659
8660 case 5400: hash_type = HASH_TYPE_SHA1;
8661 salt_type = SALT_TYPE_EMBEDDED;
8662 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8663 opts_type = OPTS_TYPE_PT_GENERATE_BE
8664 | OPTS_TYPE_ST_ADD80;
8665 kern_type = KERN_TYPE_IKEPSK_SHA1;
8666 dgst_size = DGST_SIZE_4_5;
8667 parse_func = ikepsk_sha1_parse_hash;
8668 sort_by_digest = sort_by_digest_4_5;
8669 opti_type = OPTI_TYPE_ZERO_BYTE;
8670 dgst_pos0 = 3;
8671 dgst_pos1 = 4;
8672 dgst_pos2 = 2;
8673 dgst_pos3 = 1;
8674 break;
8675
8676 case 5500: hash_type = HASH_TYPE_NETNTLM;
8677 salt_type = SALT_TYPE_EMBEDDED;
8678 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8679 opts_type = OPTS_TYPE_PT_GENERATE_LE
8680 | OPTS_TYPE_PT_ADD80
8681 | OPTS_TYPE_PT_ADDBITS14
8682 | OPTS_TYPE_PT_UNICODE
8683 | OPTS_TYPE_ST_HEX;
8684 kern_type = KERN_TYPE_NETNTLMv1;
8685 dgst_size = DGST_SIZE_4_4;
8686 parse_func = netntlmv1_parse_hash;
8687 sort_by_digest = sort_by_digest_4_4;
8688 opti_type = OPTI_TYPE_ZERO_BYTE
8689 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8690 dgst_pos0 = 0;
8691 dgst_pos1 = 1;
8692 dgst_pos2 = 2;
8693 dgst_pos3 = 3;
8694 break;
8695
8696 case 5600: hash_type = HASH_TYPE_MD5;
8697 salt_type = SALT_TYPE_EMBEDDED;
8698 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8699 opts_type = OPTS_TYPE_PT_GENERATE_LE
8700 | OPTS_TYPE_PT_ADD80
8701 | OPTS_TYPE_PT_ADDBITS14
8702 | OPTS_TYPE_PT_UNICODE;
8703 kern_type = KERN_TYPE_NETNTLMv2;
8704 dgst_size = DGST_SIZE_4_4;
8705 parse_func = netntlmv2_parse_hash;
8706 sort_by_digest = sort_by_digest_4_4;
8707 opti_type = OPTI_TYPE_ZERO_BYTE;
8708 dgst_pos0 = 0;
8709 dgst_pos1 = 3;
8710 dgst_pos2 = 2;
8711 dgst_pos3 = 1;
8712 break;
8713
8714 case 5700: hash_type = HASH_TYPE_SHA256;
8715 salt_type = SALT_TYPE_NONE;
8716 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8717 opts_type = OPTS_TYPE_PT_GENERATE_BE
8718 | OPTS_TYPE_PT_ADD80
8719 | OPTS_TYPE_PT_ADDBITS15;
8720 kern_type = KERN_TYPE_SHA256;
8721 dgst_size = DGST_SIZE_4_8;
8722 parse_func = cisco4_parse_hash;
8723 sort_by_digest = sort_by_digest_4_8;
8724 opti_type = OPTI_TYPE_ZERO_BYTE
8725 | OPTI_TYPE_PRECOMPUTE_INIT
8726 | OPTI_TYPE_PRECOMPUTE_MERKLE
8727 | OPTI_TYPE_EARLY_SKIP
8728 | OPTI_TYPE_NOT_ITERATED
8729 | OPTI_TYPE_NOT_SALTED
8730 | OPTI_TYPE_RAW_HASH;
8731 dgst_pos0 = 3;
8732 dgst_pos1 = 7;
8733 dgst_pos2 = 2;
8734 dgst_pos3 = 6;
8735 break;
8736
8737 case 5800: hash_type = HASH_TYPE_SHA1;
8738 salt_type = SALT_TYPE_INTERN;
8739 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8740 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8741 | OPTS_TYPE_ST_ADD80;
8742 kern_type = KERN_TYPE_ANDROIDPIN;
8743 dgst_size = DGST_SIZE_4_5;
8744 parse_func = androidpin_parse_hash;
8745 sort_by_digest = sort_by_digest_4_5;
8746 opti_type = OPTI_TYPE_ZERO_BYTE;
8747 dgst_pos0 = 0;
8748 dgst_pos1 = 1;
8749 dgst_pos2 = 2;
8750 dgst_pos3 = 3;
8751 break;
8752
8753 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8754 salt_type = SALT_TYPE_NONE;
8755 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8756 opts_type = OPTS_TYPE_PT_GENERATE_LE
8757 | OPTS_TYPE_PT_ADD80;
8758 kern_type = KERN_TYPE_RIPEMD160;
8759 dgst_size = DGST_SIZE_4_5;
8760 parse_func = ripemd160_parse_hash;
8761 sort_by_digest = sort_by_digest_4_5;
8762 opti_type = OPTI_TYPE_ZERO_BYTE;
8763 dgst_pos0 = 0;
8764 dgst_pos1 = 1;
8765 dgst_pos2 = 2;
8766 dgst_pos3 = 3;
8767 break;
8768
8769 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8770 salt_type = SALT_TYPE_NONE;
8771 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8772 opts_type = OPTS_TYPE_PT_GENERATE_BE
8773 | OPTS_TYPE_PT_ADD80;
8774 kern_type = KERN_TYPE_WHIRLPOOL;
8775 dgst_size = DGST_SIZE_4_16;
8776 parse_func = whirlpool_parse_hash;
8777 sort_by_digest = sort_by_digest_4_16;
8778 opti_type = OPTI_TYPE_ZERO_BYTE;
8779 dgst_pos0 = 0;
8780 dgst_pos1 = 1;
8781 dgst_pos2 = 2;
8782 dgst_pos3 = 3;
8783 break;
8784
8785 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8786 salt_type = SALT_TYPE_EMBEDDED;
8787 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8788 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8789 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8790 dgst_size = DGST_SIZE_4_5;
8791 parse_func = truecrypt_parse_hash_2k;
8792 sort_by_digest = sort_by_digest_4_5;
8793 opti_type = OPTI_TYPE_ZERO_BYTE;
8794 dgst_pos0 = 0;
8795 dgst_pos1 = 1;
8796 dgst_pos2 = 2;
8797 dgst_pos3 = 3;
8798 break;
8799
8800 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8801 salt_type = SALT_TYPE_EMBEDDED;
8802 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8803 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8804 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8805 dgst_size = DGST_SIZE_4_5;
8806 parse_func = truecrypt_parse_hash_2k;
8807 sort_by_digest = sort_by_digest_4_5;
8808 opti_type = OPTI_TYPE_ZERO_BYTE;
8809 dgst_pos0 = 0;
8810 dgst_pos1 = 1;
8811 dgst_pos2 = 2;
8812 dgst_pos3 = 3;
8813 break;
8814
8815 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8816 salt_type = SALT_TYPE_EMBEDDED;
8817 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8818 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8819 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8820 dgst_size = DGST_SIZE_4_5;
8821 parse_func = truecrypt_parse_hash_2k;
8822 sort_by_digest = sort_by_digest_4_5;
8823 opti_type = OPTI_TYPE_ZERO_BYTE;
8824 dgst_pos0 = 0;
8825 dgst_pos1 = 1;
8826 dgst_pos2 = 2;
8827 dgst_pos3 = 3;
8828 break;
8829
8830 case 6221: hash_type = HASH_TYPE_SHA512;
8831 salt_type = SALT_TYPE_EMBEDDED;
8832 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8833 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8834 kern_type = KERN_TYPE_TCSHA512_XTS512;
8835 dgst_size = DGST_SIZE_8_8;
8836 parse_func = truecrypt_parse_hash_1k;
8837 sort_by_digest = sort_by_digest_8_8;
8838 opti_type = OPTI_TYPE_ZERO_BYTE
8839 | OPTI_TYPE_USES_BITS_64;
8840 dgst_pos0 = 0;
8841 dgst_pos1 = 1;
8842 dgst_pos2 = 2;
8843 dgst_pos3 = 3;
8844 break;
8845
8846 case 6222: hash_type = HASH_TYPE_SHA512;
8847 salt_type = SALT_TYPE_EMBEDDED;
8848 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8849 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8850 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8851 dgst_size = DGST_SIZE_8_8;
8852 parse_func = truecrypt_parse_hash_1k;
8853 sort_by_digest = sort_by_digest_8_8;
8854 opti_type = OPTI_TYPE_ZERO_BYTE
8855 | OPTI_TYPE_USES_BITS_64;
8856 dgst_pos0 = 0;
8857 dgst_pos1 = 1;
8858 dgst_pos2 = 2;
8859 dgst_pos3 = 3;
8860 break;
8861
8862 case 6223: hash_type = HASH_TYPE_SHA512;
8863 salt_type = SALT_TYPE_EMBEDDED;
8864 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8865 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8866 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8867 dgst_size = DGST_SIZE_8_8;
8868 parse_func = truecrypt_parse_hash_1k;
8869 sort_by_digest = sort_by_digest_8_8;
8870 opti_type = OPTI_TYPE_ZERO_BYTE
8871 | OPTI_TYPE_USES_BITS_64;
8872 dgst_pos0 = 0;
8873 dgst_pos1 = 1;
8874 dgst_pos2 = 2;
8875 dgst_pos3 = 3;
8876 break;
8877
8878 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8879 salt_type = SALT_TYPE_EMBEDDED;
8880 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8881 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8882 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8883 dgst_size = DGST_SIZE_4_8;
8884 parse_func = truecrypt_parse_hash_1k;
8885 sort_by_digest = sort_by_digest_4_8;
8886 opti_type = OPTI_TYPE_ZERO_BYTE;
8887 dgst_pos0 = 0;
8888 dgst_pos1 = 1;
8889 dgst_pos2 = 2;
8890 dgst_pos3 = 3;
8891 break;
8892
8893 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8894 salt_type = SALT_TYPE_EMBEDDED;
8895 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8896 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8897 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8898 dgst_size = DGST_SIZE_4_8;
8899 parse_func = truecrypt_parse_hash_1k;
8900 sort_by_digest = sort_by_digest_4_8;
8901 opti_type = OPTI_TYPE_ZERO_BYTE;
8902 dgst_pos0 = 0;
8903 dgst_pos1 = 1;
8904 dgst_pos2 = 2;
8905 dgst_pos3 = 3;
8906 break;
8907
8908 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8909 salt_type = SALT_TYPE_EMBEDDED;
8910 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8911 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8912 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8913 dgst_size = DGST_SIZE_4_8;
8914 parse_func = truecrypt_parse_hash_1k;
8915 sort_by_digest = sort_by_digest_4_8;
8916 opti_type = OPTI_TYPE_ZERO_BYTE;
8917 dgst_pos0 = 0;
8918 dgst_pos1 = 1;
8919 dgst_pos2 = 2;
8920 dgst_pos3 = 3;
8921 break;
8922
8923 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8924 salt_type = SALT_TYPE_EMBEDDED;
8925 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8926 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8927 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8928 dgst_size = DGST_SIZE_4_5;
8929 parse_func = truecrypt_parse_hash_1k;
8930 sort_by_digest = sort_by_digest_4_5;
8931 opti_type = OPTI_TYPE_ZERO_BYTE;
8932 dgst_pos0 = 0;
8933 dgst_pos1 = 1;
8934 dgst_pos2 = 2;
8935 dgst_pos3 = 3;
8936 break;
8937
8938 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8939 salt_type = SALT_TYPE_EMBEDDED;
8940 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8941 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8942 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8943 dgst_size = DGST_SIZE_4_5;
8944 parse_func = truecrypt_parse_hash_1k;
8945 sort_by_digest = sort_by_digest_4_5;
8946 opti_type = OPTI_TYPE_ZERO_BYTE;
8947 dgst_pos0 = 0;
8948 dgst_pos1 = 1;
8949 dgst_pos2 = 2;
8950 dgst_pos3 = 3;
8951 break;
8952
8953 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8954 salt_type = SALT_TYPE_EMBEDDED;
8955 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8956 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8957 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8958 dgst_size = DGST_SIZE_4_5;
8959 parse_func = truecrypt_parse_hash_1k;
8960 sort_by_digest = sort_by_digest_4_5;
8961 opti_type = OPTI_TYPE_ZERO_BYTE;
8962 dgst_pos0 = 0;
8963 dgst_pos1 = 1;
8964 dgst_pos2 = 2;
8965 dgst_pos3 = 3;
8966 break;
8967
8968 case 6300: hash_type = HASH_TYPE_MD5;
8969 salt_type = SALT_TYPE_EMBEDDED;
8970 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8971 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8972 kern_type = KERN_TYPE_MD5AIX;
8973 dgst_size = DGST_SIZE_4_4;
8974 parse_func = md5aix_parse_hash;
8975 sort_by_digest = sort_by_digest_4_4;
8976 opti_type = OPTI_TYPE_ZERO_BYTE;
8977 dgst_pos0 = 0;
8978 dgst_pos1 = 1;
8979 dgst_pos2 = 2;
8980 dgst_pos3 = 3;
8981 break;
8982
8983 case 6400: hash_type = HASH_TYPE_SHA256;
8984 salt_type = SALT_TYPE_EMBEDDED;
8985 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8986 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8987 kern_type = KERN_TYPE_SHA256AIX;
8988 dgst_size = DGST_SIZE_4_8;
8989 parse_func = sha256aix_parse_hash;
8990 sort_by_digest = sort_by_digest_4_8;
8991 opti_type = OPTI_TYPE_ZERO_BYTE;
8992 dgst_pos0 = 0;
8993 dgst_pos1 = 1;
8994 dgst_pos2 = 2;
8995 dgst_pos3 = 3;
8996 break;
8997
8998 case 6500: hash_type = HASH_TYPE_SHA512;
8999 salt_type = SALT_TYPE_EMBEDDED;
9000 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9001 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9002 kern_type = KERN_TYPE_SHA512AIX;
9003 dgst_size = DGST_SIZE_8_8;
9004 parse_func = sha512aix_parse_hash;
9005 sort_by_digest = sort_by_digest_8_8;
9006 opti_type = OPTI_TYPE_ZERO_BYTE
9007 | OPTI_TYPE_USES_BITS_64;
9008 dgst_pos0 = 0;
9009 dgst_pos1 = 1;
9010 dgst_pos2 = 2;
9011 dgst_pos3 = 3;
9012 break;
9013
9014 case 6600: hash_type = HASH_TYPE_AES;
9015 salt_type = SALT_TYPE_EMBEDDED;
9016 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9017 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9018 kern_type = KERN_TYPE_AGILEKEY;
9019 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9020 parse_func = agilekey_parse_hash;
9021 sort_by_digest = sort_by_digest_4_5;
9022 opti_type = OPTI_TYPE_ZERO_BYTE;
9023 dgst_pos0 = 0;
9024 dgst_pos1 = 1;
9025 dgst_pos2 = 2;
9026 dgst_pos3 = 3;
9027 break;
9028
9029 case 6700: hash_type = HASH_TYPE_SHA1;
9030 salt_type = SALT_TYPE_EMBEDDED;
9031 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9032 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9033 kern_type = KERN_TYPE_SHA1AIX;
9034 dgst_size = DGST_SIZE_4_5;
9035 parse_func = sha1aix_parse_hash;
9036 sort_by_digest = sort_by_digest_4_5;
9037 opti_type = OPTI_TYPE_ZERO_BYTE;
9038 dgst_pos0 = 0;
9039 dgst_pos1 = 1;
9040 dgst_pos2 = 2;
9041 dgst_pos3 = 3;
9042 break;
9043
9044 case 6800: hash_type = HASH_TYPE_AES;
9045 salt_type = SALT_TYPE_EMBEDDED;
9046 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9047 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9048 kern_type = KERN_TYPE_LASTPASS;
9049 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9050 parse_func = lastpass_parse_hash;
9051 sort_by_digest = sort_by_digest_4_8;
9052 opti_type = OPTI_TYPE_ZERO_BYTE;
9053 dgst_pos0 = 0;
9054 dgst_pos1 = 1;
9055 dgst_pos2 = 2;
9056 dgst_pos3 = 3;
9057 break;
9058
9059 case 6900: hash_type = HASH_TYPE_GOST;
9060 salt_type = SALT_TYPE_NONE;
9061 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9062 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9063 kern_type = KERN_TYPE_GOST;
9064 dgst_size = DGST_SIZE_4_8;
9065 parse_func = gost_parse_hash;
9066 sort_by_digest = sort_by_digest_4_8;
9067 opti_type = OPTI_TYPE_ZERO_BYTE;
9068 dgst_pos0 = 0;
9069 dgst_pos1 = 1;
9070 dgst_pos2 = 2;
9071 dgst_pos3 = 3;
9072 break;
9073
9074 case 7100: hash_type = HASH_TYPE_SHA512;
9075 salt_type = SALT_TYPE_EMBEDDED;
9076 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9077 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9078 kern_type = KERN_TYPE_PBKDF2_SHA512;
9079 dgst_size = DGST_SIZE_8_16;
9080 parse_func = sha512osx_parse_hash;
9081 sort_by_digest = sort_by_digest_8_16;
9082 opti_type = OPTI_TYPE_ZERO_BYTE
9083 | OPTI_TYPE_USES_BITS_64;
9084 dgst_pos0 = 0;
9085 dgst_pos1 = 1;
9086 dgst_pos2 = 2;
9087 dgst_pos3 = 3;
9088 break;
9089
9090 case 7200: hash_type = HASH_TYPE_SHA512;
9091 salt_type = SALT_TYPE_EMBEDDED;
9092 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9093 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9094 kern_type = KERN_TYPE_PBKDF2_SHA512;
9095 dgst_size = DGST_SIZE_8_16;
9096 parse_func = sha512grub_parse_hash;
9097 sort_by_digest = sort_by_digest_8_16;
9098 opti_type = OPTI_TYPE_ZERO_BYTE
9099 | OPTI_TYPE_USES_BITS_64;
9100 dgst_pos0 = 0;
9101 dgst_pos1 = 1;
9102 dgst_pos2 = 2;
9103 dgst_pos3 = 3;
9104 break;
9105
9106 case 7300: hash_type = HASH_TYPE_SHA1;
9107 salt_type = SALT_TYPE_EMBEDDED;
9108 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9109 opts_type = OPTS_TYPE_PT_GENERATE_BE
9110 | OPTS_TYPE_ST_ADD80
9111 | OPTS_TYPE_ST_ADDBITS15;
9112 kern_type = KERN_TYPE_RAKP;
9113 dgst_size = DGST_SIZE_4_5;
9114 parse_func = rakp_parse_hash;
9115 sort_by_digest = sort_by_digest_4_5;
9116 opti_type = OPTI_TYPE_ZERO_BYTE
9117 | OPTI_TYPE_NOT_ITERATED;
9118 dgst_pos0 = 3;
9119 dgst_pos1 = 4;
9120 dgst_pos2 = 2;
9121 dgst_pos3 = 1;
9122 break;
9123
9124 case 7400: hash_type = HASH_TYPE_SHA256;
9125 salt_type = SALT_TYPE_EMBEDDED;
9126 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9127 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9128 kern_type = KERN_TYPE_SHA256CRYPT;
9129 dgst_size = DGST_SIZE_4_8;
9130 parse_func = sha256crypt_parse_hash;
9131 sort_by_digest = sort_by_digest_4_8;
9132 opti_type = OPTI_TYPE_ZERO_BYTE;
9133 dgst_pos0 = 0;
9134 dgst_pos1 = 1;
9135 dgst_pos2 = 2;
9136 dgst_pos3 = 3;
9137 break;
9138
9139 case 7500: hash_type = HASH_TYPE_KRB5PA;
9140 salt_type = SALT_TYPE_EMBEDDED;
9141 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9142 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9143 kern_type = KERN_TYPE_KRB5PA;
9144 dgst_size = DGST_SIZE_4_4;
9145 parse_func = krb5pa_parse_hash;
9146 sort_by_digest = sort_by_digest_4_4;
9147 opti_type = OPTI_TYPE_ZERO_BYTE
9148 | OPTI_TYPE_NOT_ITERATED;
9149 dgst_pos0 = 0;
9150 dgst_pos1 = 1;
9151 dgst_pos2 = 2;
9152 dgst_pos3 = 3;
9153 break;
9154
9155 case 7600: hash_type = HASH_TYPE_SHA1;
9156 salt_type = SALT_TYPE_INTERN;
9157 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9158 opts_type = OPTS_TYPE_PT_GENERATE_BE
9159 | OPTS_TYPE_PT_ADD80
9160 | OPTS_TYPE_PT_ADDBITS15;
9161 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9162 dgst_size = DGST_SIZE_4_5;
9163 parse_func = redmine_parse_hash;
9164 sort_by_digest = sort_by_digest_4_5;
9165 opti_type = OPTI_TYPE_ZERO_BYTE
9166 | OPTI_TYPE_PRECOMPUTE_INIT
9167 | OPTI_TYPE_EARLY_SKIP
9168 | OPTI_TYPE_NOT_ITERATED
9169 | OPTI_TYPE_PREPENDED_SALT;
9170 dgst_pos0 = 3;
9171 dgst_pos1 = 4;
9172 dgst_pos2 = 2;
9173 dgst_pos3 = 1;
9174 break;
9175
9176 case 7700: hash_type = HASH_TYPE_SAPB;
9177 salt_type = SALT_TYPE_EMBEDDED;
9178 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9179 opts_type = OPTS_TYPE_PT_GENERATE_LE
9180 | OPTS_TYPE_PT_UPPER
9181 | OPTS_TYPE_ST_UPPER;
9182 kern_type = KERN_TYPE_SAPB;
9183 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9184 parse_func = sapb_parse_hash;
9185 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9186 opti_type = OPTI_TYPE_ZERO_BYTE
9187 | OPTI_TYPE_PRECOMPUTE_INIT
9188 | OPTI_TYPE_NOT_ITERATED;
9189 dgst_pos0 = 0;
9190 dgst_pos1 = 1;
9191 dgst_pos2 = 2;
9192 dgst_pos3 = 3;
9193 break;
9194
9195 case 7800: hash_type = HASH_TYPE_SAPG;
9196 salt_type = SALT_TYPE_EMBEDDED;
9197 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9198 opts_type = OPTS_TYPE_PT_GENERATE_BE
9199 | OPTS_TYPE_ST_ADD80
9200 | OPTS_TYPE_ST_UPPER;
9201 kern_type = KERN_TYPE_SAPG;
9202 dgst_size = DGST_SIZE_4_5;
9203 parse_func = sapg_parse_hash;
9204 sort_by_digest = sort_by_digest_4_5;
9205 opti_type = OPTI_TYPE_ZERO_BYTE
9206 | OPTI_TYPE_PRECOMPUTE_INIT
9207 | OPTI_TYPE_NOT_ITERATED;
9208 dgst_pos0 = 3;
9209 dgst_pos1 = 4;
9210 dgst_pos2 = 2;
9211 dgst_pos3 = 1;
9212 break;
9213
9214 case 7900: hash_type = HASH_TYPE_SHA512;
9215 salt_type = SALT_TYPE_EMBEDDED;
9216 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9217 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9218 kern_type = KERN_TYPE_DRUPAL7;
9219 dgst_size = DGST_SIZE_8_8;
9220 parse_func = drupal7_parse_hash;
9221 sort_by_digest = sort_by_digest_8_8;
9222 opti_type = OPTI_TYPE_ZERO_BYTE
9223 | OPTI_TYPE_USES_BITS_64;
9224 dgst_pos0 = 0;
9225 dgst_pos1 = 1;
9226 dgst_pos2 = 2;
9227 dgst_pos3 = 3;
9228 break;
9229
9230 case 8000: hash_type = HASH_TYPE_SHA256;
9231 salt_type = SALT_TYPE_EMBEDDED;
9232 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9233 opts_type = OPTS_TYPE_PT_GENERATE_BE
9234 | OPTS_TYPE_PT_UNICODE
9235 | OPTS_TYPE_ST_ADD80
9236 | OPTS_TYPE_ST_HEX;
9237 kern_type = KERN_TYPE_SYBASEASE;
9238 dgst_size = DGST_SIZE_4_8;
9239 parse_func = sybasease_parse_hash;
9240 sort_by_digest = sort_by_digest_4_8;
9241 opti_type = OPTI_TYPE_ZERO_BYTE
9242 | OPTI_TYPE_PRECOMPUTE_INIT
9243 | OPTI_TYPE_EARLY_SKIP
9244 | OPTI_TYPE_NOT_ITERATED
9245 | OPTI_TYPE_RAW_HASH;
9246 dgst_pos0 = 3;
9247 dgst_pos1 = 7;
9248 dgst_pos2 = 2;
9249 dgst_pos3 = 6;
9250 break;
9251
9252 case 8100: hash_type = HASH_TYPE_SHA1;
9253 salt_type = SALT_TYPE_EMBEDDED;
9254 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9255 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9256 kern_type = KERN_TYPE_NETSCALER;
9257 dgst_size = DGST_SIZE_4_5;
9258 parse_func = netscaler_parse_hash;
9259 sort_by_digest = sort_by_digest_4_5;
9260 opti_type = OPTI_TYPE_ZERO_BYTE
9261 | OPTI_TYPE_PRECOMPUTE_INIT
9262 | OPTI_TYPE_PRECOMPUTE_MERKLE
9263 | OPTI_TYPE_EARLY_SKIP
9264 | OPTI_TYPE_NOT_ITERATED
9265 | OPTI_TYPE_PREPENDED_SALT
9266 | OPTI_TYPE_RAW_HASH;
9267 dgst_pos0 = 3;
9268 dgst_pos1 = 4;
9269 dgst_pos2 = 2;
9270 dgst_pos3 = 1;
9271 break;
9272
9273 case 8200: hash_type = HASH_TYPE_SHA256;
9274 salt_type = SALT_TYPE_EMBEDDED;
9275 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9276 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9277 kern_type = KERN_TYPE_CLOUDKEY;
9278 dgst_size = DGST_SIZE_4_8;
9279 parse_func = cloudkey_parse_hash;
9280 sort_by_digest = sort_by_digest_4_8;
9281 opti_type = OPTI_TYPE_ZERO_BYTE;
9282 dgst_pos0 = 0;
9283 dgst_pos1 = 1;
9284 dgst_pos2 = 2;
9285 dgst_pos3 = 3;
9286 break;
9287
9288 case 8300: hash_type = HASH_TYPE_SHA1;
9289 salt_type = SALT_TYPE_EMBEDDED;
9290 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9291 opts_type = OPTS_TYPE_PT_GENERATE_LE
9292 | OPTS_TYPE_ST_HEX
9293 | OPTS_TYPE_ST_ADD80;
9294 kern_type = KERN_TYPE_NSEC3;
9295 dgst_size = DGST_SIZE_4_5;
9296 parse_func = nsec3_parse_hash;
9297 sort_by_digest = sort_by_digest_4_5;
9298 opti_type = OPTI_TYPE_ZERO_BYTE;
9299 dgst_pos0 = 3;
9300 dgst_pos1 = 4;
9301 dgst_pos2 = 2;
9302 dgst_pos3 = 1;
9303 break;
9304
9305 case 8400: hash_type = HASH_TYPE_SHA1;
9306 salt_type = SALT_TYPE_INTERN;
9307 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9308 opts_type = OPTS_TYPE_PT_GENERATE_BE
9309 | OPTS_TYPE_PT_ADD80
9310 | OPTS_TYPE_PT_ADDBITS15;
9311 kern_type = KERN_TYPE_WBB3;
9312 dgst_size = DGST_SIZE_4_5;
9313 parse_func = wbb3_parse_hash;
9314 sort_by_digest = sort_by_digest_4_5;
9315 opti_type = OPTI_TYPE_ZERO_BYTE
9316 | OPTI_TYPE_PRECOMPUTE_INIT
9317 | OPTI_TYPE_NOT_ITERATED;
9318 dgst_pos0 = 3;
9319 dgst_pos1 = 4;
9320 dgst_pos2 = 2;
9321 dgst_pos3 = 1;
9322 break;
9323
9324 case 8500: hash_type = HASH_TYPE_DESRACF;
9325 salt_type = SALT_TYPE_EMBEDDED;
9326 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9327 opts_type = OPTS_TYPE_PT_GENERATE_LE
9328 | OPTS_TYPE_ST_UPPER;
9329 kern_type = KERN_TYPE_RACF;
9330 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9331 parse_func = racf_parse_hash;
9332 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9333 opti_type = OPTI_TYPE_ZERO_BYTE
9334 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9335 dgst_pos0 = 0;
9336 dgst_pos1 = 1;
9337 dgst_pos2 = 2;
9338 dgst_pos3 = 3;
9339 break;
9340
9341 case 8600: hash_type = HASH_TYPE_LOTUS5;
9342 salt_type = SALT_TYPE_NONE;
9343 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9344 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9345 kern_type = KERN_TYPE_LOTUS5;
9346 dgst_size = DGST_SIZE_4_4;
9347 parse_func = lotus5_parse_hash;
9348 sort_by_digest = sort_by_digest_4_4;
9349 opti_type = OPTI_TYPE_EARLY_SKIP
9350 | OPTI_TYPE_NOT_ITERATED
9351 | OPTI_TYPE_NOT_SALTED
9352 | OPTI_TYPE_RAW_HASH;
9353 dgst_pos0 = 0;
9354 dgst_pos1 = 1;
9355 dgst_pos2 = 2;
9356 dgst_pos3 = 3;
9357 break;
9358
9359 case 8700: hash_type = HASH_TYPE_LOTUS6;
9360 salt_type = SALT_TYPE_EMBEDDED;
9361 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9362 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9363 kern_type = KERN_TYPE_LOTUS6;
9364 dgst_size = DGST_SIZE_4_4;
9365 parse_func = lotus6_parse_hash;
9366 sort_by_digest = sort_by_digest_4_4;
9367 opti_type = OPTI_TYPE_EARLY_SKIP
9368 | OPTI_TYPE_NOT_ITERATED
9369 | OPTI_TYPE_RAW_HASH;
9370 dgst_pos0 = 0;
9371 dgst_pos1 = 1;
9372 dgst_pos2 = 2;
9373 dgst_pos3 = 3;
9374 break;
9375
9376 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9377 salt_type = SALT_TYPE_EMBEDDED;
9378 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9379 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9380 kern_type = KERN_TYPE_ANDROIDFDE;
9381 dgst_size = DGST_SIZE_4_4;
9382 parse_func = androidfde_parse_hash;
9383 sort_by_digest = sort_by_digest_4_4;
9384 opti_type = OPTI_TYPE_ZERO_BYTE;
9385 dgst_pos0 = 0;
9386 dgst_pos1 = 1;
9387 dgst_pos2 = 2;
9388 dgst_pos3 = 3;
9389 break;
9390
9391 case 8900: hash_type = HASH_TYPE_SCRYPT;
9392 salt_type = SALT_TYPE_EMBEDDED;
9393 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9394 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9395 kern_type = KERN_TYPE_SCRYPT;
9396 dgst_size = DGST_SIZE_4_8;
9397 parse_func = scrypt_parse_hash;
9398 sort_by_digest = sort_by_digest_4_8;
9399 opti_type = OPTI_TYPE_ZERO_BYTE;
9400 dgst_pos0 = 0;
9401 dgst_pos1 = 1;
9402 dgst_pos2 = 2;
9403 dgst_pos3 = 3;
9404 break;
9405
9406 case 9000: hash_type = HASH_TYPE_SHA1;
9407 salt_type = SALT_TYPE_EMBEDDED;
9408 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9409 opts_type = OPTS_TYPE_PT_GENERATE_LE
9410 | OPTS_TYPE_ST_GENERATE_LE;
9411 kern_type = KERN_TYPE_PSAFE2;
9412 dgst_size = DGST_SIZE_4_5;
9413 parse_func = psafe2_parse_hash;
9414 sort_by_digest = sort_by_digest_4_5;
9415 opti_type = OPTI_TYPE_ZERO_BYTE;
9416 dgst_pos0 = 0;
9417 dgst_pos1 = 1;
9418 dgst_pos2 = 2;
9419 dgst_pos3 = 3;
9420 break;
9421
9422 case 9100: hash_type = HASH_TYPE_LOTUS8;
9423 salt_type = SALT_TYPE_EMBEDDED;
9424 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9425 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9426 kern_type = KERN_TYPE_LOTUS8;
9427 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9428 parse_func = lotus8_parse_hash;
9429 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9430 opti_type = OPTI_TYPE_ZERO_BYTE;
9431 dgst_pos0 = 0;
9432 dgst_pos1 = 1;
9433 dgst_pos2 = 2;
9434 dgst_pos3 = 3;
9435 break;
9436
9437 case 9200: hash_type = HASH_TYPE_SHA256;
9438 salt_type = SALT_TYPE_EMBEDDED;
9439 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9440 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9441 kern_type = KERN_TYPE_PBKDF2_SHA256;
9442 dgst_size = DGST_SIZE_4_32;
9443 parse_func = cisco8_parse_hash;
9444 sort_by_digest = sort_by_digest_4_32;
9445 opti_type = OPTI_TYPE_ZERO_BYTE;
9446 dgst_pos0 = 0;
9447 dgst_pos1 = 1;
9448 dgst_pos2 = 2;
9449 dgst_pos3 = 3;
9450 break;
9451
9452 case 9300: hash_type = HASH_TYPE_SCRYPT;
9453 salt_type = SALT_TYPE_EMBEDDED;
9454 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9455 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9456 kern_type = KERN_TYPE_SCRYPT;
9457 dgst_size = DGST_SIZE_4_8;
9458 parse_func = cisco9_parse_hash;
9459 sort_by_digest = sort_by_digest_4_8;
9460 opti_type = OPTI_TYPE_ZERO_BYTE;
9461 dgst_pos0 = 0;
9462 dgst_pos1 = 1;
9463 dgst_pos2 = 2;
9464 dgst_pos3 = 3;
9465 break;
9466
9467 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9468 salt_type = SALT_TYPE_EMBEDDED;
9469 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9470 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9471 kern_type = KERN_TYPE_OFFICE2007;
9472 dgst_size = DGST_SIZE_4_4;
9473 parse_func = office2007_parse_hash;
9474 sort_by_digest = sort_by_digest_4_4;
9475 opti_type = OPTI_TYPE_ZERO_BYTE;
9476 dgst_pos0 = 0;
9477 dgst_pos1 = 1;
9478 dgst_pos2 = 2;
9479 dgst_pos3 = 3;
9480 break;
9481
9482 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9483 salt_type = SALT_TYPE_EMBEDDED;
9484 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9485 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9486 kern_type = KERN_TYPE_OFFICE2010;
9487 dgst_size = DGST_SIZE_4_4;
9488 parse_func = office2010_parse_hash;
9489 sort_by_digest = sort_by_digest_4_4;
9490 opti_type = OPTI_TYPE_ZERO_BYTE;
9491 dgst_pos0 = 0;
9492 dgst_pos1 = 1;
9493 dgst_pos2 = 2;
9494 dgst_pos3 = 3;
9495 break;
9496
9497 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9498 salt_type = SALT_TYPE_EMBEDDED;
9499 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9500 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9501 kern_type = KERN_TYPE_OFFICE2013;
9502 dgst_size = DGST_SIZE_4_4;
9503 parse_func = office2013_parse_hash;
9504 sort_by_digest = sort_by_digest_4_4;
9505 opti_type = OPTI_TYPE_ZERO_BYTE;
9506 dgst_pos0 = 0;
9507 dgst_pos1 = 1;
9508 dgst_pos2 = 2;
9509 dgst_pos3 = 3;
9510 break;
9511
9512 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9513 salt_type = SALT_TYPE_EMBEDDED;
9514 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9515 opts_type = OPTS_TYPE_PT_GENERATE_LE
9516 | OPTS_TYPE_PT_ADD80
9517 | OPTS_TYPE_PT_UNICODE;
9518 kern_type = KERN_TYPE_OLDOFFICE01;
9519 dgst_size = DGST_SIZE_4_4;
9520 parse_func = oldoffice01_parse_hash;
9521 sort_by_digest = sort_by_digest_4_4;
9522 opti_type = OPTI_TYPE_ZERO_BYTE
9523 | OPTI_TYPE_PRECOMPUTE_INIT
9524 | OPTI_TYPE_NOT_ITERATED;
9525 dgst_pos0 = 0;
9526 dgst_pos1 = 1;
9527 dgst_pos2 = 2;
9528 dgst_pos3 = 3;
9529 break;
9530
9531 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9532 salt_type = SALT_TYPE_EMBEDDED;
9533 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9534 opts_type = OPTS_TYPE_PT_GENERATE_LE
9535 | OPTS_TYPE_PT_ADD80;
9536 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9537 dgst_size = DGST_SIZE_4_4;
9538 parse_func = oldoffice01cm1_parse_hash;
9539 sort_by_digest = sort_by_digest_4_4;
9540 opti_type = OPTI_TYPE_ZERO_BYTE
9541 | OPTI_TYPE_PRECOMPUTE_INIT
9542 | OPTI_TYPE_NOT_ITERATED;
9543 dgst_pos0 = 0;
9544 dgst_pos1 = 1;
9545 dgst_pos2 = 2;
9546 dgst_pos3 = 3;
9547 break;
9548
9549 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9550 salt_type = SALT_TYPE_EMBEDDED;
9551 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9552 opts_type = OPTS_TYPE_PT_GENERATE_LE
9553 | OPTS_TYPE_PT_ADD80
9554 | OPTS_TYPE_PT_UNICODE
9555 | OPTS_TYPE_PT_NEVERCRACK;
9556 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9557 dgst_size = DGST_SIZE_4_4;
9558 parse_func = oldoffice01cm2_parse_hash;
9559 sort_by_digest = sort_by_digest_4_4;
9560 opti_type = OPTI_TYPE_ZERO_BYTE
9561 | OPTI_TYPE_PRECOMPUTE_INIT
9562 | OPTI_TYPE_NOT_ITERATED;
9563 dgst_pos0 = 0;
9564 dgst_pos1 = 1;
9565 dgst_pos2 = 2;
9566 dgst_pos3 = 3;
9567 break;
9568
9569 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9570 salt_type = SALT_TYPE_EMBEDDED;
9571 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9572 opts_type = OPTS_TYPE_PT_GENERATE_BE
9573 | OPTS_TYPE_PT_ADD80
9574 | OPTS_TYPE_PT_UNICODE;
9575 kern_type = KERN_TYPE_OLDOFFICE34;
9576 dgst_size = DGST_SIZE_4_4;
9577 parse_func = oldoffice34_parse_hash;
9578 sort_by_digest = sort_by_digest_4_4;
9579 opti_type = OPTI_TYPE_ZERO_BYTE
9580 | OPTI_TYPE_PRECOMPUTE_INIT
9581 | OPTI_TYPE_NOT_ITERATED;
9582 dgst_pos0 = 0;
9583 dgst_pos1 = 1;
9584 dgst_pos2 = 2;
9585 dgst_pos3 = 3;
9586 break;
9587
9588 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9589 salt_type = SALT_TYPE_EMBEDDED;
9590 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9591 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9592 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9593 dgst_size = DGST_SIZE_4_4;
9594 parse_func = oldoffice34cm1_parse_hash;
9595 sort_by_digest = sort_by_digest_4_4;
9596 opti_type = OPTI_TYPE_ZERO_BYTE
9597 | OPTI_TYPE_PRECOMPUTE_INIT
9598 | OPTI_TYPE_NOT_ITERATED;
9599 dgst_pos0 = 0;
9600 dgst_pos1 = 1;
9601 dgst_pos2 = 2;
9602 dgst_pos3 = 3;
9603 break;
9604
9605 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9606 salt_type = SALT_TYPE_EMBEDDED;
9607 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9608 opts_type = OPTS_TYPE_PT_GENERATE_BE
9609 | OPTS_TYPE_PT_ADD80
9610 | OPTS_TYPE_PT_UNICODE
9611 | OPTS_TYPE_PT_NEVERCRACK;
9612 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9613 dgst_size = DGST_SIZE_4_4;
9614 parse_func = oldoffice34cm2_parse_hash;
9615 sort_by_digest = sort_by_digest_4_4;
9616 opti_type = OPTI_TYPE_ZERO_BYTE
9617 | OPTI_TYPE_PRECOMPUTE_INIT
9618 | OPTI_TYPE_NOT_ITERATED;
9619 dgst_pos0 = 0;
9620 dgst_pos1 = 1;
9621 dgst_pos2 = 2;
9622 dgst_pos3 = 3;
9623 break;
9624
9625 case 9900: hash_type = HASH_TYPE_MD5;
9626 salt_type = SALT_TYPE_NONE;
9627 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9628 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9629 kern_type = KERN_TYPE_RADMIN2;
9630 dgst_size = DGST_SIZE_4_4;
9631 parse_func = radmin2_parse_hash;
9632 sort_by_digest = sort_by_digest_4_4;
9633 opti_type = OPTI_TYPE_ZERO_BYTE
9634 | OPTI_TYPE_PRECOMPUTE_INIT
9635 | OPTI_TYPE_EARLY_SKIP
9636 | OPTI_TYPE_NOT_ITERATED
9637 | OPTI_TYPE_NOT_SALTED;
9638 dgst_pos0 = 0;
9639 dgst_pos1 = 3;
9640 dgst_pos2 = 2;
9641 dgst_pos3 = 1;
9642 break;
9643
9644 case 10000: hash_type = HASH_TYPE_SHA256;
9645 salt_type = SALT_TYPE_EMBEDDED;
9646 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9647 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9648 kern_type = KERN_TYPE_PBKDF2_SHA256;
9649 dgst_size = DGST_SIZE_4_32;
9650 parse_func = djangopbkdf2_parse_hash;
9651 sort_by_digest = sort_by_digest_4_32;
9652 opti_type = OPTI_TYPE_ZERO_BYTE;
9653 dgst_pos0 = 0;
9654 dgst_pos1 = 1;
9655 dgst_pos2 = 2;
9656 dgst_pos3 = 3;
9657 break;
9658
9659 case 10100: hash_type = HASH_TYPE_SIPHASH;
9660 salt_type = SALT_TYPE_EMBEDDED;
9661 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9662 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9663 kern_type = KERN_TYPE_SIPHASH;
9664 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9665 parse_func = siphash_parse_hash;
9666 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9667 opti_type = OPTI_TYPE_ZERO_BYTE
9668 | OPTI_TYPE_NOT_ITERATED
9669 | OPTI_TYPE_RAW_HASH;
9670 dgst_pos0 = 0;
9671 dgst_pos1 = 1;
9672 dgst_pos2 = 2;
9673 dgst_pos3 = 3;
9674 break;
9675
9676 case 10200: hash_type = HASH_TYPE_MD5;
9677 salt_type = SALT_TYPE_EMBEDDED;
9678 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9679 opts_type = OPTS_TYPE_PT_GENERATE_LE
9680 | OPTS_TYPE_ST_ADD80
9681 | OPTS_TYPE_ST_ADDBITS14;
9682 kern_type = KERN_TYPE_HMACMD5_PW;
9683 dgst_size = DGST_SIZE_4_4;
9684 parse_func = crammd5_parse_hash;
9685 sort_by_digest = sort_by_digest_4_4;
9686 opti_type = OPTI_TYPE_ZERO_BYTE
9687 | OPTI_TYPE_NOT_ITERATED;
9688 dgst_pos0 = 0;
9689 dgst_pos1 = 3;
9690 dgst_pos2 = 2;
9691 dgst_pos3 = 1;
9692 break;
9693
9694 case 10300: hash_type = HASH_TYPE_SHA1;
9695 salt_type = SALT_TYPE_EMBEDDED;
9696 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9697 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9698 kern_type = KERN_TYPE_SAPH_SHA1;
9699 dgst_size = DGST_SIZE_4_5;
9700 parse_func = saph_sha1_parse_hash;
9701 sort_by_digest = sort_by_digest_4_5;
9702 opti_type = OPTI_TYPE_ZERO_BYTE;
9703 dgst_pos0 = 0;
9704 dgst_pos1 = 1;
9705 dgst_pos2 = 2;
9706 dgst_pos3 = 3;
9707 break;
9708
9709 case 10400: hash_type = HASH_TYPE_PDFU16;
9710 salt_type = SALT_TYPE_EMBEDDED;
9711 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9712 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9713 kern_type = KERN_TYPE_PDF11;
9714 dgst_size = DGST_SIZE_4_4;
9715 parse_func = pdf11_parse_hash;
9716 sort_by_digest = sort_by_digest_4_4;
9717 opti_type = OPTI_TYPE_ZERO_BYTE
9718 | OPTI_TYPE_NOT_ITERATED;
9719 dgst_pos0 = 0;
9720 dgst_pos1 = 1;
9721 dgst_pos2 = 2;
9722 dgst_pos3 = 3;
9723 break;
9724
9725 case 10410: hash_type = HASH_TYPE_PDFU16;
9726 salt_type = SALT_TYPE_EMBEDDED;
9727 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9728 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9729 kern_type = KERN_TYPE_PDF11CM1;
9730 dgst_size = DGST_SIZE_4_4;
9731 parse_func = pdf11cm1_parse_hash;
9732 sort_by_digest = sort_by_digest_4_4;
9733 opti_type = OPTI_TYPE_ZERO_BYTE
9734 | OPTI_TYPE_NOT_ITERATED;
9735 dgst_pos0 = 0;
9736 dgst_pos1 = 1;
9737 dgst_pos2 = 2;
9738 dgst_pos3 = 3;
9739 break;
9740
9741 case 10420: hash_type = HASH_TYPE_PDFU16;
9742 salt_type = SALT_TYPE_EMBEDDED;
9743 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9744 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9745 kern_type = KERN_TYPE_PDF11CM2;
9746 dgst_size = DGST_SIZE_4_4;
9747 parse_func = pdf11cm2_parse_hash;
9748 sort_by_digest = sort_by_digest_4_4;
9749 opti_type = OPTI_TYPE_ZERO_BYTE
9750 | OPTI_TYPE_NOT_ITERATED;
9751 dgst_pos0 = 0;
9752 dgst_pos1 = 1;
9753 dgst_pos2 = 2;
9754 dgst_pos3 = 3;
9755 break;
9756
9757 case 10500: hash_type = HASH_TYPE_PDFU16;
9758 salt_type = SALT_TYPE_EMBEDDED;
9759 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9760 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9761 kern_type = KERN_TYPE_PDF14;
9762 dgst_size = DGST_SIZE_4_4;
9763 parse_func = pdf14_parse_hash;
9764 sort_by_digest = sort_by_digest_4_4;
9765 opti_type = OPTI_TYPE_ZERO_BYTE
9766 | OPTI_TYPE_NOT_ITERATED;
9767 dgst_pos0 = 0;
9768 dgst_pos1 = 1;
9769 dgst_pos2 = 2;
9770 dgst_pos3 = 3;
9771 break;
9772
9773 case 10600: hash_type = HASH_TYPE_SHA256;
9774 salt_type = SALT_TYPE_EMBEDDED;
9775 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9776 opts_type = OPTS_TYPE_PT_GENERATE_BE
9777 | OPTS_TYPE_ST_ADD80
9778 | OPTS_TYPE_ST_ADDBITS15
9779 | OPTS_TYPE_HASH_COPY;
9780 kern_type = KERN_TYPE_SHA256_PWSLT;
9781 dgst_size = DGST_SIZE_4_8;
9782 parse_func = pdf17l3_parse_hash;
9783 sort_by_digest = sort_by_digest_4_8;
9784 opti_type = OPTI_TYPE_ZERO_BYTE
9785 | OPTI_TYPE_PRECOMPUTE_INIT
9786 | OPTI_TYPE_PRECOMPUTE_MERKLE
9787 | OPTI_TYPE_EARLY_SKIP
9788 | OPTI_TYPE_NOT_ITERATED
9789 | OPTI_TYPE_APPENDED_SALT
9790 | OPTI_TYPE_RAW_HASH;
9791 dgst_pos0 = 3;
9792 dgst_pos1 = 7;
9793 dgst_pos2 = 2;
9794 dgst_pos3 = 6;
9795 break;
9796
9797 case 10700: hash_type = HASH_TYPE_PDFU32;
9798 salt_type = SALT_TYPE_EMBEDDED;
9799 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9800 opts_type = OPTS_TYPE_PT_GENERATE_LE
9801 | OPTS_TYPE_HASH_COPY;
9802 kern_type = KERN_TYPE_PDF17L8;
9803 dgst_size = DGST_SIZE_4_8;
9804 parse_func = pdf17l8_parse_hash;
9805 sort_by_digest = sort_by_digest_4_8;
9806 opti_type = OPTI_TYPE_ZERO_BYTE
9807 | OPTI_TYPE_NOT_ITERATED;
9808 dgst_pos0 = 0;
9809 dgst_pos1 = 1;
9810 dgst_pos2 = 2;
9811 dgst_pos3 = 3;
9812 break;
9813
9814 case 10800: hash_type = HASH_TYPE_SHA384;
9815 salt_type = SALT_TYPE_NONE;
9816 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9817 opts_type = OPTS_TYPE_PT_GENERATE_BE
9818 | OPTS_TYPE_PT_ADD80
9819 | OPTS_TYPE_PT_ADDBITS15;
9820 kern_type = KERN_TYPE_SHA384;
9821 dgst_size = DGST_SIZE_8_8;
9822 parse_func = sha384_parse_hash;
9823 sort_by_digest = sort_by_digest_8_8;
9824 opti_type = OPTI_TYPE_ZERO_BYTE
9825 | OPTI_TYPE_PRECOMPUTE_INIT
9826 | OPTI_TYPE_PRECOMPUTE_MERKLE
9827 | OPTI_TYPE_EARLY_SKIP
9828 | OPTI_TYPE_NOT_ITERATED
9829 | OPTI_TYPE_NOT_SALTED
9830 | OPTI_TYPE_USES_BITS_64
9831 | OPTI_TYPE_RAW_HASH;
9832 dgst_pos0 = 6;
9833 dgst_pos1 = 7;
9834 dgst_pos2 = 4;
9835 dgst_pos3 = 5;
9836 break;
9837
9838 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9839 salt_type = SALT_TYPE_EMBEDDED;
9840 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9841 opts_type = OPTS_TYPE_PT_GENERATE_LE
9842 | OPTS_TYPE_ST_BASE64
9843 | OPTS_TYPE_HASH_COPY;
9844 kern_type = KERN_TYPE_PBKDF2_SHA256;
9845 dgst_size = DGST_SIZE_4_32;
9846 parse_func = pbkdf2_sha256_parse_hash;
9847 sort_by_digest = sort_by_digest_4_32;
9848 opti_type = OPTI_TYPE_ZERO_BYTE;
9849 dgst_pos0 = 0;
9850 dgst_pos1 = 1;
9851 dgst_pos2 = 2;
9852 dgst_pos3 = 3;
9853 break;
9854
9855 case 11000: hash_type = HASH_TYPE_MD5;
9856 salt_type = SALT_TYPE_INTERN;
9857 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9858 opts_type = OPTS_TYPE_PT_GENERATE_LE
9859 | OPTS_TYPE_PT_ADD80;
9860 kern_type = KERN_TYPE_PRESTASHOP;
9861 dgst_size = DGST_SIZE_4_4;
9862 parse_func = prestashop_parse_hash;
9863 sort_by_digest = sort_by_digest_4_4;
9864 opti_type = OPTI_TYPE_ZERO_BYTE
9865 | OPTI_TYPE_PRECOMPUTE_INIT
9866 | OPTI_TYPE_NOT_ITERATED
9867 | OPTI_TYPE_PREPENDED_SALT;
9868 dgst_pos0 = 0;
9869 dgst_pos1 = 3;
9870 dgst_pos2 = 2;
9871 dgst_pos3 = 1;
9872 break;
9873
9874 case 11100: hash_type = HASH_TYPE_MD5;
9875 salt_type = SALT_TYPE_EMBEDDED;
9876 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9877 opts_type = OPTS_TYPE_PT_GENERATE_LE
9878 | OPTS_TYPE_ST_ADD80;
9879 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9880 dgst_size = DGST_SIZE_4_4;
9881 parse_func = postgresql_auth_parse_hash;
9882 sort_by_digest = sort_by_digest_4_4;
9883 opti_type = OPTI_TYPE_ZERO_BYTE
9884 | OPTI_TYPE_PRECOMPUTE_INIT
9885 | OPTI_TYPE_PRECOMPUTE_MERKLE
9886 | OPTI_TYPE_EARLY_SKIP;
9887 dgst_pos0 = 0;
9888 dgst_pos1 = 3;
9889 dgst_pos2 = 2;
9890 dgst_pos3 = 1;
9891 break;
9892
9893 case 11200: hash_type = HASH_TYPE_SHA1;
9894 salt_type = SALT_TYPE_EMBEDDED;
9895 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9896 opts_type = OPTS_TYPE_PT_GENERATE_BE
9897 | OPTS_TYPE_PT_ADD80
9898 | OPTS_TYPE_ST_HEX;
9899 kern_type = KERN_TYPE_MYSQL_AUTH;
9900 dgst_size = DGST_SIZE_4_5;
9901 parse_func = mysql_auth_parse_hash;
9902 sort_by_digest = sort_by_digest_4_5;
9903 opti_type = OPTI_TYPE_ZERO_BYTE
9904 | OPTI_TYPE_EARLY_SKIP;
9905 dgst_pos0 = 3;
9906 dgst_pos1 = 4;
9907 dgst_pos2 = 2;
9908 dgst_pos3 = 1;
9909 break;
9910
9911 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9912 salt_type = SALT_TYPE_EMBEDDED;
9913 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9914 opts_type = OPTS_TYPE_PT_GENERATE_LE
9915 | OPTS_TYPE_ST_HEX
9916 | OPTS_TYPE_ST_ADD80;
9917 kern_type = KERN_TYPE_BITCOIN_WALLET;
9918 dgst_size = DGST_SIZE_4_4;
9919 parse_func = bitcoin_wallet_parse_hash;
9920 sort_by_digest = sort_by_digest_4_4;
9921 opti_type = OPTI_TYPE_ZERO_BYTE;
9922 dgst_pos0 = 0;
9923 dgst_pos1 = 1;
9924 dgst_pos2 = 2;
9925 dgst_pos3 = 3;
9926 break;
9927
9928 case 11400: hash_type = HASH_TYPE_MD5;
9929 salt_type = SALT_TYPE_EMBEDDED;
9930 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9931 opts_type = OPTS_TYPE_PT_GENERATE_LE
9932 | OPTS_TYPE_PT_ADD80
9933 | OPTS_TYPE_HASH_COPY;
9934 kern_type = KERN_TYPE_SIP_AUTH;
9935 dgst_size = DGST_SIZE_4_4;
9936 parse_func = sip_auth_parse_hash;
9937 sort_by_digest = sort_by_digest_4_4;
9938 opti_type = OPTI_TYPE_ZERO_BYTE;
9939 dgst_pos0 = 0;
9940 dgst_pos1 = 3;
9941 dgst_pos2 = 2;
9942 dgst_pos3 = 1;
9943 break;
9944
9945 case 11500: hash_type = HASH_TYPE_CRC32;
9946 salt_type = SALT_TYPE_INTERN;
9947 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9948 opts_type = OPTS_TYPE_PT_GENERATE_LE
9949 | OPTS_TYPE_ST_GENERATE_LE
9950 | OPTS_TYPE_ST_HEX;
9951 kern_type = KERN_TYPE_CRC32;
9952 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9953 parse_func = crc32_parse_hash;
9954 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9955 opti_type = OPTI_TYPE_ZERO_BYTE;
9956 dgst_pos0 = 0;
9957 dgst_pos1 = 1;
9958 dgst_pos2 = 2;
9959 dgst_pos3 = 3;
9960 break;
9961
9962 case 11600: hash_type = HASH_TYPE_AES;
9963 salt_type = SALT_TYPE_EMBEDDED;
9964 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9965 opts_type = OPTS_TYPE_PT_GENERATE_LE
9966 | OPTS_TYPE_PT_NEVERCRACK;
9967 kern_type = KERN_TYPE_SEVEN_ZIP;
9968 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9969 parse_func = seven_zip_parse_hash;
9970 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9971 opti_type = OPTI_TYPE_ZERO_BYTE;
9972 dgst_pos0 = 0;
9973 dgst_pos1 = 1;
9974 dgst_pos2 = 2;
9975 dgst_pos3 = 3;
9976 break;
9977
9978 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9979 salt_type = SALT_TYPE_NONE;
9980 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9981 opts_type = OPTS_TYPE_PT_GENERATE_LE
9982 | OPTS_TYPE_PT_ADD01;
9983 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9984 dgst_size = DGST_SIZE_4_8;
9985 parse_func = gost2012sbog_256_parse_hash;
9986 sort_by_digest = sort_by_digest_4_8;
9987 opti_type = OPTI_TYPE_ZERO_BYTE;
9988 dgst_pos0 = 0;
9989 dgst_pos1 = 1;
9990 dgst_pos2 = 2;
9991 dgst_pos3 = 3;
9992 break;
9993
9994 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9995 salt_type = SALT_TYPE_NONE;
9996 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9997 opts_type = OPTS_TYPE_PT_GENERATE_LE
9998 | OPTS_TYPE_PT_ADD01;
9999 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10000 dgst_size = DGST_SIZE_4_16;
10001 parse_func = gost2012sbog_512_parse_hash;
10002 sort_by_digest = sort_by_digest_4_16;
10003 opti_type = OPTI_TYPE_ZERO_BYTE;
10004 dgst_pos0 = 0;
10005 dgst_pos1 = 1;
10006 dgst_pos2 = 2;
10007 dgst_pos3 = 3;
10008 break;
10009
10010 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10011 salt_type = SALT_TYPE_EMBEDDED;
10012 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10013 opts_type = OPTS_TYPE_PT_GENERATE_LE
10014 | OPTS_TYPE_ST_BASE64
10015 | OPTS_TYPE_HASH_COPY;
10016 kern_type = KERN_TYPE_PBKDF2_MD5;
10017 dgst_size = DGST_SIZE_4_32;
10018 parse_func = pbkdf2_md5_parse_hash;
10019 sort_by_digest = sort_by_digest_4_32;
10020 opti_type = OPTI_TYPE_ZERO_BYTE;
10021 dgst_pos0 = 0;
10022 dgst_pos1 = 1;
10023 dgst_pos2 = 2;
10024 dgst_pos3 = 3;
10025 break;
10026
10027 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10028 salt_type = SALT_TYPE_EMBEDDED;
10029 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10030 opts_type = OPTS_TYPE_PT_GENERATE_LE
10031 | OPTS_TYPE_ST_BASE64
10032 | OPTS_TYPE_HASH_COPY;
10033 kern_type = KERN_TYPE_PBKDF2_SHA1;
10034 dgst_size = DGST_SIZE_4_32;
10035 parse_func = pbkdf2_sha1_parse_hash;
10036 sort_by_digest = sort_by_digest_4_32;
10037 opti_type = OPTI_TYPE_ZERO_BYTE;
10038 dgst_pos0 = 0;
10039 dgst_pos1 = 1;
10040 dgst_pos2 = 2;
10041 dgst_pos3 = 3;
10042 break;
10043
10044 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10045 salt_type = SALT_TYPE_EMBEDDED;
10046 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10047 opts_type = OPTS_TYPE_PT_GENERATE_LE
10048 | OPTS_TYPE_ST_BASE64
10049 | OPTS_TYPE_HASH_COPY;
10050 kern_type = KERN_TYPE_PBKDF2_SHA512;
10051 dgst_size = DGST_SIZE_8_16;
10052 parse_func = pbkdf2_sha512_parse_hash;
10053 sort_by_digest = sort_by_digest_8_16;
10054 opti_type = OPTI_TYPE_ZERO_BYTE
10055 | OPTI_TYPE_USES_BITS_64;
10056 dgst_pos0 = 0;
10057 dgst_pos1 = 1;
10058 dgst_pos2 = 2;
10059 dgst_pos3 = 3;
10060 break;
10061
10062 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10063 salt_type = SALT_TYPE_EMBEDDED;
10064 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10065 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10066 kern_type = KERN_TYPE_ECRYPTFS;
10067 dgst_size = DGST_SIZE_8_8;
10068 parse_func = ecryptfs_parse_hash;
10069 sort_by_digest = sort_by_digest_8_8;
10070 opti_type = OPTI_TYPE_ZERO_BYTE
10071 | OPTI_TYPE_USES_BITS_64;
10072 dgst_pos0 = 0;
10073 dgst_pos1 = 1;
10074 dgst_pos2 = 2;
10075 dgst_pos3 = 3;
10076 break;
10077
10078 case 12300: hash_type = HASH_TYPE_ORACLET;
10079 salt_type = SALT_TYPE_EMBEDDED;
10080 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10081 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10082 kern_type = KERN_TYPE_ORACLET;
10083 dgst_size = DGST_SIZE_8_16;
10084 parse_func = oraclet_parse_hash;
10085 sort_by_digest = sort_by_digest_8_16;
10086 opti_type = OPTI_TYPE_ZERO_BYTE
10087 | OPTI_TYPE_USES_BITS_64;
10088 dgst_pos0 = 0;
10089 dgst_pos1 = 1;
10090 dgst_pos2 = 2;
10091 dgst_pos3 = 3;
10092 break;
10093
10094 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10095 salt_type = SALT_TYPE_EMBEDDED;
10096 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10097 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10098 kern_type = KERN_TYPE_BSDICRYPT;
10099 dgst_size = DGST_SIZE_4_4;
10100 parse_func = bsdicrypt_parse_hash;
10101 sort_by_digest = sort_by_digest_4_4;
10102 opti_type = OPTI_TYPE_ZERO_BYTE
10103 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10104 dgst_pos0 = 0;
10105 dgst_pos1 = 1;
10106 dgst_pos2 = 2;
10107 dgst_pos3 = 3;
10108 break;
10109
10110 case 12500: hash_type = HASH_TYPE_RAR3HP;
10111 salt_type = SALT_TYPE_EMBEDDED;
10112 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10113 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10114 kern_type = KERN_TYPE_RAR3;
10115 dgst_size = DGST_SIZE_4_4;
10116 parse_func = rar3hp_parse_hash;
10117 sort_by_digest = sort_by_digest_4_4;
10118 opti_type = OPTI_TYPE_ZERO_BYTE;
10119 dgst_pos0 = 0;
10120 dgst_pos1 = 1;
10121 dgst_pos2 = 2;
10122 dgst_pos3 = 3;
10123 break;
10124
10125 case 12600: hash_type = HASH_TYPE_SHA256;
10126 salt_type = SALT_TYPE_INTERN;
10127 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10128 opts_type = OPTS_TYPE_PT_GENERATE_BE
10129 | OPTS_TYPE_PT_ADD80;
10130 kern_type = KERN_TYPE_CF10;
10131 dgst_size = DGST_SIZE_4_8;
10132 parse_func = cf10_parse_hash;
10133 sort_by_digest = sort_by_digest_4_8;
10134 opti_type = OPTI_TYPE_ZERO_BYTE
10135 | OPTI_TYPE_PRECOMPUTE_INIT
10136 | OPTI_TYPE_EARLY_SKIP
10137 | OPTI_TYPE_NOT_ITERATED;
10138 dgst_pos0 = 3;
10139 dgst_pos1 = 7;
10140 dgst_pos2 = 2;
10141 dgst_pos3 = 6;
10142 break;
10143
10144 case 12700: hash_type = HASH_TYPE_AES;
10145 salt_type = SALT_TYPE_EMBEDDED;
10146 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10147 opts_type = OPTS_TYPE_PT_GENERATE_LE
10148 | OPTS_TYPE_HASH_COPY;
10149 kern_type = KERN_TYPE_MYWALLET;
10150 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10151 parse_func = mywallet_parse_hash;
10152 sort_by_digest = sort_by_digest_4_5;
10153 opti_type = OPTI_TYPE_ZERO_BYTE;
10154 dgst_pos0 = 0;
10155 dgst_pos1 = 1;
10156 dgst_pos2 = 2;
10157 dgst_pos3 = 3;
10158 break;
10159
10160 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10161 salt_type = SALT_TYPE_EMBEDDED;
10162 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10163 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10164 kern_type = KERN_TYPE_MS_DRSR;
10165 dgst_size = DGST_SIZE_4_8;
10166 parse_func = ms_drsr_parse_hash;
10167 sort_by_digest = sort_by_digest_4_8;
10168 opti_type = OPTI_TYPE_ZERO_BYTE;
10169 dgst_pos0 = 0;
10170 dgst_pos1 = 1;
10171 dgst_pos2 = 2;
10172 dgst_pos3 = 3;
10173 break;
10174
10175 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10176 salt_type = SALT_TYPE_EMBEDDED;
10177 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10178 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10179 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10180 dgst_size = DGST_SIZE_4_8;
10181 parse_func = androidfde_samsung_parse_hash;
10182 sort_by_digest = sort_by_digest_4_8;
10183 opti_type = OPTI_TYPE_ZERO_BYTE;
10184 dgst_pos0 = 0;
10185 dgst_pos1 = 1;
10186 dgst_pos2 = 2;
10187 dgst_pos3 = 3;
10188 break;
10189
10190 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10191 salt_type = SALT_TYPE_EMBEDDED;
10192 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10193 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10194 kern_type = KERN_TYPE_RAR5;
10195 dgst_size = DGST_SIZE_4_4;
10196 parse_func = rar5_parse_hash;
10197 sort_by_digest = sort_by_digest_4_4;
10198 opti_type = OPTI_TYPE_ZERO_BYTE;
10199 dgst_pos0 = 0;
10200 dgst_pos1 = 1;
10201 dgst_pos2 = 2;
10202 dgst_pos3 = 3;
10203 break;
10204
10205 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10206 salt_type = SALT_TYPE_EMBEDDED;
10207 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10208 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10209 kern_type = KERN_TYPE_KRB5TGS;
10210 dgst_size = DGST_SIZE_4_4;
10211 parse_func = krb5tgs_parse_hash;
10212 sort_by_digest = sort_by_digest_4_4;
10213 opti_type = OPTI_TYPE_ZERO_BYTE
10214 | OPTI_TYPE_NOT_ITERATED;
10215 dgst_pos0 = 0;
10216 dgst_pos1 = 1;
10217 dgst_pos2 = 2;
10218 dgst_pos3 = 3;
10219 break;
10220
10221 default: usage_mini_print (PROGNAME); return (-1);
10222 }
10223
10224 /**
10225 * parser
10226 */
10227
10228 data.parse_func = parse_func;
10229
10230 /**
10231 * misc stuff
10232 */
10233
10234 if (hex_salt)
10235 {
10236 if (salt_type == SALT_TYPE_INTERN)
10237 {
10238 opts_type |= OPTS_TYPE_ST_HEX;
10239 }
10240 else
10241 {
10242 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10243
10244 return (-1);
10245 }
10246 }
10247
10248 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10249 | (salt_type == SALT_TYPE_EXTERN)
10250 | (salt_type == SALT_TYPE_EMBEDDED)
10251 | (salt_type == SALT_TYPE_VIRTUAL));
10252
10253 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10254
10255 data.hash_type = hash_type;
10256 data.attack_mode = attack_mode;
10257 data.attack_kern = attack_kern;
10258 data.attack_exec = attack_exec;
10259 data.kern_type = kern_type;
10260 data.opts_type = opts_type;
10261 data.dgst_size = dgst_size;
10262 data.salt_type = salt_type;
10263 data.isSalted = isSalted;
10264 data.sort_by_digest = sort_by_digest;
10265 data.dgst_pos0 = dgst_pos0;
10266 data.dgst_pos1 = dgst_pos1;
10267 data.dgst_pos2 = dgst_pos2;
10268 data.dgst_pos3 = dgst_pos3;
10269
10270 esalt_size = 0;
10271
10272 switch (hash_mode)
10273 {
10274 case 2500: esalt_size = sizeof (wpa_t); break;
10275 case 5300: esalt_size = sizeof (ikepsk_t); break;
10276 case 5400: esalt_size = sizeof (ikepsk_t); break;
10277 case 5500: esalt_size = sizeof (netntlm_t); break;
10278 case 5600: esalt_size = sizeof (netntlm_t); break;
10279 case 6211: esalt_size = sizeof (tc_t); break;
10280 case 6212: esalt_size = sizeof (tc_t); break;
10281 case 6213: esalt_size = sizeof (tc_t); break;
10282 case 6221: esalt_size = sizeof (tc_t); break;
10283 case 6222: esalt_size = sizeof (tc_t); break;
10284 case 6223: esalt_size = sizeof (tc_t); break;
10285 case 6231: esalt_size = sizeof (tc_t); break;
10286 case 6232: esalt_size = sizeof (tc_t); break;
10287 case 6233: esalt_size = sizeof (tc_t); break;
10288 case 6241: esalt_size = sizeof (tc_t); break;
10289 case 6242: esalt_size = sizeof (tc_t); break;
10290 case 6243: esalt_size = sizeof (tc_t); break;
10291 case 6600: esalt_size = sizeof (agilekey_t); break;
10292 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10293 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10294 case 7300: esalt_size = sizeof (rakp_t); break;
10295 case 7500: esalt_size = sizeof (krb5pa_t); break;
10296 case 8200: esalt_size = sizeof (cloudkey_t); break;
10297 case 8800: esalt_size = sizeof (androidfde_t); break;
10298 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10299 case 9400: esalt_size = sizeof (office2007_t); break;
10300 case 9500: esalt_size = sizeof (office2010_t); break;
10301 case 9600: esalt_size = sizeof (office2013_t); break;
10302 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10303 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10304 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10305 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10306 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10307 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10308 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10309 case 10200: esalt_size = sizeof (cram_md5_t); break;
10310 case 10400: esalt_size = sizeof (pdf_t); break;
10311 case 10410: esalt_size = sizeof (pdf_t); break;
10312 case 10420: esalt_size = sizeof (pdf_t); break;
10313 case 10500: esalt_size = sizeof (pdf_t); break;
10314 case 10600: esalt_size = sizeof (pdf_t); break;
10315 case 10700: esalt_size = sizeof (pdf_t); break;
10316 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10317 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10318 case 11400: esalt_size = sizeof (sip_t); break;
10319 case 11600: esalt_size = sizeof (seven_zip_t); break;
10320 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10321 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10322 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10323 case 13000: esalt_size = sizeof (rar5_t); break;
10324 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10325 }
10326
10327 data.esalt_size = esalt_size;
10328
10329 /**
10330 * choose dictionary parser
10331 */
10332
10333 if (hash_type == HASH_TYPE_LM)
10334 {
10335 get_next_word_func = get_next_word_lm;
10336 }
10337 else if (opts_type & OPTS_TYPE_PT_UPPER)
10338 {
10339 get_next_word_func = get_next_word_uc;
10340 }
10341 else
10342 {
10343 get_next_word_func = get_next_word_std;
10344 }
10345
10346 /**
10347 * dictstat
10348 */
10349
10350 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10351
10352 #ifdef _POSIX
10353 size_t dictstat_nmemb = 0;
10354 #endif
10355
10356 #ifdef _WIN
10357 uint dictstat_nmemb = 0;
10358 #endif
10359
10360 char dictstat[256] = { 0 };
10361
10362 FILE *dictstat_fp = NULL;
10363
10364 if (keyspace == 0)
10365 {
10366 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10367
10368 dictstat_fp = fopen (dictstat, "rb");
10369
10370 if (dictstat_fp)
10371 {
10372 #ifdef _POSIX
10373 struct stat tmpstat;
10374
10375 fstat (fileno (dictstat_fp), &tmpstat);
10376 #endif
10377
10378 #ifdef _WIN
10379 struct stat64 tmpstat;
10380
10381 _fstat64 (fileno (dictstat_fp), &tmpstat);
10382 #endif
10383
10384 if (tmpstat.st_mtime < COMPTIME)
10385 {
10386 /* with v0.15 the format changed so we have to ensure user is using a good version
10387 since there is no version-header in the dictstat file */
10388
10389 fclose (dictstat_fp);
10390
10391 unlink (dictstat);
10392 }
10393 else
10394 {
10395 while (!feof (dictstat_fp))
10396 {
10397 dictstat_t d;
10398
10399 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10400
10401 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10402
10403 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10404 {
10405 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10406
10407 return -1;
10408 }
10409 }
10410
10411 fclose (dictstat_fp);
10412 }
10413 }
10414 }
10415
10416 /**
10417 * potfile
10418 */
10419
10420 char potfile[256] = { 0 };
10421
10422 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10423
10424 data.pot_fp = NULL;
10425
10426 FILE *out_fp = NULL;
10427 FILE *pot_fp = NULL;
10428
10429 if (show == 1 || left == 1)
10430 {
10431 pot_fp = fopen (potfile, "rb");
10432
10433 if (pot_fp == NULL)
10434 {
10435 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10436
10437 return (-1);
10438 }
10439
10440 if (outfile != NULL)
10441 {
10442 if ((out_fp = fopen (outfile, "ab")) == NULL)
10443 {
10444 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10445
10446 fclose (pot_fp);
10447
10448 return (-1);
10449 }
10450 }
10451 else
10452 {
10453 out_fp = stdout;
10454 }
10455 }
10456 else
10457 {
10458 if (potfile_disable == 0)
10459 {
10460 pot_fp = fopen (potfile, "ab");
10461
10462 if (pot_fp == NULL)
10463 {
10464 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10465
10466 return (-1);
10467 }
10468
10469 data.pot_fp = pot_fp;
10470 }
10471 }
10472
10473 pot_t *pot = NULL;
10474
10475 uint pot_cnt = 0;
10476 uint pot_avail = 0;
10477
10478 if (show == 1 || left == 1)
10479 {
10480 SUPPRESS_OUTPUT = 1;
10481
10482 pot_avail = count_lines (pot_fp);
10483
10484 rewind (pot_fp);
10485
10486 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10487
10488 uint pot_hashes_avail = 0;
10489
10490 uint line_num = 0;
10491
10492 while (!feof (pot_fp))
10493 {
10494 line_num++;
10495
10496 char line_buf[BUFSIZ] = { 0 };
10497
10498 int line_len = fgetl (pot_fp, line_buf);
10499
10500 if (line_len == 0) continue;
10501
10502 char *plain_buf = line_buf + line_len;
10503
10504 pot_t *pot_ptr = &pot[pot_cnt];
10505
10506 hash_t *hashes_buf = &pot_ptr->hash;
10507
10508 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10509 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10510
10511 if (pot_cnt == pot_hashes_avail)
10512 {
10513 uint pos = 0;
10514
10515 for (pos = 0; pos < INCR_POT; pos++)
10516 {
10517 if ((pot_cnt + pos) >= pot_avail) break;
10518
10519 pot_t *tmp_pot = &pot[pot_cnt + pos];
10520
10521 hash_t *tmp_hash = &tmp_pot->hash;
10522
10523 tmp_hash->digest = mymalloc (dgst_size);
10524
10525 if (isSalted)
10526 {
10527 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10528 }
10529
10530 if (esalt_size)
10531 {
10532 tmp_hash->esalt = mymalloc (esalt_size);
10533 }
10534
10535 pot_hashes_avail++;
10536 }
10537 }
10538
10539 int plain_len = 0;
10540
10541 int parser_status;
10542
10543 int iter = MAX_CUT_TRIES;
10544
10545 do
10546 {
10547 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10548 {
10549 if (line_buf[i] == ':')
10550 {
10551 line_len--;
10552
10553 break;
10554 }
10555 }
10556
10557 if (data.hash_mode != 2500)
10558 {
10559 parser_status = parse_func (line_buf, line_len, hashes_buf);
10560 }
10561 else
10562 {
10563 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10564
10565 if (line_len > max_salt_size)
10566 {
10567 parser_status = PARSER_GLOBAL_LENGTH;
10568 }
10569 else
10570 {
10571 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10572
10573 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10574
10575 hashes_buf->salt->salt_len = line_len;
10576
10577 parser_status = PARSER_OK;
10578 }
10579 }
10580
10581 // if NOT parsed without error, we add the ":" to the plain
10582
10583 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10584 {
10585 plain_len++;
10586 plain_buf--;
10587 }
10588
10589 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10590
10591 if (parser_status < PARSER_GLOBAL_ZERO)
10592 {
10593 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10594
10595 continue;
10596 }
10597
10598 if (plain_len >= 255) continue;
10599
10600 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10601
10602 pot_ptr->plain_len = plain_len;
10603
10604 pot_cnt++;
10605 }
10606
10607 fclose (pot_fp);
10608
10609 SUPPRESS_OUTPUT = 0;
10610
10611 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10612 }
10613
10614 /**
10615 * word len
10616 */
10617
10618 uint pw_min = PW_MIN;
10619 uint pw_max = PW_MAX;
10620
10621 switch (hash_mode)
10622 {
10623 case 400: if (pw_max > 40) pw_max = 40;
10624 break;
10625 case 500: if (pw_max > 16) pw_max = 16;
10626 break;
10627 case 1500: if (pw_max > 8) pw_max = 8;
10628 break;
10629 case 1600: if (pw_max > 16) pw_max = 16;
10630 break;
10631 case 1800: if (pw_max > 16) pw_max = 16;
10632 break;
10633 case 2100: if (pw_max > 16) pw_max = 16;
10634 break;
10635 case 2500: if (pw_min < 8) pw_min = 8;
10636 break;
10637 case 3000: if (pw_max > 7) pw_max = 7;
10638 break;
10639 case 5200: if (pw_max > 24) pw_max = 24;
10640 break;
10641 case 5800: if (pw_max > 16) pw_max = 16;
10642 break;
10643 case 6300: if (pw_max > 16) pw_max = 16;
10644 break;
10645 case 7400: if (pw_max > 16) pw_max = 16;
10646 break;
10647 case 7900: if (pw_max > 48) pw_max = 48;
10648 break;
10649 case 8500: if (pw_max > 8) pw_max = 8;
10650 break;
10651 case 8600: if (pw_max > 16) pw_max = 16;
10652 break;
10653 case 9710: pw_min = 5;
10654 pw_max = 5;
10655 break;
10656 case 9810: pw_min = 5;
10657 pw_max = 5;
10658 break;
10659 case 10410: pw_min = 5;
10660 pw_max = 5;
10661 break;
10662 case 10300: if (pw_max < 3) pw_min = 3;
10663 if (pw_max > 40) pw_max = 40;
10664 break;
10665 case 10500: if (pw_max < 3) pw_min = 3;
10666 if (pw_max > 40) pw_max = 40;
10667 break;
10668 case 10700: if (pw_max > 16) pw_max = 16;
10669 break;
10670 case 11300: if (pw_max > 40) pw_max = 40;
10671 break;
10672 case 12500: if (pw_max > 20) pw_max = 20;
10673 break;
10674 case 12800: if (pw_max > 24) pw_max = 24;
10675 break;
10676 }
10677
10678 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10679 {
10680 switch (attack_kern)
10681 {
10682 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10683 break;
10684 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10685 break;
10686 }
10687 }
10688
10689 /**
10690 * charsets : keep them together for more easy maintainnce
10691 */
10692
10693 cs_t mp_sys[6] = { { { 0 }, 0 } };
10694 cs_t mp_usr[4] = { { { 0 }, 0 } };
10695
10696 mp_setup_sys (mp_sys);
10697
10698 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10699 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10700 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10701 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10702
10703 /**
10704 * load hashes, part I: find input mode, count hashes
10705 */
10706
10707 uint hashlist_mode = 0;
10708 uint hashlist_format = HLFMT_HASHCAT;
10709
10710 uint hashes_avail = 0;
10711
10712 if (benchmark == 0)
10713 {
10714 struct stat f;
10715
10716 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10717
10718 if ((hash_mode == 2500) ||
10719 (hash_mode == 5200) ||
10720 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10721 (hash_mode == 9000))
10722 {
10723 hashlist_mode = HL_MODE_ARG;
10724
10725 char *hashfile = myargv[optind];
10726
10727 data.hashfile = hashfile;
10728
10729 logfile_top_var_string ("target", hashfile);
10730 }
10731
10732 if (hashlist_mode == HL_MODE_ARG)
10733 {
10734 if (hash_mode == 2500)
10735 {
10736 struct stat st;
10737
10738 if (stat (data.hashfile, &st) == -1)
10739 {
10740 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10741
10742 return (-1);
10743 }
10744
10745 hashes_avail = st.st_size / sizeof (hccap_t);
10746 }
10747 else
10748 {
10749 hashes_avail = 1;
10750 }
10751 }
10752 else if (hashlist_mode == HL_MODE_FILE)
10753 {
10754 char *hashfile = myargv[optind];
10755
10756 data.hashfile = hashfile;
10757
10758 logfile_top_var_string ("target", hashfile);
10759
10760 FILE *fp = NULL;
10761
10762 if ((fp = fopen (hashfile, "rb")) == NULL)
10763 {
10764 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10765
10766 return (-1);
10767 }
10768
10769 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10770
10771 hashes_avail = count_lines (fp);
10772
10773 rewind (fp);
10774
10775 if (hashes_avail == 0)
10776 {
10777 log_error ("ERROR: hashfile is empty or corrupt");
10778
10779 fclose (fp);
10780
10781 return (-1);
10782 }
10783
10784 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10785
10786 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10787 {
10788 log_error ("ERROR: remove not supported in native hashfile-format mode");
10789
10790 fclose (fp);
10791
10792 return (-1);
10793 }
10794
10795 fclose (fp);
10796 }
10797 }
10798 else
10799 {
10800 hashlist_mode = HL_MODE_ARG;
10801
10802 hashes_avail = 1;
10803 }
10804
10805 if (hash_mode == 3000) hashes_avail *= 2;
10806
10807 data.hashlist_mode = hashlist_mode;
10808 data.hashlist_format = hashlist_format;
10809
10810 logfile_top_uint (hashlist_mode);
10811 logfile_top_uint (hashlist_format);
10812
10813 /**
10814 * load hashes, part II: allocate required memory, set pointers
10815 */
10816
10817 hash_t *hashes_buf = NULL;
10818 void *digests_buf = NULL;
10819 salt_t *salts_buf = NULL;
10820 void *esalts_buf = NULL;
10821
10822 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10823
10824 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10825
10826 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10827 {
10828 u32 hash_pos;
10829
10830 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10831 {
10832 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10833
10834 hashes_buf[hash_pos].hash_info = hash_info;
10835
10836 if (username && (remove || show || left))
10837 {
10838 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10839 }
10840
10841 if (benchmark)
10842 {
10843 hash_info->orighash = (char *) mymalloc (256);
10844 }
10845 }
10846 }
10847
10848 if (isSalted)
10849 {
10850 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10851
10852 if (esalt_size)
10853 {
10854 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10855 }
10856 }
10857 else
10858 {
10859 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10860 }
10861
10862 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10863 {
10864 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10865
10866 if (isSalted)
10867 {
10868 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10869
10870 if (esalt_size)
10871 {
10872 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10873 }
10874 }
10875 else
10876 {
10877 hashes_buf[hash_pos].salt = &salts_buf[0];
10878 }
10879 }
10880
10881 /**
10882 * load hashes, part III: parse hashes or generate them if benchmark
10883 */
10884
10885 uint hashes_cnt = 0;
10886
10887 if (benchmark == 0)
10888 {
10889 if (keyspace == 1)
10890 {
10891 // useless to read hash file for keyspace, cheat a little bit w/ optind
10892 }
10893 else if (hashes_avail == 0)
10894 {
10895 }
10896 else if (hashlist_mode == HL_MODE_ARG)
10897 {
10898 char *input_buf = myargv[optind];
10899
10900 uint input_len = strlen (input_buf);
10901
10902 logfile_top_var_string ("target", input_buf);
10903
10904 char *hash_buf = NULL;
10905 int hash_len = 0;
10906
10907 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10908
10909 if (hash_len)
10910 {
10911 if (opts_type & OPTS_TYPE_HASH_COPY)
10912 {
10913 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10914
10915 hash_info_tmp->orighash = mystrdup (hash_buf);
10916 }
10917
10918 if (isSalted)
10919 {
10920 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10921 }
10922
10923 int parser_status = PARSER_OK;
10924
10925 if (hash_mode == 2500)
10926 {
10927 if (hash_len == 0)
10928 {
10929 log_error ("ERROR: hccap file not specified");
10930
10931 return (-1);
10932 }
10933
10934 hashlist_mode = HL_MODE_FILE;
10935
10936 data.hashlist_mode = hashlist_mode;
10937
10938 FILE *fp = fopen (hash_buf, "rb");
10939
10940 if (fp == NULL)
10941 {
10942 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10943
10944 return (-1);
10945 }
10946
10947 if (hashes_avail < 1)
10948 {
10949 log_error ("ERROR: hccap file is empty or corrupt");
10950
10951 fclose (fp);
10952
10953 return (-1);
10954 }
10955
10956 uint hccap_size = sizeof (hccap_t);
10957
10958 char *in = (char *) mymalloc (hccap_size);
10959
10960 while (!feof (fp))
10961 {
10962 int n = fread (in, hccap_size, 1, fp);
10963
10964 if (n != 1)
10965 {
10966 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10967
10968 break;
10969 }
10970
10971 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10972
10973 if (parser_status != PARSER_OK)
10974 {
10975 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10976
10977 continue;
10978 }
10979
10980 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10981
10982 if ((show == 1) || (left == 1))
10983 {
10984 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10985
10986 char *salt_ptr = (char *) tmp_salt->salt_buf;
10987
10988 int cur_pos = tmp_salt->salt_len;
10989 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10990
10991 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10992
10993 u8 *pke_ptr = (u8 *) wpa->pke;
10994
10995 // do the appending task
10996
10997 snprintf (salt_ptr + cur_pos,
10998 rem_len,
10999 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11000 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
11001 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
11002
11003
11004 // memset () the remaining part of the salt
11005
11006 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11007 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11008
11009 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11010
11011 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11012 }
11013
11014 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);
11015 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);
11016
11017 hashes_cnt++;
11018 }
11019
11020 fclose (fp);
11021
11022 myfree (in);
11023 }
11024 else if (hash_mode == 3000)
11025 {
11026 if (hash_len == 32)
11027 {
11028 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11029
11030 hash_t *lm_hash_left = NULL;
11031
11032 if (parser_status == PARSER_OK)
11033 {
11034 lm_hash_left = &hashes_buf[hashes_cnt];
11035
11036 hashes_cnt++;
11037 }
11038 else
11039 {
11040 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11041 }
11042
11043 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11044
11045 hash_t *lm_hash_right = NULL;
11046
11047 if (parser_status == PARSER_OK)
11048 {
11049 lm_hash_right = &hashes_buf[hashes_cnt];
11050
11051 hashes_cnt++;
11052 }
11053 else
11054 {
11055 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11056 }
11057
11058 // show / left
11059
11060 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11061 {
11062 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);
11063 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);
11064 }
11065 }
11066 else
11067 {
11068 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11069
11070 if (parser_status == PARSER_OK)
11071 {
11072 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11073 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11074 }
11075
11076 if (parser_status == PARSER_OK)
11077 {
11078 hashes_cnt++;
11079 }
11080 else
11081 {
11082 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11083 }
11084 }
11085 }
11086 else
11087 {
11088 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11089
11090 if (parser_status == PARSER_OK)
11091 {
11092 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11093 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11094 }
11095
11096 if (parser_status == PARSER_OK)
11097 {
11098 hashes_cnt++;
11099 }
11100 else
11101 {
11102 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11103 }
11104 }
11105 }
11106 }
11107 else if (hashlist_mode == HL_MODE_FILE)
11108 {
11109 char *hashfile = data.hashfile;
11110
11111 FILE *fp;
11112
11113 if ((fp = fopen (hashfile, "rb")) == NULL)
11114 {
11115 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11116
11117 return (-1);
11118 }
11119
11120 uint line_num = 0;
11121
11122 while (!feof (fp))
11123 {
11124 line_num++;
11125
11126 char line_buf[BUFSIZ] = { 0 };
11127
11128 int line_len = fgetl (fp, line_buf);
11129
11130 if (line_len == 0) continue;
11131
11132 char *hash_buf = NULL;
11133 int hash_len = 0;
11134
11135 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11136
11137 if (username)
11138 {
11139 char *user_buf = NULL;
11140 int user_len = 0;
11141
11142 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11143
11144 if (remove || show)
11145 {
11146 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11147
11148 *user = (user_t *) mymalloc (sizeof (user_t));
11149
11150 user_t *user_ptr = *user;
11151
11152 if (user_buf != NULL)
11153 {
11154 user_ptr->user_name = mystrdup (user_buf);
11155 }
11156 else
11157 {
11158 user_ptr->user_name = mystrdup ("");
11159 }
11160
11161 user_ptr->user_len = user_len;
11162 }
11163 }
11164
11165 if (opts_type & OPTS_TYPE_HASH_COPY)
11166 {
11167 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11168
11169 hash_info_tmp->orighash = mystrdup (hash_buf);
11170 }
11171
11172 if (isSalted)
11173 {
11174 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11175 }
11176
11177 if (hash_mode == 3000)
11178 {
11179 if (hash_len == 32)
11180 {
11181 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11182
11183 if (parser_status < PARSER_GLOBAL_ZERO)
11184 {
11185 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11186
11187 continue;
11188 }
11189
11190 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11191
11192 hashes_cnt++;
11193
11194 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11195
11196 if (parser_status < PARSER_GLOBAL_ZERO)
11197 {
11198 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11199
11200 continue;
11201 }
11202
11203 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11204
11205 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);
11206
11207 hashes_cnt++;
11208
11209 // show / left
11210
11211 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);
11212 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);
11213 }
11214 else
11215 {
11216 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11217
11218 if (parser_status < PARSER_GLOBAL_ZERO)
11219 {
11220 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11221
11222 continue;
11223 }
11224
11225 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);
11226
11227 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11228 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11229
11230 hashes_cnt++;
11231 }
11232 }
11233 else
11234 {
11235 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11236
11237 if (parser_status < PARSER_GLOBAL_ZERO)
11238 {
11239 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11240
11241 continue;
11242 }
11243
11244 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);
11245
11246 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11247 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11248
11249 hashes_cnt++;
11250 }
11251 }
11252
11253 fclose (fp);
11254
11255 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11256
11257 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11258 }
11259 }
11260 else
11261 {
11262 if (isSalted)
11263 {
11264 hashes_buf[0].salt->salt_len = 8;
11265
11266 // special salt handling
11267
11268 switch (hash_mode)
11269 {
11270 case 1500: hashes_buf[0].salt->salt_len = 2;
11271 break;
11272 case 1731: hashes_buf[0].salt->salt_len = 4;
11273 break;
11274 case 2410: hashes_buf[0].salt->salt_len = 4;
11275 break;
11276 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11277 break;
11278 case 3100: hashes_buf[0].salt->salt_len = 1;
11279 break;
11280 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11281 break;
11282 case 5800: hashes_buf[0].salt->salt_len = 16;
11283 break;
11284 case 6800: hashes_buf[0].salt->salt_len = 32;
11285 break;
11286 case 8400: hashes_buf[0].salt->salt_len = 40;
11287 break;
11288 case 8800: hashes_buf[0].salt->salt_len = 16;
11289 break;
11290 case 8900: hashes_buf[0].salt->salt_len = 16;
11291 hashes_buf[0].salt->scrypt_N = 1024;
11292 hashes_buf[0].salt->scrypt_r = 1;
11293 hashes_buf[0].salt->scrypt_p = 1;
11294 break;
11295 case 9100: hashes_buf[0].salt->salt_len = 16;
11296 break;
11297 case 9300: hashes_buf[0].salt->salt_len = 14;
11298 hashes_buf[0].salt->scrypt_N = 16384;
11299 hashes_buf[0].salt->scrypt_r = 1;
11300 hashes_buf[0].salt->scrypt_p = 1;
11301 break;
11302 case 9400: hashes_buf[0].salt->salt_len = 16;
11303 break;
11304 case 9500: hashes_buf[0].salt->salt_len = 16;
11305 break;
11306 case 9600: hashes_buf[0].salt->salt_len = 16;
11307 break;
11308 case 9700: hashes_buf[0].salt->salt_len = 16;
11309 break;
11310 case 9710: hashes_buf[0].salt->salt_len = 16;
11311 break;
11312 case 9720: hashes_buf[0].salt->salt_len = 16;
11313 break;
11314 case 9800: hashes_buf[0].salt->salt_len = 16;
11315 break;
11316 case 9810: hashes_buf[0].salt->salt_len = 16;
11317 break;
11318 case 9820: hashes_buf[0].salt->salt_len = 16;
11319 break;
11320 case 10300: hashes_buf[0].salt->salt_len = 12;
11321 break;
11322 case 11500: hashes_buf[0].salt->salt_len = 4;
11323 break;
11324 case 11600: hashes_buf[0].salt->salt_len = 4;
11325 break;
11326 case 12400: hashes_buf[0].salt->salt_len = 4;
11327 break;
11328 case 12500: hashes_buf[0].salt->salt_len = 8;
11329 break;
11330 case 12600: hashes_buf[0].salt->salt_len = 64;
11331 break;
11332 }
11333
11334 // special esalt handling
11335
11336 switch (hash_mode)
11337 {
11338 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11339 break;
11340 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11341 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11342 break;
11343 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11344 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11345 break;
11346 case 5500: ((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 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11352 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11353 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11354 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11355 break;
11356 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11357 break;
11358 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11359 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11360 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11361 break;
11362 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11363 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11364 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11365 break;
11366 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11367 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11368 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11369 break;
11370 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11371 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11372 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11373 break;
11374 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11375 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11376 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11377 break;
11378 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11379 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11380 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11381 break;
11382 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11383 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11384 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11385 break;
11386 }
11387 }
11388
11389 // set hashfile
11390
11391 switch (hash_mode)
11392 {
11393 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11394 break;
11395 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11396 break;
11397 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11398 break;
11399 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11400 break;
11401 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11402 break;
11403 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11404 break;
11405 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11406 break;
11407 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11408 break;
11409 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11410 break;
11411 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11412 break;
11413 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11414 break;
11415 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11416 break;
11417 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11418 break;
11419 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11420 break;
11421 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11422 break;
11423 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11424 break;
11425 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11426 break;
11427 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11428 break;
11429 }
11430
11431 // set default iterations
11432
11433 switch (hash_mode)
11434 {
11435 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11436 break;
11437 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11438 break;
11439 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11440 break;
11441 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11442 break;
11443 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11444 break;
11445 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11446 break;
11447 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11448 break;
11449 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11450 break;
11451 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11452 break;
11453 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11454 break;
11455 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11456 break;
11457 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11458 break;
11459 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11460 break;
11461 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11462 break;
11463 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11464 break;
11465 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11466 break;
11467 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11468 break;
11469 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11470 break;
11471 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11472 break;
11473 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11474 break;
11475 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11476 break;
11477 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11478 break;
11479 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11480 break;
11481 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11482 break;
11483 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11484 break;
11485 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11486 break;
11487 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11488 break;
11489 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11490 break;
11491 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11492 break;
11493 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11494 break;
11495 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11496 break;
11497 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11498 break;
11499 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11500 break;
11501 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11502 break;
11503 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11504 break;
11505 case 8900: hashes_buf[0].salt->salt_iter = 1;
11506 break;
11507 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11508 break;
11509 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11510 break;
11511 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11512 break;
11513 case 9300: hashes_buf[0].salt->salt_iter = 1;
11514 break;
11515 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11516 break;
11517 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11518 break;
11519 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11520 break;
11521 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11522 break;
11523 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11524 break;
11525 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11526 break;
11527 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11528 break;
11529 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11530 break;
11531 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11532 break;
11533 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11534 break;
11535 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11536 break;
11537 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11538 break;
11539 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11540 break;
11541 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11542 break;
11543 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11544 break;
11545 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11546 break;
11547 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11548 break;
11549 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11550 break;
11551 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11552 break;
11553 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11554 break;
11555 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11556 break;
11557 }
11558
11559 hashes_cnt = 1;
11560 }
11561
11562 if (show == 1 || left == 1)
11563 {
11564 for (uint i = 0; i < pot_cnt; i++)
11565 {
11566 pot_t *pot_ptr = &pot[i];
11567
11568 hash_t *hashes_buf = &pot_ptr->hash;
11569
11570 local_free (hashes_buf->digest);
11571
11572 if (isSalted)
11573 {
11574 local_free (hashes_buf->salt);
11575 }
11576 }
11577
11578 local_free (pot);
11579
11580 if (data.quiet == 0) log_info_nn ("");
11581
11582 return (0);
11583 }
11584
11585 if (keyspace == 0)
11586 {
11587 if (hashes_cnt == 0)
11588 {
11589 log_error ("ERROR: No hashes loaded");
11590
11591 return (-1);
11592 }
11593 }
11594
11595 /**
11596 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11597 */
11598
11599 if (data.outfile != NULL)
11600 {
11601 if (data.hashfile != NULL)
11602 {
11603 #ifdef _POSIX
11604 struct stat tmpstat_outfile;
11605 struct stat tmpstat_hashfile;
11606 #endif
11607
11608 #ifdef _WIN
11609 struct stat64 tmpstat_outfile;
11610 struct stat64 tmpstat_hashfile;
11611 #endif
11612
11613 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11614
11615 if (tmp_outfile_fp)
11616 {
11617 #ifdef _POSIX
11618 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11619 #endif
11620
11621 #ifdef _WIN
11622 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11623 #endif
11624
11625 fclose (tmp_outfile_fp);
11626 }
11627
11628 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11629
11630 if (tmp_hashfile_fp)
11631 {
11632 #ifdef _POSIX
11633 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11634 #endif
11635
11636 #ifdef _WIN
11637 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11638 #endif
11639
11640 fclose (tmp_hashfile_fp);
11641 }
11642
11643 if (tmp_outfile_fp && tmp_outfile_fp)
11644 {
11645 tmpstat_outfile.st_mode = 0;
11646 tmpstat_outfile.st_nlink = 0;
11647 tmpstat_outfile.st_uid = 0;
11648 tmpstat_outfile.st_gid = 0;
11649 tmpstat_outfile.st_rdev = 0;
11650 tmpstat_outfile.st_atime = 0;
11651
11652 tmpstat_hashfile.st_mode = 0;
11653 tmpstat_hashfile.st_nlink = 0;
11654 tmpstat_hashfile.st_uid = 0;
11655 tmpstat_hashfile.st_gid = 0;
11656 tmpstat_hashfile.st_rdev = 0;
11657 tmpstat_hashfile.st_atime = 0;
11658
11659 #ifdef _POSIX
11660 tmpstat_outfile.st_blksize = 0;
11661 tmpstat_outfile.st_blocks = 0;
11662
11663 tmpstat_hashfile.st_blksize = 0;
11664 tmpstat_hashfile.st_blocks = 0;
11665 #endif
11666
11667 #ifdef _POSIX
11668 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11669 {
11670 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11671
11672 return (-1);
11673 }
11674 #endif
11675
11676 #ifdef _WIN
11677 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11678 {
11679 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11680
11681 return (-1);
11682 }
11683 #endif
11684 }
11685 }
11686 }
11687
11688 /**
11689 * Remove duplicates
11690 */
11691
11692 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11693
11694 if (isSalted)
11695 {
11696 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11697 }
11698 else
11699 {
11700 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11701 }
11702
11703 uint hashes_cnt_orig = hashes_cnt;
11704
11705 hashes_cnt = 1;
11706
11707 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11708 {
11709 if (isSalted)
11710 {
11711 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11712 {
11713 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11714 }
11715 }
11716 else
11717 {
11718 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11719 }
11720
11721 if (hashes_pos > hashes_cnt)
11722 {
11723 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11724 }
11725
11726 hashes_cnt++;
11727 }
11728
11729 /**
11730 * Potfile removes
11731 */
11732
11733 uint potfile_remove_cracks = 0;
11734
11735 if (potfile_disable == 0)
11736 {
11737 hash_t hash_buf;
11738
11739 hash_buf.digest = mymalloc (dgst_size);
11740 hash_buf.salt = NULL;
11741 hash_buf.esalt = NULL;
11742 hash_buf.hash_info = NULL;
11743 hash_buf.cracked = 0;
11744
11745 if (isSalted)
11746 {
11747 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11748 }
11749
11750 if (esalt_size)
11751 {
11752 hash_buf.esalt = mymalloc (esalt_size);
11753 }
11754
11755 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11756
11757 // no solution for these special hash types (for instane because they use hashfile in output etc)
11758 if ((hash_mode != 5200) &&
11759 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11760 (hash_mode != 9000))
11761 {
11762 FILE *fp = fopen (potfile, "rb");
11763
11764 if (fp != NULL)
11765 {
11766 while (!feof (fp))
11767 {
11768 char line_buf[BUFSIZ] = { 0 };
11769
11770 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11771
11772 if (ptr == NULL) break;
11773
11774 int line_len = strlen (line_buf);
11775
11776 if (line_len == 0) continue;
11777
11778 int iter = MAX_CUT_TRIES;
11779
11780 for (int i = line_len - 1; i && iter; i--, line_len--)
11781 {
11782 if (line_buf[i] != ':') continue;
11783
11784 if (isSalted)
11785 {
11786 memset (hash_buf.salt, 0, sizeof (salt_t));
11787 }
11788
11789 hash_t *found = NULL;
11790
11791 if (hash_mode == 6800)
11792 {
11793 if (i < 64) // 64 = 16 * uint in salt_buf[]
11794 {
11795 // manipulate salt_buf
11796 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11797
11798 hash_buf.salt->salt_len = i;
11799
11800 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11801 }
11802 }
11803 else if (hash_mode == 2500)
11804 {
11805 if (i < 64) // 64 = 16 * uint in salt_buf[]
11806 {
11807 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11808 // manipulate salt_buf
11809
11810 // to be safe work with a copy (because of line_len loop, i etc)
11811
11812 char line_buf_cpy[BUFSIZ] = { 0 };
11813
11814 memcpy (line_buf_cpy, line_buf, i);
11815
11816 char *mac2_pos = strrchr (line_buf_cpy, ':');
11817
11818 if (mac2_pos == NULL) continue;
11819
11820 mac2_pos[0] = 0;
11821 mac2_pos++;
11822
11823 if (strlen (mac2_pos) != 12) continue;
11824
11825 char *mac1_pos = strrchr (line_buf_cpy, ':');
11826
11827 if (mac1_pos == NULL) continue;
11828
11829 mac1_pos[0] = 0;
11830 mac1_pos++;
11831
11832 if (strlen (mac1_pos) != 12) continue;
11833
11834 uint essid_length = mac1_pos - line_buf_cpy - 1;
11835
11836 // here we need the ESSID
11837 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11838
11839 hash_buf.salt->salt_len = essid_length;
11840
11841 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11842
11843 if (found)
11844 {
11845 wpa_t *wpa = (wpa_t *) found->esalt;
11846
11847 uint pke[25] = { 0 };
11848
11849 char *pke_ptr = (char *) pke;
11850
11851 for (uint i = 0; i < 25; i++)
11852 {
11853 pke[i] = byte_swap_32 (wpa->pke[i]);
11854 }
11855
11856 u8 mac1[6] = { 0 };
11857 u8 mac2[6] = { 0 };
11858
11859 memcpy (mac1, pke_ptr + 23, 6);
11860 memcpy (mac2, pke_ptr + 29, 6);
11861
11862 // compare hex string(s) vs binary MAC address(es)
11863
11864 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11865 {
11866 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11867 {
11868 found = NULL;
11869 break;
11870 }
11871 }
11872
11873 // early skip ;)
11874 if (!found) continue;
11875
11876 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11877 {
11878 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11879 {
11880 found = NULL;
11881 break;
11882 }
11883 }
11884 }
11885 }
11886 }
11887 else
11888 {
11889 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11890
11891 if (parser_status == PARSER_OK)
11892 {
11893 if (isSalted)
11894 {
11895 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11896 }
11897 else
11898 {
11899 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11900 }
11901 }
11902 }
11903
11904 if (found == NULL) continue;
11905
11906 if (!found->cracked) potfile_remove_cracks++;
11907
11908 found->cracked = 1;
11909
11910 if (found) break;
11911
11912 iter--;
11913 }
11914 }
11915
11916 fclose (fp);
11917 }
11918 }
11919
11920 if (esalt_size)
11921 {
11922 local_free (hash_buf.esalt);
11923 }
11924
11925 if (isSalted)
11926 {
11927 local_free (hash_buf.salt);
11928 }
11929
11930 local_free (hash_buf.digest);
11931 }
11932
11933 /**
11934 * Now generate all the buffers required for later
11935 */
11936
11937 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11938
11939 salt_t *salts_buf_new = NULL;
11940 void *esalts_buf_new = NULL;
11941
11942 if (isSalted)
11943 {
11944 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11945
11946 if (esalt_size)
11947 {
11948 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11949 }
11950 }
11951 else
11952 {
11953 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11954 }
11955
11956 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11957
11958 uint digests_cnt = hashes_cnt;
11959 uint digests_done = 0;
11960
11961 uint size_digests = digests_cnt * dgst_size;
11962 uint size_shown = digests_cnt * sizeof (uint);
11963
11964 uint *digests_shown = (uint *) mymalloc (size_shown);
11965 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11966
11967 uint salts_cnt = 0;
11968 uint salts_done = 0;
11969
11970 hashinfo_t **hash_info = NULL;
11971
11972 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11973 {
11974 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11975
11976 if (username && (remove || show))
11977 {
11978 uint user_pos;
11979
11980 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11981 {
11982 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11983
11984 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11985 }
11986 }
11987 }
11988
11989 uint *salts_shown = (uint *) mymalloc (size_shown);
11990
11991 salt_t *salt_buf;
11992
11993 {
11994 // copied from inner loop
11995
11996 salt_buf = &salts_buf_new[salts_cnt];
11997
11998 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11999
12000 if (esalt_size)
12001 {
12002 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12003 }
12004
12005 salt_buf->digests_cnt = 0;
12006 salt_buf->digests_done = 0;
12007 salt_buf->digests_offset = 0;
12008
12009 salts_cnt++;
12010 }
12011
12012 if (hashes_buf[0].cracked == 1)
12013 {
12014 digests_shown[0] = 1;
12015
12016 digests_done++;
12017
12018 salt_buf->digests_done++;
12019 }
12020
12021 salt_buf->digests_cnt++;
12022
12023 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12024
12025 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12026 {
12027 hash_info[0] = hashes_buf[0].hash_info;
12028 }
12029
12030 // copy from inner loop
12031
12032 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12033 {
12034 if (isSalted)
12035 {
12036 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12037 {
12038 salt_buf = &salts_buf_new[salts_cnt];
12039
12040 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12041
12042 if (esalt_size)
12043 {
12044 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12045 }
12046
12047 salt_buf->digests_cnt = 0;
12048 salt_buf->digests_done = 0;
12049 salt_buf->digests_offset = hashes_pos;
12050
12051 salts_cnt++;
12052 }
12053 }
12054
12055 if (hashes_buf[hashes_pos].cracked == 1)
12056 {
12057 digests_shown[hashes_pos] = 1;
12058
12059 digests_done++;
12060
12061 salt_buf->digests_done++;
12062 }
12063
12064 salt_buf->digests_cnt++;
12065
12066 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12067
12068 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12069 {
12070 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12071 }
12072 }
12073
12074 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12075 {
12076 salt_t *salt_buf = &salts_buf_new[salt_pos];
12077
12078 if (salt_buf->digests_done == salt_buf->digests_cnt)
12079 {
12080 salts_shown[salt_pos] = 1;
12081
12082 salts_done++;
12083 }
12084
12085 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12086 }
12087
12088 local_free (digests_buf);
12089 local_free (salts_buf);
12090 local_free (esalts_buf);
12091
12092 digests_buf = digests_buf_new;
12093 salts_buf = salts_buf_new;
12094 esalts_buf = esalts_buf_new;
12095
12096 local_free (hashes_buf);
12097
12098 /**
12099 * special modification not set from parser
12100 */
12101
12102 switch (hash_mode)
12103 {
12104 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12105 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12106 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12107 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12108 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12109 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12110 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12111 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12112 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12113 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12114 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12115 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12116 }
12117
12118 if (truecrypt_keyfiles)
12119 {
12120 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12121
12122 char *keyfiles = strdup (truecrypt_keyfiles);
12123
12124 char *keyfile = strtok (keyfiles, ",");
12125
12126 do
12127 {
12128 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12129
12130 } while ((keyfile = strtok (NULL, ",")) != NULL);
12131
12132 free (keyfiles);
12133 }
12134
12135 data.digests_cnt = digests_cnt;
12136 data.digests_done = digests_done;
12137 data.digests_buf = digests_buf;
12138 data.digests_shown = digests_shown;
12139 data.digests_shown_tmp = digests_shown_tmp;
12140
12141 data.salts_cnt = salts_cnt;
12142 data.salts_done = salts_done;
12143 data.salts_buf = salts_buf;
12144 data.salts_shown = salts_shown;
12145
12146 data.esalts_buf = esalts_buf;
12147 data.hash_info = hash_info;
12148
12149 /**
12150 * Automatic Optimizers
12151 */
12152
12153 if (salts_cnt == 1)
12154 opti_type |= OPTI_TYPE_SINGLE_SALT;
12155
12156 if (digests_cnt == 1)
12157 opti_type |= OPTI_TYPE_SINGLE_HASH;
12158
12159 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12160 opti_type |= OPTI_TYPE_NOT_ITERATED;
12161
12162 if (attack_mode == ATTACK_MODE_BF)
12163 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12164
12165 data.opti_type = opti_type;
12166
12167 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12168 {
12169 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12170 {
12171 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12172 {
12173 if (opts_type & OPTS_TYPE_ST_ADD80)
12174 {
12175 opts_type &= ~OPTS_TYPE_ST_ADD80;
12176 opts_type |= OPTS_TYPE_PT_ADD80;
12177 }
12178
12179 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12180 {
12181 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12182 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12183 }
12184
12185 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12186 {
12187 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12188 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12189 }
12190 }
12191 }
12192 }
12193
12194 /**
12195 * Some algorithm, like descrypt, can benefit from JIT compilation
12196 */
12197
12198 int force_jit_compilation = -1;
12199
12200 if (hash_mode == 8900)
12201 {
12202 force_jit_compilation = 8900;
12203 }
12204 else if (hash_mode == 9300)
12205 {
12206 force_jit_compilation = 8900;
12207 }
12208 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12209 {
12210 force_jit_compilation = 1500;
12211 }
12212
12213 /**
12214 * generate bitmap tables
12215 */
12216
12217 const uint bitmap_shift1 = 5;
12218 const uint bitmap_shift2 = 13;
12219
12220 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12221
12222 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12223 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12224 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12225 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12226 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12227 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12228 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12229 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12230
12231 uint bitmap_bits;
12232 uint bitmap_nums;
12233 uint bitmap_mask;
12234 uint bitmap_size;
12235
12236 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12237 {
12238 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12239
12240 bitmap_nums = 1 << bitmap_bits;
12241
12242 bitmap_mask = bitmap_nums - 1;
12243
12244 bitmap_size = bitmap_nums * sizeof (uint);
12245
12246 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12247
12248 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;
12249 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;
12250
12251 break;
12252 }
12253
12254 bitmap_nums = 1 << bitmap_bits;
12255
12256 bitmap_mask = bitmap_nums - 1;
12257
12258 bitmap_size = bitmap_nums * sizeof (uint);
12259
12260 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);
12261 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);
12262
12263 /**
12264 * prepare quick rule
12265 */
12266
12267 data.rule_buf_l = rule_buf_l;
12268 data.rule_buf_r = rule_buf_r;
12269
12270 int rule_len_l = (int) strlen (rule_buf_l);
12271 int rule_len_r = (int) strlen (rule_buf_r);
12272
12273 data.rule_len_l = rule_len_l;
12274 data.rule_len_r = rule_len_r;
12275
12276 /**
12277 * load rules
12278 */
12279
12280 uint *all_kernel_rules_cnt = NULL;
12281
12282 kernel_rule_t **all_kernel_rules_buf = NULL;
12283
12284 if (rp_files_cnt)
12285 {
12286 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12287
12288 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12289 }
12290
12291 char rule_buf[BUFSIZ] = { 0 };
12292
12293 int rule_len = 0;
12294
12295 for (uint i = 0; i < rp_files_cnt; i++)
12296 {
12297 uint kernel_rules_avail = 0;
12298
12299 uint kernel_rules_cnt = 0;
12300
12301 kernel_rule_t *kernel_rules_buf = NULL;
12302
12303 char *rp_file = rp_files[i];
12304
12305 char in[BLOCK_SIZE] = { 0 };
12306 char out[BLOCK_SIZE] = { 0 };
12307
12308 FILE *fp = NULL;
12309
12310 uint rule_line = 0;
12311
12312 if ((fp = fopen (rp_file, "rb")) == NULL)
12313 {
12314 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12315
12316 return (-1);
12317 }
12318
12319 while (!feof (fp))
12320 {
12321 memset (rule_buf, 0, BUFSIZ);
12322
12323 rule_len = fgetl (fp, rule_buf);
12324
12325 rule_line++;
12326
12327 if (rule_len == 0) continue;
12328
12329 if (rule_buf[0] == '#') continue;
12330
12331 if (kernel_rules_avail == kernel_rules_cnt)
12332 {
12333 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12334
12335 kernel_rules_avail += INCR_RULES;
12336 }
12337
12338 memset (in, 0, BLOCK_SIZE);
12339 memset (out, 0, BLOCK_SIZE);
12340
12341 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12342
12343 if (result == -1)
12344 {
12345 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12346
12347 continue;
12348 }
12349
12350 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12351 {
12352 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12353
12354 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12355
12356 continue;
12357 }
12358
12359 /* its so slow
12360 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12361 {
12362 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12363
12364 continue;
12365 }
12366 */
12367
12368 kernel_rules_cnt++;
12369 }
12370
12371 fclose (fp);
12372
12373 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12374
12375 all_kernel_rules_buf[i] = kernel_rules_buf;
12376 }
12377
12378 /**
12379 * merge rules or automatic rule generator
12380 */
12381
12382 uint kernel_rules_cnt = 0;
12383
12384 kernel_rule_t *kernel_rules_buf = NULL;
12385
12386 if (attack_mode == ATTACK_MODE_STRAIGHT)
12387 {
12388 if (rp_files_cnt)
12389 {
12390 kernel_rules_cnt = 1;
12391
12392 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12393
12394 repeats[0] = kernel_rules_cnt;
12395
12396 for (uint i = 0; i < rp_files_cnt; i++)
12397 {
12398 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12399
12400 repeats[i + 1] = kernel_rules_cnt;
12401 }
12402
12403 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12404
12405 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12406
12407 for (uint i = 0; i < kernel_rules_cnt; i++)
12408 {
12409 uint out_pos = 0;
12410
12411 kernel_rule_t *out = &kernel_rules_buf[i];
12412
12413 for (uint j = 0; j < rp_files_cnt; j++)
12414 {
12415 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12416 uint in_pos;
12417
12418 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12419
12420 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12421 {
12422 if (out_pos == RULES_MAX - 1)
12423 {
12424 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12425
12426 break;
12427 }
12428
12429 out->cmds[out_pos] = in->cmds[in_pos];
12430 }
12431 }
12432 }
12433
12434 local_free (repeats);
12435 }
12436 else if (rp_gen)
12437 {
12438 uint kernel_rules_avail = 0;
12439
12440 while (kernel_rules_cnt < rp_gen)
12441 {
12442 if (kernel_rules_avail == kernel_rules_cnt)
12443 {
12444 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12445
12446 kernel_rules_avail += INCR_RULES;
12447 }
12448
12449 memset (rule_buf, 0, BLOCK_SIZE);
12450
12451 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12452
12453 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12454
12455 kernel_rules_cnt++;
12456 }
12457 }
12458 }
12459
12460 /**
12461 * generate NOP rules
12462 */
12463
12464 if (kernel_rules_cnt == 0)
12465 {
12466 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12467
12468 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12469
12470 kernel_rules_cnt++;
12471 }
12472
12473 data.kernel_rules_cnt = kernel_rules_cnt;
12474 data.kernel_rules_buf = kernel_rules_buf;
12475
12476 /**
12477 * OpenCL platforms: detect
12478 */
12479
12480 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12481 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12482
12483 cl_uint platforms_cnt = 0;
12484 cl_uint platform_devices_cnt = 0;
12485
12486 if (keyspace == 0)
12487 {
12488 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12489
12490 if (platforms_cnt == 0)
12491 {
12492 log_error ("ERROR: No OpenCL compatible platform found");
12493
12494 return (-1);
12495 }
12496 }
12497
12498 /**
12499 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12500 */
12501
12502 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12503 {
12504 cl_platform_id platform = platforms[platform_id];
12505
12506 char platform_vendor[INFOSZ] = { 0 };
12507
12508 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12509
12510 #ifdef HAVE_HWMON
12511 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12512 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12513 {
12514 // make sure that we do not directly control the fan for NVidia
12515
12516 gpu_temp_retain = 0;
12517
12518 data.gpu_temp_retain = gpu_temp_retain;
12519 }
12520 #endif // HAVE_NVML || HAVE_NVAPI
12521 #endif
12522 }
12523
12524 /**
12525 * OpenCL devices: simply push all devices from all platforms into the same device array
12526 */
12527
12528 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12529
12530 data.devices_param = devices_param;
12531
12532 uint devices_cnt = 0;
12533
12534 uint devices_active = 0;
12535
12536 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12537 {
12538 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12539
12540 cl_platform_id platform = platforms[platform_id];
12541
12542 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12543
12544 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12545 {
12546 size_t param_value_size = 0;
12547
12548 const uint device_id = devices_cnt;
12549
12550 hc_device_param_t *device_param = &data.devices_param[device_id];
12551
12552 device_param->device = platform_devices[platform_devices_id];
12553
12554 device_param->device_id = device_id;
12555
12556 device_param->platform_devices_id = platform_devices_id;
12557
12558 // device_type
12559
12560 cl_device_type device_type;
12561
12562 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12563
12564 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12565
12566 device_param->device_type = device_type;
12567
12568 // vendor_id
12569
12570 cl_uint vendor_id = 0;
12571
12572 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12573
12574 device_param->vendor_id = vendor_id;
12575
12576 // device_name
12577
12578 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12579
12580 char *device_name = (char *) mymalloc (param_value_size);
12581
12582 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12583
12584 device_param->device_name = device_name;
12585
12586 // tuning db
12587
12588 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12589
12590 // device_version
12591
12592 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12593
12594 char *device_version = (char *) mymalloc (param_value_size);
12595
12596 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12597
12598 device_param->device_version = device_version;
12599
12600 // device_opencl_version
12601
12602 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12603
12604 char *device_opencl_version = (char *) mymalloc (param_value_size);
12605
12606 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12607
12608 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12609
12610 myfree (device_opencl_version);
12611
12612 if (strstr (device_version, "pocl"))
12613 {
12614 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12615 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12616
12617 cl_uint vendor_id = VENDOR_ID_GENERIC;
12618
12619 device_param->vendor_id = vendor_id;
12620 }
12621
12622 // vector_width
12623
12624 cl_uint vector_width;
12625
12626 if (opencl_vector_width_chgd == 0)
12627 {
12628 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12629 {
12630 if (opti_type & OPTI_TYPE_USES_BITS_64)
12631 {
12632 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12633 }
12634 else
12635 {
12636 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12637 }
12638 }
12639 else
12640 {
12641 vector_width = (cl_uint) tuningdb_entry->vector_width;
12642 }
12643 }
12644 else
12645 {
12646 vector_width = opencl_vector_width;
12647 }
12648
12649 if (vector_width > 16) vector_width = 16;
12650
12651 device_param->vector_width = vector_width;
12652
12653 // max_compute_units
12654
12655 cl_uint device_processors;
12656
12657 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12658
12659 device_param->device_processors = device_processors;
12660
12661 // max_mem_alloc_size
12662
12663 cl_ulong device_maxmem_alloc;
12664
12665 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12666
12667 device_param->device_maxmem_alloc = device_maxmem_alloc;
12668
12669 // max_mem_alloc_size
12670
12671 cl_ulong device_global_mem;
12672
12673 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12674
12675 device_param->device_global_mem = device_global_mem;
12676
12677 // max_clock_frequency
12678
12679 cl_uint device_maxclock_frequency;
12680
12681 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12682
12683 device_param->device_maxclock_frequency = device_maxclock_frequency;
12684
12685 // skipped
12686
12687 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12688 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12689
12690 device_param->skipped = (skipped1 || skipped2);
12691
12692 // driver_version
12693 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12694
12695 char *driver_version = (char *) mymalloc (param_value_size);
12696
12697 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12698
12699 device_param->driver_version = driver_version;
12700
12701 // device_name_chksum
12702
12703 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12704
12705 #if __x86_64__
12706 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);
12707 #else
12708 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);
12709 #endif
12710
12711 uint device_name_digest[4] = { 0 };
12712
12713 md5_64 ((uint *) device_name_chksum, device_name_digest);
12714
12715 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12716
12717 device_param->device_name_chksum = device_name_chksum;
12718
12719 // device_processor_cores
12720
12721 if (device_type & CL_DEVICE_TYPE_CPU)
12722 {
12723 cl_uint device_processor_cores = 1;
12724
12725 device_param->device_processor_cores = device_processor_cores;
12726 }
12727
12728 if (device_type & CL_DEVICE_TYPE_GPU)
12729 {
12730 if (vendor_id == VENDOR_ID_AMD)
12731 {
12732 cl_uint device_processor_cores = 0;
12733
12734 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12735
12736 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12737
12738 device_param->device_processor_cores = device_processor_cores;
12739 }
12740 else if (vendor_id == VENDOR_ID_NV)
12741 {
12742 cl_uint kernel_exec_timeout = 0;
12743
12744 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12745
12746 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12747
12748 device_param->kernel_exec_timeout = kernel_exec_timeout;
12749
12750 cl_uint device_processor_cores = 0;
12751
12752 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12753
12754 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12755
12756 device_param->device_processor_cores = device_processor_cores;
12757
12758 cl_uint sm_minor = 0;
12759 cl_uint sm_major = 0;
12760
12761 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12762 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12763
12764 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12765 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12766
12767 device_param->sm_minor = sm_minor;
12768 device_param->sm_major = sm_major;
12769 }
12770 else
12771 {
12772 cl_uint device_processor_cores = 1;
12773
12774 device_param->device_processor_cores = device_processor_cores;
12775 }
12776 }
12777
12778 // display results
12779
12780 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12781 {
12782 if (device_param->skipped == 0)
12783 {
12784 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12785 device_id + 1,
12786 device_name,
12787 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12788 (unsigned int) (device_global_mem / 1024 / 1024),
12789 (unsigned int) (device_maxclock_frequency),
12790 (unsigned int) device_processors);
12791 }
12792 else
12793 {
12794 log_info ("Device #%u: %s, skipped",
12795 device_id + 1,
12796 device_name);
12797 }
12798 }
12799
12800 // common driver check
12801
12802 if (device_param->skipped == 0)
12803 {
12804 if (strstr (device_version, "pocl"))
12805 {
12806 if (force == 0)
12807 {
12808 log_info ("");
12809 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12810 log_info ("You are STRONGLY encouraged not to use it");
12811 log_info ("You can use --force to override this but do not post error reports if you do so");
12812 log_info ("");
12813
12814 return (-1);
12815 }
12816 }
12817
12818 if (device_type & CL_DEVICE_TYPE_GPU)
12819 {
12820 if (vendor_id == VENDOR_ID_NV)
12821 {
12822 if (device_param->kernel_exec_timeout != 0)
12823 {
12824 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);
12825 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12826 }
12827 }
12828 else if (vendor_id == VENDOR_ID_AMD)
12829 {
12830 int catalyst_check = (force == 1) ? 0 : 1;
12831
12832 int catalyst_warn = 0;
12833
12834 int catalyst_broken = 0;
12835
12836 if (catalyst_check == 1)
12837 {
12838 catalyst_warn = 1;
12839
12840 // v14.9 and higher
12841 if (atoi (device_param->driver_version) >= 1573)
12842 {
12843 catalyst_warn = 0;
12844 }
12845
12846 catalyst_check = 0;
12847 }
12848
12849 if (catalyst_broken == 1)
12850 {
12851 log_info ("");
12852 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12853 log_info ("It will pass over cracked hashes and does not report them as cracked");
12854 log_info ("You are STRONGLY encouraged not to use it");
12855 log_info ("You can use --force to override this but do not post error reports if you do so");
12856 log_info ("");
12857
12858 return (-1);
12859 }
12860
12861 if (catalyst_warn == 1)
12862 {
12863 log_info ("");
12864 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12865 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12866 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12867 #ifdef _WIN
12868 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12869 #endif
12870 log_info ("You can use --force to override this but do not post error reports if you do so");
12871 log_info ("");
12872
12873 return (-1);
12874 }
12875 }
12876 }
12877
12878 /**
12879 * kernel accel and loops tuning db adjustment
12880 */
12881
12882 device_param->kernel_accel_min = 1;
12883 device_param->kernel_accel_max = 1024;
12884
12885 device_param->kernel_loops_min = 1;
12886 device_param->kernel_loops_max = 1024;
12887
12888 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12889
12890 if (tuningdb_entry)
12891 {
12892 u32 _kernel_accel = tuningdb_entry->kernel_accel;
12893 u32 _kernel_loops = tuningdb_entry->kernel_loops;
12894
12895 if (_kernel_accel)
12896 {
12897 device_param->kernel_accel_min = _kernel_accel;
12898 device_param->kernel_accel_max = _kernel_accel;
12899 }
12900
12901 if (_kernel_loops)
12902 {
12903 if (workload_profile == 1)
12904 {
12905 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
12906 }
12907 else if (workload_profile == 2)
12908 {
12909 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
12910 }
12911
12912 device_param->kernel_loops_min = _kernel_loops;
12913 device_param->kernel_loops_max = _kernel_loops;
12914 }
12915 }
12916
12917 // commandline parameters overwrite tuningdb entries
12918
12919 if (kernel_accel)
12920 {
12921 device_param->kernel_accel_min = kernel_accel;
12922 device_param->kernel_accel_max = kernel_accel;
12923 }
12924
12925 if (kernel_loops)
12926 {
12927 device_param->kernel_loops_min = kernel_loops;
12928 device_param->kernel_loops_max = kernel_loops;
12929 }
12930
12931 /**
12932 * activate device
12933 */
12934
12935 devices_active++;
12936 }
12937
12938 // next please
12939
12940 devices_cnt++;
12941 }
12942 }
12943
12944 if (keyspace == 0 && devices_active == 0)
12945 {
12946 log_error ("ERROR: No devices found/left");
12947
12948 return (-1);
12949 }
12950
12951 data.devices_cnt = devices_cnt;
12952
12953 data.devices_active = devices_active;
12954
12955 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12956 {
12957 log_info ("");
12958 }
12959
12960 /**
12961 * HM devices: init
12962 */
12963
12964 #ifdef HAVE_HWMON
12965 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12966 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12967 #endif
12968
12969 #ifdef HAVE_ADL
12970 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12971 #endif
12972
12973 if (gpu_temp_disable == 0)
12974 {
12975 #if defined(WIN) && defined(HAVE_NVAPI)
12976 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
12977
12978 if (nvapi_init (nvapi) == 0)
12979 data.hm_nv = nvapi;
12980
12981 if (data.hm_nv)
12982 {
12983 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
12984 {
12985 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
12986
12987 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12988
12989 int tmp_out = 0;
12990
12991 for (int i = 0; i < tmp_in; i++)
12992 {
12993 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12994 }
12995
12996 for (int i = 0; i < tmp_out; i++)
12997 {
12998 NV_GPU_COOLER_SETTINGS pCoolerSettings;
12999
13000 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13001
13002 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;
13003 }
13004 }
13005 }
13006 #endif // WIN && HAVE_NVAPI
13007
13008 #if defined(LINUX) && defined(HAVE_NVML)
13009 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13010
13011 if (nvml_init (nvml) == 0)
13012 data.hm_nv = nvml;
13013
13014 if (data.hm_nv)
13015 {
13016 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13017 {
13018 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13019
13020 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13021
13022 int tmp_out = 0;
13023
13024 for (int i = 0; i < tmp_in; i++)
13025 {
13026 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13027 }
13028
13029 for (int i = 0; i < tmp_out; i++)
13030 {
13031 unsigned int speed;
13032
13033 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;
13034 }
13035 }
13036 }
13037 #endif // LINUX && HAVE_NVML
13038
13039 data.hm_amd = NULL;
13040
13041 #ifdef HAVE_ADL
13042 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13043
13044 if (adl_init (adl) == 0)
13045 data.hm_amd = adl;
13046
13047 if (data.hm_amd)
13048 {
13049 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13050 {
13051 // total number of adapters
13052
13053 int hm_adapters_num;
13054
13055 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13056
13057 // adapter info
13058
13059 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13060
13061 if (lpAdapterInfo == NULL) return (-1);
13062
13063 // get a list (of ids of) valid/usable adapters
13064
13065 int num_adl_adapters = 0;
13066
13067 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13068
13069 if (num_adl_adapters > 0)
13070 {
13071 hc_thread_mutex_lock (mux_adl);
13072
13073 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13074
13075 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13076
13077 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13078 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13079
13080 hc_thread_mutex_unlock (mux_adl);
13081 }
13082
13083 myfree (valid_adl_device_list);
13084 myfree (lpAdapterInfo);
13085 }
13086 }
13087 #endif // HAVE_ADL
13088
13089 if (data.hm_amd == NULL && data.hm_nv == NULL)
13090 {
13091 gpu_temp_disable = 1;
13092 }
13093 }
13094
13095 /**
13096 * OpenCL devices: allocate buffer for device specific information
13097 */
13098
13099 #ifdef HAVE_HWMON
13100 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13101
13102 #ifdef HAVE_ADL
13103 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13104
13105 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13106 #endif // ADL
13107 #endif
13108
13109 /**
13110 * enable custom signal handler(s)
13111 */
13112
13113 if (benchmark == 0)
13114 {
13115 hc_signal (sigHandler_default);
13116 }
13117 else
13118 {
13119 hc_signal (sigHandler_benchmark);
13120 }
13121
13122 /**
13123 * User-defined GPU temp handling
13124 */
13125
13126 #ifdef HAVE_HWMON
13127 if (gpu_temp_disable == 1)
13128 {
13129 gpu_temp_abort = 0;
13130 gpu_temp_retain = 0;
13131 }
13132
13133 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13134 {
13135 if (gpu_temp_abort < gpu_temp_retain)
13136 {
13137 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13138
13139 return (-1);
13140 }
13141 }
13142
13143 data.gpu_temp_disable = gpu_temp_disable;
13144 data.gpu_temp_abort = gpu_temp_abort;
13145 data.gpu_temp_retain = gpu_temp_retain;
13146 #endif
13147
13148 /**
13149 * inform the user
13150 */
13151
13152 if (data.quiet == 0)
13153 {
13154 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13155
13156 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);
13157
13158 if (attack_mode == ATTACK_MODE_STRAIGHT)
13159 {
13160 log_info ("Rules: %u", kernel_rules_cnt);
13161 }
13162
13163 if (opti_type)
13164 {
13165 log_info ("Applicable Optimizers:");
13166
13167 for (uint i = 0; i < 32; i++)
13168 {
13169 const uint opti_bit = 1u << i;
13170
13171 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13172 }
13173 }
13174
13175 /**
13176 * Watchdog and Temperature balance
13177 */
13178
13179 #ifdef HAVE_HWMON
13180 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13181 {
13182 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13183 }
13184
13185 if (gpu_temp_abort == 0)
13186 {
13187 log_info ("Watchdog: Temperature abort trigger disabled");
13188 }
13189 else
13190 {
13191 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13192 }
13193
13194 if (gpu_temp_retain == 0)
13195 {
13196 log_info ("Watchdog: Temperature retain trigger disabled");
13197 }
13198 else
13199 {
13200 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13201 }
13202 #endif
13203 }
13204
13205 if (data.quiet == 0) log_info ("");
13206
13207 /**
13208 * HM devices: copy
13209 */
13210
13211 if (gpu_temp_disable == 0)
13212 {
13213 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13214 {
13215 hc_device_param_t *device_param = &data.devices_param[device_id];
13216
13217 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13218
13219 if (device_param->skipped) continue;
13220
13221 const uint platform_devices_id = device_param->platform_devices_id;
13222
13223 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13224 if (device_param->vendor_id == VENDOR_ID_NV)
13225 {
13226 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13227 }
13228 #endif
13229
13230 #ifdef HAVE_ADL
13231 if (device_param->vendor_id == VENDOR_ID_AMD)
13232 {
13233 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13234 }
13235 #endif
13236 }
13237 }
13238
13239 /*
13240 * Temporary fix:
13241 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13242 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13243 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13244 * Driver / ADL bug?
13245 */
13246
13247 #ifdef HAVE_ADL
13248 if (powertune_enable == 1)
13249 {
13250 hc_thread_mutex_lock (mux_adl);
13251
13252 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13253 {
13254 hc_device_param_t *device_param = &data.devices_param[device_id];
13255
13256 if (device_param->skipped) continue;
13257
13258 if (data.hm_device[device_id].od_version == 6)
13259 {
13260 // set powertune value only
13261
13262 int powertune_supported = 0;
13263
13264 int ADL_rc = 0;
13265
13266 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13267 {
13268 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13269
13270 return (-1);
13271 }
13272
13273 if (powertune_supported != 0)
13274 {
13275 // powertune set
13276 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13277
13278 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13279 {
13280 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13281
13282 return (-1);
13283 }
13284
13285 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13286 {
13287 log_error ("ERROR: Failed to set new ADL PowerControl values");
13288
13289 return (-1);
13290 }
13291 }
13292 }
13293 }
13294
13295 hc_thread_mutex_unlock (mux_adl);
13296 }
13297 #endif // HAVE_ADK
13298 #endif // HAVE_HWMON
13299
13300 #ifdef DEBUG
13301 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13302 #endif
13303
13304 uint kernel_power_all = 0;
13305
13306 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13307 {
13308 /**
13309 * host buffer
13310 */
13311
13312 hc_device_param_t *device_param = &data.devices_param[device_id];
13313
13314 if (device_param->skipped) continue;
13315
13316 /**
13317 * device properties
13318 */
13319
13320 const char *device_name_chksum = device_param->device_name_chksum;
13321 const u32 device_processors = device_param->device_processors;
13322 const u32 device_processor_cores = device_param->device_processor_cores;
13323
13324 /**
13325 * create context for each device
13326 */
13327
13328 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13329
13330 /**
13331 * create command-queue
13332 */
13333
13334 // not supported with NV
13335 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13336
13337 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13338
13339 /**
13340 * create input buffers on device : calculate size of fixed memory buffers
13341 */
13342
13343 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13344 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13345
13346 device_param->size_root_css = size_root_css;
13347 device_param->size_markov_css = size_markov_css;
13348
13349 uint size_results = KERNEL_THREADS * sizeof (uint);
13350
13351 device_param->size_results = size_results;
13352
13353 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13354 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13355
13356 uint size_plains = digests_cnt * sizeof (plain_t);
13357 uint size_salts = salts_cnt * sizeof (salt_t);
13358 uint size_esalts = salts_cnt * esalt_size;
13359
13360 device_param->size_plains = size_plains;
13361 device_param->size_digests = size_digests;
13362 device_param->size_shown = size_shown;
13363 device_param->size_salts = size_salts;
13364
13365 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13366 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13367 uint size_tm = 32 * sizeof (bs_word_t);
13368
13369 // scryptV stuff
13370
13371 u64 size_scryptV = 1;
13372
13373 if ((hash_mode == 8900) || (hash_mode == 9300))
13374 {
13375 uint tmto_start = 0;
13376 uint tmto_stop = 10;
13377
13378 if (scrypt_tmto)
13379 {
13380 tmto_start = scrypt_tmto;
13381 }
13382 else
13383 {
13384 // in case the user did not specify the tmto manually
13385 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13386 // but set the lower end only in case the user has a device with too less memory
13387
13388 if (hash_mode == 8900)
13389 {
13390 if (device_param->vendor_id == VENDOR_ID_AMD)
13391 {
13392 tmto_start = 1;
13393 }
13394 else if (device_param->vendor_id == VENDOR_ID_NV)
13395 {
13396 tmto_start = 3;
13397 }
13398 }
13399 else if (hash_mode == 9300)
13400 {
13401 if (device_param->vendor_id == VENDOR_ID_AMD)
13402 {
13403 tmto_start = 3;
13404 }
13405 else if (device_param->vendor_id == VENDOR_ID_NV)
13406 {
13407 tmto_start = 5;
13408 }
13409 }
13410 }
13411
13412 if (quiet == 0) log_info ("");
13413
13414 uint shader_per_mp = 1;
13415
13416 if (device_param->vendor_id == VENDOR_ID_AMD)
13417 {
13418 shader_per_mp = 8;
13419 }
13420 else if (device_param->vendor_id == VENDOR_ID_NV)
13421 {
13422 shader_per_mp = 32;
13423 }
13424
13425 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13426 {
13427 // TODO: in theory the following calculation needs to be done per salt, not global
13428 // we assume all hashes have the same scrypt settings
13429
13430 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13431
13432 size_scryptV /= 1 << tmto;
13433
13434 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13435
13436 if (size_scryptV > device_param->device_maxmem_alloc)
13437 {
13438 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13439
13440 continue;
13441 }
13442
13443 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13444 {
13445 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13446 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13447 }
13448
13449 break;
13450 }
13451
13452 if (data.salts_buf[0].scrypt_phy == 0)
13453 {
13454 log_error ("ERROR: can't allocate enough device memory");
13455
13456 return -1;
13457 }
13458
13459 if (quiet == 0) log_info ("");
13460 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13461 }
13462
13463 /**
13464 * create input buffers on device : calculate size of dynamic size memory buffers
13465 */
13466
13467 uint kernel_threads = KERNEL_THREADS;
13468
13469 // some algorithms need a fixed kernel-threads count (mostly because of shared memory usage)
13470
13471 if (hash_mode == 3200) kernel_threads = 8;
13472 if (hash_mode == 9000) kernel_threads = 8;
13473
13474 /**
13475 * some algorithms need a fixed kernel-loops count
13476 */
13477
13478 if (hash_mode == 1500)
13479 {
13480 const u32 kernel_loops_fixed = 1024;
13481
13482 device_param->kernel_loops_min = kernel_loops_fixed;
13483 device_param->kernel_loops_max = kernel_loops_fixed;
13484 }
13485
13486 if (hash_mode == 3000)
13487 {
13488 const u32 kernel_loops_fixed = 1024;
13489
13490 device_param->kernel_loops_min = kernel_loops_fixed;
13491 device_param->kernel_loops_max = kernel_loops_fixed;
13492 }
13493
13494 if (hash_mode == 8900)
13495 {
13496 const u32 kernel_loops_fixed = 1;
13497
13498 device_param->kernel_loops_min = kernel_loops_fixed;
13499 device_param->kernel_loops_max = kernel_loops_fixed;
13500 }
13501
13502 if (hash_mode == 9300)
13503 {
13504 const u32 kernel_loops_fixed = 1;
13505
13506 device_param->kernel_loops_min = kernel_loops_fixed;
13507 device_param->kernel_loops_max = kernel_loops_fixed;
13508 }
13509
13510 if (hash_mode == 12500)
13511 {
13512 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13513
13514 device_param->kernel_loops_min = kernel_loops_fixed;
13515 device_param->kernel_loops_max = kernel_loops_fixed;
13516 }
13517
13518 /**
13519 * some algorithms have a maximum kernel-loops count
13520 */
13521
13522 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13523 {
13524 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13525 {
13526 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13527 }
13528 }
13529
13530 /**
13531 * some algorithms need a special kernel-accel
13532 */
13533
13534 if (hash_mode == 8900)
13535 {
13536 device_param->kernel_accel_min = 1;
13537 device_param->kernel_accel_max = 64;
13538 }
13539
13540 if (hash_mode == 9300)
13541 {
13542 device_param->kernel_accel_min = 1;
13543 device_param->kernel_accel_max = 64;
13544 }
13545
13546 u32 kernel_accel_min = device_param->kernel_accel_min;
13547 u32 kernel_accel_max = device_param->kernel_accel_max;
13548
13549 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13550
13551 uint size_pws = 4;
13552 uint size_tmps = 4;
13553 uint size_hooks = 4;
13554
13555 while (kernel_accel_max >= kernel_accel_min)
13556 {
13557 uint kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13558
13559 // size_pws
13560
13561 size_pws = kernel_power_max * sizeof (pw_t);
13562
13563 // size_tmps
13564
13565 switch (hash_mode)
13566 {
13567 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13568 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13569 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13570 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13571 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13572 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13573 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13574 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13575 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13576 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13577 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13578 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13579 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13580 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13581 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13582 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13583 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13584 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13585 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13586 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13587 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13588 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13589 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13590 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13591 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13592 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13593 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13594 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13595 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13596 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13597 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13598 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13599 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13600 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13601 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13602 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13603 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13604 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13605 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13606 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13607 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13608 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13609 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13610 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13611 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13612 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13613 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13614 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13615 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13616 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13617 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13618 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13619 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13620 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13621 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13622 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13623 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13624 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13625 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13626 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13627 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13628 };
13629
13630 // size_hooks
13631
13632 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13633 {
13634 // none yet
13635 }
13636
13637 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13638 // if not, decrease amplifier and try again
13639
13640 int skip = 0;
13641
13642 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13643 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13644 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13645
13646 if (( bitmap_size
13647 + bitmap_size
13648 + bitmap_size
13649 + bitmap_size
13650 + bitmap_size
13651 + bitmap_size
13652 + bitmap_size
13653 + bitmap_size
13654 + size_bfs
13655 + size_combs
13656 + size_digests
13657 + size_esalts
13658 + size_hooks
13659 + size_markov_css
13660 + size_plains
13661 + size_pws
13662 + size_results
13663 + size_root_css
13664 + size_rules
13665 + size_rules_c
13666 + size_salts
13667 + size_scryptV
13668 + size_shown
13669 + size_tm
13670 + size_tmps) > device_param->device_global_mem) skip = 1;
13671
13672 if (skip == 1)
13673 {
13674 kernel_accel_max--;
13675
13676 continue;
13677 }
13678
13679 break;
13680 }
13681
13682 /*
13683 if (kernel_accel_max == 0)
13684 {
13685 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13686
13687 return -1;
13688 }
13689 */
13690
13691 device_param->kernel_accel_min = kernel_accel_min;
13692 device_param->kernel_accel_max = kernel_accel_max;
13693
13694 /*
13695 if (kernel_accel_max < kernel_accel)
13696 {
13697 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13698
13699 device_param->kernel_accel = kernel_accel_max;
13700 }
13701 */
13702
13703 device_param->size_bfs = size_bfs;
13704 device_param->size_combs = size_combs;
13705 device_param->size_rules = size_rules;
13706 device_param->size_rules_c = size_rules_c;
13707 device_param->size_pws = size_pws;
13708 device_param->size_tmps = size_tmps;
13709 device_param->size_hooks = size_hooks;
13710
13711 // do not confuse kernel_accel_max with kernel_accel here
13712
13713 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13714
13715 device_param->kernel_threads = kernel_threads;
13716 device_param->kernel_power_user = kernel_power;
13717
13718 kernel_power_all += kernel_power;
13719
13720 /**
13721 * default building options
13722 */
13723
13724 char build_opts[1024] = { 0 };
13725
13726 // we don't have sm_* on vendors not NV but it doesn't matter
13727
13728 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);
13729
13730 /**
13731 * main kernel
13732 */
13733
13734 {
13735 /**
13736 * kernel source filename
13737 */
13738
13739 char source_file[256] = { 0 };
13740
13741 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13742
13743 struct stat sst;
13744
13745 if (stat (source_file, &sst) == -1)
13746 {
13747 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13748
13749 return -1;
13750 }
13751
13752 /**
13753 * kernel cached filename
13754 */
13755
13756 char cached_file[256] = { 0 };
13757
13758 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13759
13760 int cached = 1;
13761
13762 struct stat cst;
13763
13764 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13765 {
13766 cached = 0;
13767 }
13768
13769 /**
13770 * kernel compile or load
13771 */
13772
13773 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13774
13775 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13776
13777 if (force_jit_compilation == -1)
13778 {
13779 if (cached == 0)
13780 {
13781 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13782
13783 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13784
13785 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13786
13787 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13788
13789 if (rc != 0)
13790 {
13791 device_param->skipped = true;
13792 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13793 continue;
13794 }
13795
13796 size_t binary_size;
13797
13798 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13799
13800 u8 *binary = (u8 *) mymalloc (binary_size);
13801
13802 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13803
13804 writeProgramBin (cached_file, binary, binary_size);
13805
13806 local_free (binary);
13807 }
13808 else
13809 {
13810 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13811
13812 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13813
13814 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13815
13816 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
13817 }
13818 }
13819 else
13820 {
13821 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13822
13823 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13824
13825 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13826
13827 char build_opts_update[1024] = { 0 };
13828
13829 if (force_jit_compilation == 1500)
13830 {
13831 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13832 }
13833 else if (force_jit_compilation == 8900)
13834 {
13835 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);
13836 }
13837 else
13838 {
13839 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
13840 }
13841
13842 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
13843
13844 if (rc != 0)
13845 {
13846 device_param->skipped = true;
13847
13848 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13849 }
13850 }
13851
13852 local_free (kernel_lengths);
13853 local_free (kernel_sources[0]);
13854 local_free (kernel_sources);
13855 }
13856
13857 /**
13858 * word generator kernel
13859 */
13860
13861 if (attack_mode != ATTACK_MODE_STRAIGHT)
13862 {
13863 /**
13864 * kernel mp source filename
13865 */
13866
13867 char source_file[256] = { 0 };
13868
13869 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13870
13871 struct stat sst;
13872
13873 if (stat (source_file, &sst) == -1)
13874 {
13875 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13876
13877 return -1;
13878 }
13879
13880 /**
13881 * kernel mp cached filename
13882 */
13883
13884 char cached_file[256] = { 0 };
13885
13886 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13887
13888 int cached = 1;
13889
13890 struct stat cst;
13891
13892 if (stat (cached_file, &cst) == -1)
13893 {
13894 cached = 0;
13895 }
13896
13897 /**
13898 * kernel compile or load
13899 */
13900
13901 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13902
13903 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13904
13905 if (cached == 0)
13906 {
13907 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13908
13909 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13910
13911 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13912
13913 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
13914
13915 if (rc != 0)
13916 {
13917 device_param->skipped = true;
13918 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13919 continue;
13920 }
13921
13922 size_t binary_size;
13923
13924 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13925
13926 u8 *binary = (u8 *) mymalloc (binary_size);
13927
13928 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13929
13930 writeProgramBin (cached_file, binary, binary_size);
13931
13932 local_free (binary);
13933 }
13934 else
13935 {
13936 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13937
13938 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13939
13940 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13941
13942 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
13943 }
13944
13945 local_free (kernel_lengths);
13946 local_free (kernel_sources[0]);
13947 local_free (kernel_sources);
13948 }
13949
13950 /**
13951 * amplifier kernel
13952 */
13953
13954 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13955 {
13956
13957 }
13958 else
13959 {
13960 /**
13961 * kernel amp source filename
13962 */
13963
13964 char source_file[256] = { 0 };
13965
13966 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13967
13968 struct stat sst;
13969
13970 if (stat (source_file, &sst) == -1)
13971 {
13972 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13973
13974 return -1;
13975 }
13976
13977 /**
13978 * kernel amp cached filename
13979 */
13980
13981 char cached_file[256] = { 0 };
13982
13983 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
13984
13985 int cached = 1;
13986
13987 struct stat cst;
13988
13989 if (stat (cached_file, &cst) == -1)
13990 {
13991 cached = 0;
13992 }
13993
13994 /**
13995 * kernel compile or load
13996 */
13997
13998 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13999
14000 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14001
14002 if (cached == 0)
14003 {
14004 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14005
14006 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14007
14008 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14009
14010 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14011
14012 if (rc != 0)
14013 {
14014 device_param->skipped = true;
14015 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14016 continue;
14017 }
14018
14019 size_t binary_size;
14020
14021 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14022
14023 u8 *binary = (u8 *) mymalloc (binary_size);
14024
14025 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14026
14027 writeProgramBin (cached_file, binary, binary_size);
14028
14029 local_free (binary);
14030 }
14031 else
14032 {
14033 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14034
14035 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14036
14037 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14038
14039 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14040 }
14041
14042 local_free (kernel_lengths);
14043 local_free (kernel_sources[0]);
14044 local_free (kernel_sources);
14045 }
14046
14047 // some algorithm collide too fast, make that impossible
14048
14049 if (benchmark == 1)
14050 {
14051 ((uint *) digests_buf)[0] = -1;
14052 ((uint *) digests_buf)[1] = -1;
14053 ((uint *) digests_buf)[2] = -1;
14054 ((uint *) digests_buf)[3] = -1;
14055 }
14056
14057 /**
14058 * global buffers
14059 */
14060
14061 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14062 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14063 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14064 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14065 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14066 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14067 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14068 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14069 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14070 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14071 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14072 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14073 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14074 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14075 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14076 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14077 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14078 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14079
14080 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);
14081 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);
14082 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);
14083 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);
14084 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);
14085 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);
14086 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);
14087 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);
14088 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14089 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14090 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14091
14092 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14093 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14094 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14095 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14096 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14097 run_kernel_bzero (device_param, device_param->d_result, size_results);
14098
14099 /**
14100 * special buffers
14101 */
14102
14103 if (attack_kern == ATTACK_KERN_STRAIGHT)
14104 {
14105 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14106 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14107
14108 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14109
14110 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14111 }
14112 else if (attack_kern == ATTACK_KERN_COMBI)
14113 {
14114 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14115 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14116 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14117 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14118
14119 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14120 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14121 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14122 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14123 }
14124 else if (attack_kern == ATTACK_KERN_BF)
14125 {
14126 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14127 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14128 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14129 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14130 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14131
14132 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14133 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14134 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14135 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14136 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14137 }
14138
14139 if (size_esalts)
14140 {
14141 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14142
14143 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14144 }
14145
14146 /**
14147 * main host data
14148 */
14149
14150 uint *result = (uint *) mymalloc (size_results);
14151
14152 device_param->result = result;
14153
14154 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14155
14156 device_param->pws_buf = pws_buf;
14157
14158 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14159
14160 device_param->combs_buf = combs_buf;
14161
14162 void *hooks_buf = mymalloc (size_hooks);
14163
14164 device_param->hooks_buf = hooks_buf;
14165
14166 /**
14167 * kernel args
14168 */
14169
14170 device_param->kernel_params_buf32[21] = bitmap_mask;
14171 device_param->kernel_params_buf32[22] = bitmap_shift1;
14172 device_param->kernel_params_buf32[23] = bitmap_shift2;
14173 device_param->kernel_params_buf32[24] = 0; // salt_pos
14174 device_param->kernel_params_buf32[25] = 0; // loop_pos
14175 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14176 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14177 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14178 device_param->kernel_params_buf32[29] = 0; // digests_offset
14179 device_param->kernel_params_buf32[30] = 0; // combs_mode
14180 device_param->kernel_params_buf32[31] = 0; // gid_max
14181
14182 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14183 ? &device_param->d_pws_buf
14184 : &device_param->d_pws_amp_buf;
14185 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14186 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14187 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14188 device_param->kernel_params[ 4] = &device_param->d_tmps;
14189 device_param->kernel_params[ 5] = &device_param->d_hooks;
14190 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14191 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14192 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14193 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14194 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14195 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14196 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14197 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14198 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14199 device_param->kernel_params[15] = &device_param->d_digests_buf;
14200 device_param->kernel_params[16] = &device_param->d_digests_shown;
14201 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14202 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14203 device_param->kernel_params[19] = &device_param->d_result;
14204 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14205 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14206 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14207 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14208 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14209 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14210 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14211 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14212 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14213 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14214 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14215 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14216
14217 device_param->kernel_params_mp_buf64[3] = 0;
14218 device_param->kernel_params_mp_buf32[4] = 0;
14219 device_param->kernel_params_mp_buf32[5] = 0;
14220 device_param->kernel_params_mp_buf32[6] = 0;
14221 device_param->kernel_params_mp_buf32[7] = 0;
14222 device_param->kernel_params_mp_buf32[8] = 0;
14223
14224 device_param->kernel_params_mp[0] = NULL;
14225 device_param->kernel_params_mp[1] = NULL;
14226 device_param->kernel_params_mp[2] = NULL;
14227 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14228 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14229 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14230 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14231 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14232 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14233
14234 device_param->kernel_params_mp_l_buf64[3] = 0;
14235 device_param->kernel_params_mp_l_buf32[4] = 0;
14236 device_param->kernel_params_mp_l_buf32[5] = 0;
14237 device_param->kernel_params_mp_l_buf32[6] = 0;
14238 device_param->kernel_params_mp_l_buf32[7] = 0;
14239 device_param->kernel_params_mp_l_buf32[8] = 0;
14240 device_param->kernel_params_mp_l_buf32[9] = 0;
14241
14242 device_param->kernel_params_mp_l[0] = NULL;
14243 device_param->kernel_params_mp_l[1] = NULL;
14244 device_param->kernel_params_mp_l[2] = NULL;
14245 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14246 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14247 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14248 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14249 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14250 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14251 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14252
14253 device_param->kernel_params_mp_r_buf64[3] = 0;
14254 device_param->kernel_params_mp_r_buf32[4] = 0;
14255 device_param->kernel_params_mp_r_buf32[5] = 0;
14256 device_param->kernel_params_mp_r_buf32[6] = 0;
14257 device_param->kernel_params_mp_r_buf32[7] = 0;
14258 device_param->kernel_params_mp_r_buf32[8] = 0;
14259
14260 device_param->kernel_params_mp_r[0] = NULL;
14261 device_param->kernel_params_mp_r[1] = NULL;
14262 device_param->kernel_params_mp_r[2] = NULL;
14263 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14264 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14265 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14266 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14267 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14268 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14269
14270 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14271 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14272
14273 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14274 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14275 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14276 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14277 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14278 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14279 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14280
14281 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14282
14283 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14284 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14285
14286 /**
14287 * kernel name
14288 */
14289
14290 char kernel_name[64] = { 0 };
14291
14292 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14293 {
14294 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14295 {
14296 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14297
14298 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14299
14300 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14301
14302 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14303
14304 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14305
14306 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14307 }
14308 else
14309 {
14310 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14311
14312 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14313
14314 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14315
14316 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14317
14318 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14319
14320 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14321 }
14322
14323 if (data.attack_mode == ATTACK_MODE_BF)
14324 {
14325 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14326 {
14327 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14328
14329 device_param->kernel_tb = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14330
14331 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14332
14333 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14334 }
14335 }
14336 }
14337 else
14338 {
14339 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14340
14341 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14342
14343 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14344
14345 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14346
14347 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14348
14349 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14350
14351 if (opts_type & OPTS_TYPE_HOOK12)
14352 {
14353 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14354
14355 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14356 }
14357
14358 if (opts_type & OPTS_TYPE_HOOK23)
14359 {
14360 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14361
14362 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14363 }
14364 }
14365
14366 for (uint i = 0; i <= 20; i++)
14367 {
14368 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14369 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14370 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14371
14372 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14373 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14374 }
14375
14376 for (uint i = 21; i <= 31; i++)
14377 {
14378 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14379 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14380 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14381
14382 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14383 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14384 }
14385
14386 if (attack_mode == ATTACK_MODE_BF)
14387 {
14388 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14389 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14390
14391 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14392 {
14393 hc_clSetKernelArg (data.ocl, device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14394
14395 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14396 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14397 }
14398 }
14399 else if (attack_mode == ATTACK_MODE_HYBRID1)
14400 {
14401 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14402 }
14403 else if (attack_mode == ATTACK_MODE_HYBRID2)
14404 {
14405 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14406 }
14407
14408 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14409 {
14410 // nothing to do
14411 }
14412 else
14413 {
14414 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14415 }
14416
14417 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14418 {
14419 // nothing to do
14420 }
14421 else
14422 {
14423 for (uint i = 0; i < 5; i++)
14424 {
14425 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14426 }
14427
14428 for (uint i = 5; i < 7; i++)
14429 {
14430 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14431 }
14432 }
14433
14434 /**
14435 * Store initial fanspeed if gpu_temp_retain is enabled
14436 */
14437
14438 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14439 int gpu_temp_retain_set = 0;
14440
14441 if (gpu_temp_disable == 0)
14442 {
14443 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14444 {
14445 hc_thread_mutex_lock (mux_adl);
14446
14447 if (data.hm_device[device_id].fan_supported == 1)
14448 {
14449 if (gpu_temp_retain_chgd == 0)
14450 {
14451 uint cur_temp = 0;
14452 uint default_temp = 0;
14453
14454 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);
14455
14456 if (ADL_rc == ADL_OK)
14457 {
14458 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14459
14460 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14461
14462 // special case with multi gpu setups: always use minimum retain
14463
14464 if (gpu_temp_retain_set == 0)
14465 {
14466 gpu_temp_retain = gpu_temp_retain_target;
14467 gpu_temp_retain_set = 1;
14468 }
14469 else
14470 {
14471 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14472 }
14473
14474 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14475 }
14476 }
14477
14478 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14479
14480 temp_retain_fanspeed_value[device_id] = fan_speed;
14481
14482 if (fan_speed == -1)
14483 {
14484 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14485
14486 temp_retain_fanspeed_value[device_id] = 0;
14487 }
14488 }
14489
14490 hc_thread_mutex_unlock (mux_adl);
14491 }
14492 }
14493
14494 /**
14495 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14496 */
14497
14498 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14499 {
14500 hc_thread_mutex_lock (mux_adl);
14501
14502 if (data.hm_device[device_id].od_version == 6)
14503 {
14504 int ADL_rc;
14505
14506 // check powertune capabilities first, if not available then skip device
14507
14508 int powertune_supported = 0;
14509
14510 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14511 {
14512 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14513
14514 return (-1);
14515 }
14516
14517 if (powertune_supported != 0)
14518 {
14519 // powercontrol settings
14520
14521 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14522
14523 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14524 {
14525 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14526 }
14527
14528 if (ADL_rc != ADL_OK)
14529 {
14530 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14531
14532 return (-1);
14533 }
14534
14535 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14536 {
14537 log_error ("ERROR: Failed to set new ADL PowerControl values");
14538
14539 return (-1);
14540 }
14541
14542 // clocks
14543
14544 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14545
14546 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14547
14548 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)
14549 {
14550 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14551
14552 return (-1);
14553 }
14554
14555 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14556
14557 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14558
14559 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14560 {
14561 log_error ("ERROR: Failed to get ADL device capabilities");
14562
14563 return (-1);
14564 }
14565
14566 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14567 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14568
14569 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14570 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14571
14572 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14573 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14574
14575 // warning if profile has too low max values
14576
14577 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14578 {
14579 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14580 }
14581
14582 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14583 {
14584 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14585 }
14586
14587 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14588
14589 performance_state->iNumberOfPerformanceLevels = 2;
14590
14591 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14592 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14593 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14594 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14595
14596 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)
14597 {
14598 log_info ("ERROR: Failed to set ADL performance state");
14599
14600 return (-1);
14601 }
14602
14603 local_free (performance_state);
14604 }
14605 }
14606
14607 hc_thread_mutex_unlock (mux_adl);
14608 }
14609 #endif // HAVE_HWMON && HAVE_ADL
14610 }
14611
14612 data.kernel_power_all = kernel_power_all;
14613
14614 if (data.quiet == 0) log_info ("");
14615
14616 /**
14617 * Inform user which algorithm is checked and at which workload setting
14618 */
14619
14620 if (benchmark == 1)
14621 {
14622 quiet = 0;
14623
14624 data.quiet = quiet;
14625
14626 char *hash_type = strhashtype (data.hash_mode); // not a bug
14627
14628 log_info ("Hashtype: %s", hash_type);
14629 log_info ("");
14630 }
14631
14632 /**
14633 * keep track of the progress
14634 */
14635
14636 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14637 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14638 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14639
14640 /**
14641 * open filehandles
14642 */
14643
14644 #if _WIN
14645 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14646 {
14647 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14648
14649 return (-1);
14650 }
14651
14652 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14653 {
14654 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14655
14656 return (-1);
14657 }
14658
14659 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14660 {
14661 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14662
14663 return (-1);
14664 }
14665 #endif
14666
14667 /**
14668 * dictionary pad
14669 */
14670
14671 segment_size *= (1024 * 1024);
14672
14673 data.segment_size = segment_size;
14674
14675 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14676
14677 wl_data->buf = (char *) mymalloc (segment_size);
14678 wl_data->avail = segment_size;
14679 wl_data->incr = segment_size;
14680 wl_data->cnt = 0;
14681 wl_data->pos = 0;
14682
14683 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14684
14685 data.wordlist_mode = wordlist_mode;
14686
14687 cs_t *css_buf = NULL;
14688 uint css_cnt = 0;
14689 uint dictcnt = 0;
14690 uint maskcnt = 1;
14691 char **masks = NULL;
14692 char **dictfiles = NULL;
14693
14694 uint mask_from_file = 0;
14695
14696 if (attack_mode == ATTACK_MODE_STRAIGHT)
14697 {
14698 if (wordlist_mode == WL_MODE_FILE)
14699 {
14700 int wls_left = myargc - (optind + 1);
14701
14702 for (int i = 0; i < wls_left; i++)
14703 {
14704 char *l0_filename = myargv[optind + 1 + i];
14705
14706 struct stat l0_stat;
14707
14708 if (stat (l0_filename, &l0_stat) == -1)
14709 {
14710 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14711
14712 return (-1);
14713 }
14714
14715 uint is_dir = S_ISDIR (l0_stat.st_mode);
14716
14717 if (is_dir == 0)
14718 {
14719 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14720
14721 dictcnt++;
14722
14723 dictfiles[dictcnt - 1] = l0_filename;
14724 }
14725 else
14726 {
14727 // do not allow --keyspace w/ a directory
14728
14729 if (keyspace == 1)
14730 {
14731 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14732
14733 return (-1);
14734 }
14735
14736 char **dictionary_files = NULL;
14737
14738 dictionary_files = scan_directory (l0_filename);
14739
14740 if (dictionary_files != NULL)
14741 {
14742 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14743
14744 for (int d = 0; dictionary_files[d] != NULL; d++)
14745 {
14746 char *l1_filename = dictionary_files[d];
14747
14748 struct stat l1_stat;
14749
14750 if (stat (l1_filename, &l1_stat) == -1)
14751 {
14752 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14753
14754 return (-1);
14755 }
14756
14757 if (S_ISREG (l1_stat.st_mode))
14758 {
14759 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14760
14761 dictcnt++;
14762
14763 dictfiles[dictcnt - 1] = strdup (l1_filename);
14764 }
14765 }
14766 }
14767
14768 local_free (dictionary_files);
14769 }
14770 }
14771
14772 if (dictcnt < 1)
14773 {
14774 log_error ("ERROR: No usable dictionary file found.");
14775
14776 return (-1);
14777 }
14778 }
14779 else if (wordlist_mode == WL_MODE_STDIN)
14780 {
14781 dictcnt = 1;
14782 }
14783 }
14784 else if (attack_mode == ATTACK_MODE_COMBI)
14785 {
14786 // display
14787
14788 char *dictfile1 = myargv[optind + 1 + 0];
14789 char *dictfile2 = myargv[optind + 1 + 1];
14790
14791 // find the bigger dictionary and use as base
14792
14793 FILE *fp1 = NULL;
14794 FILE *fp2 = NULL;
14795
14796 struct stat tmp_stat;
14797
14798 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14799 {
14800 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14801
14802 return (-1);
14803 }
14804
14805 if (stat (dictfile1, &tmp_stat) == -1)
14806 {
14807 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14808
14809 fclose (fp1);
14810
14811 return (-1);
14812 }
14813
14814 if (S_ISDIR (tmp_stat.st_mode))
14815 {
14816 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14817
14818 fclose (fp1);
14819
14820 return (-1);
14821 }
14822
14823 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14824 {
14825 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14826
14827 fclose (fp1);
14828
14829 return (-1);
14830 }
14831
14832 if (stat (dictfile2, &tmp_stat) == -1)
14833 {
14834 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14835
14836 fclose (fp1);
14837 fclose (fp2);
14838
14839 return (-1);
14840 }
14841
14842 if (S_ISDIR (tmp_stat.st_mode))
14843 {
14844 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14845
14846 fclose (fp1);
14847 fclose (fp2);
14848
14849 return (-1);
14850 }
14851
14852 data.combs_cnt = 1;
14853
14854 data.quiet = 1;
14855
14856 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14857
14858 data.quiet = quiet;
14859
14860 if (words1_cnt == 0)
14861 {
14862 log_error ("ERROR: %s: empty file", dictfile1);
14863
14864 fclose (fp1);
14865 fclose (fp2);
14866
14867 return (-1);
14868 }
14869
14870 data.combs_cnt = 1;
14871
14872 data.quiet = 1;
14873
14874 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14875
14876 data.quiet = quiet;
14877
14878 if (words2_cnt == 0)
14879 {
14880 log_error ("ERROR: %s: empty file", dictfile2);
14881
14882 fclose (fp1);
14883 fclose (fp2);
14884
14885 return (-1);
14886 }
14887
14888 fclose (fp1);
14889 fclose (fp2);
14890
14891 data.dictfile = dictfile1;
14892 data.dictfile2 = dictfile2;
14893
14894 if (words1_cnt >= words2_cnt)
14895 {
14896 data.combs_cnt = words2_cnt;
14897 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14898
14899 dictfiles = &data.dictfile;
14900
14901 dictcnt = 1;
14902 }
14903 else
14904 {
14905 data.combs_cnt = words1_cnt;
14906 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14907
14908 dictfiles = &data.dictfile2;
14909
14910 dictcnt = 1;
14911
14912 // we also have to switch wordlist related rules!
14913
14914 char *tmpc = data.rule_buf_l;
14915
14916 data.rule_buf_l = data.rule_buf_r;
14917 data.rule_buf_r = tmpc;
14918
14919 int tmpi = data.rule_len_l;
14920
14921 data.rule_len_l = data.rule_len_r;
14922 data.rule_len_r = tmpi;
14923 }
14924 }
14925 else if (attack_mode == ATTACK_MODE_BF)
14926 {
14927 char *mask = NULL;
14928
14929 maskcnt = 0;
14930
14931 if (benchmark == 0)
14932 {
14933 mask = myargv[optind + 1];
14934
14935 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14936
14937 if ((optind + 2) <= myargc)
14938 {
14939 struct stat file_stat;
14940
14941 if (stat (mask, &file_stat) == -1)
14942 {
14943 maskcnt = 1;
14944
14945 masks[maskcnt - 1] = mystrdup (mask);
14946 }
14947 else
14948 {
14949 int wls_left = myargc - (optind + 1);
14950
14951 uint masks_avail = INCR_MASKS;
14952
14953 for (int i = 0; i < wls_left; i++)
14954 {
14955 if (i != 0)
14956 {
14957 mask = myargv[optind + 1 + i];
14958
14959 if (stat (mask, &file_stat) == -1)
14960 {
14961 log_error ("ERROR: %s: %s", mask, strerror (errno));
14962
14963 return (-1);
14964 }
14965 }
14966
14967 uint is_file = S_ISREG (file_stat.st_mode);
14968
14969 if (is_file == 1)
14970 {
14971 FILE *mask_fp;
14972
14973 if ((mask_fp = fopen (mask, "r")) == NULL)
14974 {
14975 log_error ("ERROR: %s: %s", mask, strerror (errno));
14976
14977 return (-1);
14978 }
14979
14980 char line_buf[BUFSIZ] = { 0 };
14981
14982 while (!feof (mask_fp))
14983 {
14984 memset (line_buf, 0, BUFSIZ);
14985
14986 int line_len = fgetl (mask_fp, line_buf);
14987
14988 if (line_len == 0) continue;
14989
14990 if (line_buf[0] == '#') continue;
14991
14992 if (masks_avail == maskcnt)
14993 {
14994 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14995
14996 masks_avail += INCR_MASKS;
14997 }
14998
14999 masks[maskcnt] = mystrdup (line_buf);
15000
15001 maskcnt++;
15002 }
15003
15004 fclose (mask_fp);
15005 }
15006 else
15007 {
15008 log_error ("ERROR: %s: unsupported file-type", mask);
15009
15010 return (-1);
15011 }
15012 }
15013
15014 mask_from_file = 1;
15015 }
15016 }
15017 else
15018 {
15019 custom_charset_1 = (char *) "?l?d?u";
15020 custom_charset_2 = (char *) "?l?d";
15021 custom_charset_3 = (char *) "?l?d*!$@_";
15022
15023 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15024 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15025 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15026
15027 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15028
15029 wordlist_mode = WL_MODE_MASK;
15030
15031 data.wordlist_mode = wordlist_mode;
15032
15033 increment = 1;
15034
15035 maskcnt = 1;
15036 }
15037 }
15038 else
15039 {
15040 /**
15041 * generate full masks and charsets
15042 */
15043
15044 masks = (char **) mymalloc (sizeof (char *));
15045
15046 switch (hash_mode)
15047 {
15048 case 1731: pw_min = 5;
15049 pw_max = 5;
15050 mask = mystrdup ("?b?b?b?b?b");
15051 break;
15052 case 12500: pw_min = 5;
15053 pw_max = 5;
15054 mask = mystrdup ("?b?b?b?b?b");
15055 break;
15056 default: pw_min = 7;
15057 pw_max = 7;
15058 mask = mystrdup ("?b?b?b?b?b?b?b");
15059 break;
15060 }
15061
15062 maskcnt = 1;
15063
15064 masks[maskcnt - 1] = mystrdup (mask);
15065
15066 wordlist_mode = WL_MODE_MASK;
15067
15068 data.wordlist_mode = wordlist_mode;
15069
15070 increment = 1;
15071 }
15072
15073 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15074
15075 if (increment)
15076 {
15077 if (increment_min > pw_min) pw_min = increment_min;
15078
15079 if (increment_max < pw_max) pw_max = increment_max;
15080 }
15081 }
15082 else if (attack_mode == ATTACK_MODE_HYBRID1)
15083 {
15084 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15085
15086 // display
15087
15088 char *mask = myargv[myargc - 1];
15089
15090 maskcnt = 0;
15091
15092 masks = (char **) mymalloc (1 * sizeof (char *));
15093
15094 // mod
15095
15096 struct stat file_stat;
15097
15098 if (stat (mask, &file_stat) == -1)
15099 {
15100 maskcnt = 1;
15101
15102 masks[maskcnt - 1] = mystrdup (mask);
15103 }
15104 else
15105 {
15106 uint is_file = S_ISREG (file_stat.st_mode);
15107
15108 if (is_file == 1)
15109 {
15110 FILE *mask_fp;
15111
15112 if ((mask_fp = fopen (mask, "r")) == NULL)
15113 {
15114 log_error ("ERROR: %s: %s", mask, strerror (errno));
15115
15116 return (-1);
15117 }
15118
15119 char line_buf[BUFSIZ] = { 0 };
15120
15121 uint masks_avail = 1;
15122
15123 while (!feof (mask_fp))
15124 {
15125 memset (line_buf, 0, BUFSIZ);
15126
15127 int line_len = fgetl (mask_fp, line_buf);
15128
15129 if (line_len == 0) continue;
15130
15131 if (line_buf[0] == '#') continue;
15132
15133 if (masks_avail == maskcnt)
15134 {
15135 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15136
15137 masks_avail += INCR_MASKS;
15138 }
15139
15140 masks[maskcnt] = mystrdup (line_buf);
15141
15142 maskcnt++;
15143 }
15144
15145 fclose (mask_fp);
15146
15147 mask_from_file = 1;
15148 }
15149 else
15150 {
15151 maskcnt = 1;
15152
15153 masks[maskcnt - 1] = mystrdup (mask);
15154 }
15155 }
15156
15157 // base
15158
15159 int wls_left = myargc - (optind + 2);
15160
15161 for (int i = 0; i < wls_left; i++)
15162 {
15163 char *filename = myargv[optind + 1 + i];
15164
15165 struct stat file_stat;
15166
15167 if (stat (filename, &file_stat) == -1)
15168 {
15169 log_error ("ERROR: %s: %s", filename, strerror (errno));
15170
15171 return (-1);
15172 }
15173
15174 uint is_dir = S_ISDIR (file_stat.st_mode);
15175
15176 if (is_dir == 0)
15177 {
15178 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15179
15180 dictcnt++;
15181
15182 dictfiles[dictcnt - 1] = filename;
15183 }
15184 else
15185 {
15186 // do not allow --keyspace w/ a directory
15187
15188 if (keyspace == 1)
15189 {
15190 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15191
15192 return (-1);
15193 }
15194
15195 char **dictionary_files = NULL;
15196
15197 dictionary_files = scan_directory (filename);
15198
15199 if (dictionary_files != NULL)
15200 {
15201 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15202
15203 for (int d = 0; dictionary_files[d] != NULL; d++)
15204 {
15205 char *l1_filename = dictionary_files[d];
15206
15207 struct stat l1_stat;
15208
15209 if (stat (l1_filename, &l1_stat) == -1)
15210 {
15211 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15212
15213 return (-1);
15214 }
15215
15216 if (S_ISREG (l1_stat.st_mode))
15217 {
15218 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15219
15220 dictcnt++;
15221
15222 dictfiles[dictcnt - 1] = strdup (l1_filename);
15223 }
15224 }
15225 }
15226
15227 local_free (dictionary_files);
15228 }
15229 }
15230
15231 if (dictcnt < 1)
15232 {
15233 log_error ("ERROR: No usable dictionary file found.");
15234
15235 return (-1);
15236 }
15237
15238 if (increment)
15239 {
15240 maskcnt = 0;
15241
15242 uint mask_min = increment_min; // we can't reject smaller masks here
15243 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15244
15245 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15246 {
15247 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15248
15249 if (cur_mask == NULL) break;
15250
15251 masks[maskcnt] = cur_mask;
15252
15253 maskcnt++;
15254
15255 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15256 }
15257 }
15258 }
15259 else if (attack_mode == ATTACK_MODE_HYBRID2)
15260 {
15261 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15262
15263 // display
15264
15265 char *mask = myargv[optind + 1 + 0];
15266
15267 maskcnt = 0;
15268
15269 masks = (char **) mymalloc (1 * sizeof (char *));
15270
15271 // mod
15272
15273 struct stat file_stat;
15274
15275 if (stat (mask, &file_stat) == -1)
15276 {
15277 maskcnt = 1;
15278
15279 masks[maskcnt - 1] = mystrdup (mask);
15280 }
15281 else
15282 {
15283 uint is_file = S_ISREG (file_stat.st_mode);
15284
15285 if (is_file == 1)
15286 {
15287 FILE *mask_fp;
15288
15289 if ((mask_fp = fopen (mask, "r")) == NULL)
15290 {
15291 log_error ("ERROR: %s: %s", mask, strerror (errno));
15292
15293 return (-1);
15294 }
15295
15296 char line_buf[BUFSIZ] = { 0 };
15297
15298 uint masks_avail = 1;
15299
15300 while (!feof (mask_fp))
15301 {
15302 memset (line_buf, 0, BUFSIZ);
15303
15304 int line_len = fgetl (mask_fp, line_buf);
15305
15306 if (line_len == 0) continue;
15307
15308 if (line_buf[0] == '#') continue;
15309
15310 if (masks_avail == maskcnt)
15311 {
15312 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15313
15314 masks_avail += INCR_MASKS;
15315 }
15316
15317 masks[maskcnt] = mystrdup (line_buf);
15318
15319 maskcnt++;
15320 }
15321
15322 fclose (mask_fp);
15323
15324 mask_from_file = 1;
15325 }
15326 else
15327 {
15328 maskcnt = 1;
15329
15330 masks[maskcnt - 1] = mystrdup (mask);
15331 }
15332 }
15333
15334 // base
15335
15336 int wls_left = myargc - (optind + 2);
15337
15338 for (int i = 0; i < wls_left; i++)
15339 {
15340 char *filename = myargv[optind + 2 + i];
15341
15342 struct stat file_stat;
15343
15344 if (stat (filename, &file_stat) == -1)
15345 {
15346 log_error ("ERROR: %s: %s", filename, strerror (errno));
15347
15348 return (-1);
15349 }
15350
15351 uint is_dir = S_ISDIR (file_stat.st_mode);
15352
15353 if (is_dir == 0)
15354 {
15355 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15356
15357 dictcnt++;
15358
15359 dictfiles[dictcnt - 1] = filename;
15360 }
15361 else
15362 {
15363 // do not allow --keyspace w/ a directory
15364
15365 if (keyspace == 1)
15366 {
15367 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15368
15369 return (-1);
15370 }
15371
15372 char **dictionary_files = NULL;
15373
15374 dictionary_files = scan_directory (filename);
15375
15376 if (dictionary_files != NULL)
15377 {
15378 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15379
15380 for (int d = 0; dictionary_files[d] != NULL; d++)
15381 {
15382 char *l1_filename = dictionary_files[d];
15383
15384 struct stat l1_stat;
15385
15386 if (stat (l1_filename, &l1_stat) == -1)
15387 {
15388 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15389
15390 return (-1);
15391 }
15392
15393 if (S_ISREG (l1_stat.st_mode))
15394 {
15395 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15396
15397 dictcnt++;
15398
15399 dictfiles[dictcnt - 1] = strdup (l1_filename);
15400 }
15401 }
15402 }
15403
15404 local_free (dictionary_files);
15405 }
15406 }
15407
15408 if (dictcnt < 1)
15409 {
15410 log_error ("ERROR: No usable dictionary file found.");
15411
15412 return (-1);
15413 }
15414
15415 if (increment)
15416 {
15417 maskcnt = 0;
15418
15419 uint mask_min = increment_min; // we can't reject smaller masks here
15420 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15421
15422 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15423 {
15424 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15425
15426 if (cur_mask == NULL) break;
15427
15428 masks[maskcnt] = cur_mask;
15429
15430 maskcnt++;
15431
15432 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15433 }
15434 }
15435 }
15436
15437 data.pw_min = pw_min;
15438 data.pw_max = pw_max;
15439
15440 /**
15441 * weak hash check
15442 */
15443
15444 if (weak_hash_threshold >= salts_cnt)
15445 {
15446 hc_device_param_t *device_param = NULL;
15447
15448 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15449 {
15450 device_param = &data.devices_param[device_id];
15451
15452 if (device_param->skipped) continue;
15453
15454 break;
15455 }
15456
15457 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15458
15459 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15460 {
15461 weak_hash_check (device_param, salt_pos);
15462 }
15463 }
15464
15465 // Display hack, guarantee that there is at least one \r before real start
15466
15467 if (data.quiet == 0) log_info_nn ("");
15468
15469 /**
15470 * status and monitor threads
15471 */
15472
15473 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15474
15475 hc_thread_t i_thread = 0;
15476
15477 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15478 {
15479 hc_thread_create (i_thread, thread_keypress, &benchmark);
15480 }
15481
15482 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15483
15484 uint ni_threads_cnt = 0;
15485
15486 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15487
15488 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15489
15490 ni_threads_cnt++;
15491
15492 /**
15493 * Outfile remove
15494 */
15495
15496 if (keyspace == 0)
15497 {
15498 if (outfile_check_timer != 0)
15499 {
15500 if (data.outfile_check_directory != NULL)
15501 {
15502 if ((hash_mode != 5200) &&
15503 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15504 (hash_mode != 9000))
15505 {
15506 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15507
15508 ni_threads_cnt++;
15509 }
15510 else
15511 {
15512 outfile_check_timer = 0;
15513 }
15514 }
15515 else
15516 {
15517 outfile_check_timer = 0;
15518 }
15519 }
15520 }
15521
15522 /**
15523 * Inform the user if we got some hashes remove because of the pot file remove feature
15524 */
15525
15526 if (data.quiet == 0)
15527 {
15528 if (potfile_remove_cracks > 0)
15529 {
15530 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15531 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15532 }
15533 }
15534
15535 data.outfile_check_timer = outfile_check_timer;
15536
15537 /**
15538 * main loop
15539 */
15540
15541 char **induction_dictionaries = NULL;
15542
15543 int induction_dictionaries_cnt = 0;
15544
15545 hcstat_table_t *root_table_buf = NULL;
15546 hcstat_table_t *markov_table_buf = NULL;
15547
15548 uint initial_restore_done = 0;
15549
15550 data.maskcnt = maskcnt;
15551
15552 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15553 {
15554 if (data.devices_status == STATUS_CRACKED) break;
15555
15556 data.devices_status = STATUS_INIT;
15557
15558 if (maskpos > rd->maskpos)
15559 {
15560 rd->dictpos = 0;
15561 }
15562
15563 rd->maskpos = maskpos;
15564 data.maskpos = maskpos;
15565
15566 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15567 {
15568 char *mask = masks[maskpos];
15569
15570 if (mask_from_file == 1)
15571 {
15572 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15573
15574 char *str_ptr;
15575 uint str_pos;
15576
15577 uint mask_offset = 0;
15578
15579 uint separator_cnt;
15580
15581 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15582 {
15583 str_ptr = strstr (mask + mask_offset, ",");
15584
15585 if (str_ptr == NULL) break;
15586
15587 str_pos = str_ptr - mask;
15588
15589 // escaped separator, i.e. "\,"
15590
15591 if (str_pos > 0)
15592 {
15593 if (mask[str_pos - 1] == '\\')
15594 {
15595 separator_cnt --;
15596
15597 mask_offset = str_pos + 1;
15598
15599 continue;
15600 }
15601 }
15602
15603 // reset the offset
15604
15605 mask_offset = 0;
15606
15607 mask[str_pos] = '\0';
15608
15609 switch (separator_cnt)
15610 {
15611 case 0:
15612 mp_reset_usr (mp_usr, 0);
15613
15614 custom_charset_1 = mask;
15615 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15616 break;
15617
15618 case 1:
15619 mp_reset_usr (mp_usr, 1);
15620
15621 custom_charset_2 = mask;
15622 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15623 break;
15624
15625 case 2:
15626 mp_reset_usr (mp_usr, 2);
15627
15628 custom_charset_3 = mask;
15629 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15630 break;
15631
15632 case 3:
15633 mp_reset_usr (mp_usr, 3);
15634
15635 custom_charset_4 = mask;
15636 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15637 break;
15638 }
15639
15640 mask = mask + str_pos + 1;
15641 }
15642 }
15643
15644 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15645 {
15646 if (maskpos > 0)
15647 {
15648 local_free (css_buf);
15649 local_free (data.root_css_buf);
15650 local_free (data.markov_css_buf);
15651
15652 local_free (masks[maskpos - 1]);
15653 }
15654
15655 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15656
15657 data.mask = mask;
15658 data.css_cnt = css_cnt;
15659 data.css_buf = css_buf;
15660
15661 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15662
15663 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15664
15665 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15666 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15667
15668 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15669
15670 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15671
15672 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15673 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15674
15675 data.root_css_buf = root_css_buf;
15676 data.markov_css_buf = markov_css_buf;
15677
15678 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15679
15680 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15681
15682 local_free (root_table_buf);
15683 local_free (markov_table_buf);
15684
15685 // args
15686
15687 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15688 {
15689 hc_device_param_t *device_param = &data.devices_param[device_id];
15690
15691 if (device_param->skipped) continue;
15692
15693 device_param->kernel_params_mp[0] = &device_param->d_combs;
15694 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15695 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15696
15697 device_param->kernel_params_mp_buf64[3] = 0;
15698 device_param->kernel_params_mp_buf32[4] = css_cnt;
15699 device_param->kernel_params_mp_buf32[5] = 0;
15700 device_param->kernel_params_mp_buf32[6] = 0;
15701 device_param->kernel_params_mp_buf32[7] = 0;
15702
15703 if (attack_mode == ATTACK_MODE_HYBRID1)
15704 {
15705 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15706 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15707 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15708 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15709 }
15710 else if (attack_mode == ATTACK_MODE_HYBRID2)
15711 {
15712 device_param->kernel_params_mp_buf32[5] = 0;
15713 device_param->kernel_params_mp_buf32[6] = 0;
15714 device_param->kernel_params_mp_buf32[7] = 0;
15715 }
15716
15717 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]);
15718 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]);
15719 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]);
15720
15721 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);
15722 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);
15723 }
15724 }
15725 else if (attack_mode == ATTACK_MODE_BF)
15726 {
15727 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15728
15729 if (increment)
15730 {
15731 for (uint i = 0; i < dictcnt; i++)
15732 {
15733 local_free (dictfiles[i]);
15734 }
15735
15736 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15737 {
15738 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15739
15740 if (l1_filename == NULL) break;
15741
15742 dictcnt++;
15743
15744 dictfiles[dictcnt - 1] = l1_filename;
15745 }
15746 }
15747 else
15748 {
15749 dictcnt++;
15750
15751 dictfiles[dictcnt - 1] = mask;
15752 }
15753
15754 if (dictcnt == 0)
15755 {
15756 log_error ("ERROR: Mask is too small");
15757
15758 return (-1);
15759 }
15760 }
15761 }
15762
15763 free (induction_dictionaries);
15764
15765 // induction_dictionaries_cnt = 0; // implied
15766
15767 if (attack_mode != ATTACK_MODE_BF)
15768 {
15769 if (keyspace == 0)
15770 {
15771 induction_dictionaries = scan_directory (induction_directory);
15772
15773 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15774 }
15775 }
15776
15777 if (induction_dictionaries_cnt)
15778 {
15779 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15780 }
15781
15782 /**
15783 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15784 */
15785 if (keyspace == 1)
15786 {
15787 if ((maskcnt > 1) || (dictcnt > 1))
15788 {
15789 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15790
15791 return (-1);
15792 }
15793 }
15794
15795 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15796 {
15797 char *subid = logfile_generate_subid ();
15798
15799 data.subid = subid;
15800
15801 logfile_sub_msg ("START");
15802
15803 data.devices_status = STATUS_INIT;
15804
15805 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15806 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15807 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15808
15809 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15810
15811 data.cpt_pos = 0;
15812
15813 data.cpt_start = time (NULL);
15814
15815 data.cpt_total = 0;
15816
15817 if (data.restore == 0)
15818 {
15819 rd->words_cur = skip;
15820
15821 skip = 0;
15822
15823 data.skip = 0;
15824 }
15825
15826 data.ms_paused = 0;
15827
15828 data.words_cur = rd->words_cur;
15829
15830 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15831 {
15832 hc_device_param_t *device_param = &data.devices_param[device_id];
15833
15834 if (device_param->skipped) continue;
15835
15836 device_param->speed_pos = 0;
15837
15838 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15839 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15840 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15841
15842 device_param->exec_pos = 0;
15843
15844 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
15845
15846 device_param->kernel_power = device_param->kernel_power_user;
15847
15848 device_param->outerloop_pos = 0;
15849 device_param->outerloop_left = 0;
15850 device_param->innerloop_pos = 0;
15851 device_param->innerloop_left = 0;
15852
15853 // some more resets:
15854
15855 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
15856
15857 device_param->pws_cnt = 0;
15858
15859 device_param->words_off = 0;
15860 device_param->words_done = 0;
15861 }
15862
15863 data.kernel_power_div = 0;
15864
15865 // figure out some workload
15866
15867 if (attack_mode == ATTACK_MODE_STRAIGHT)
15868 {
15869 if (data.wordlist_mode == WL_MODE_FILE)
15870 {
15871 char *dictfile = NULL;
15872
15873 if (induction_dictionaries_cnt)
15874 {
15875 dictfile = induction_dictionaries[0];
15876 }
15877 else
15878 {
15879 dictfile = dictfiles[dictpos];
15880 }
15881
15882 data.dictfile = dictfile;
15883
15884 logfile_sub_string (dictfile);
15885
15886 for (uint i = 0; i < rp_files_cnt; i++)
15887 {
15888 logfile_sub_var_string ("rulefile", rp_files[i]);
15889 }
15890
15891 FILE *fd2 = fopen (dictfile, "rb");
15892
15893 if (fd2 == NULL)
15894 {
15895 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15896
15897 return (-1);
15898 }
15899
15900 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15901
15902 fclose (fd2);
15903
15904 if (data.words_cnt == 0)
15905 {
15906 if (data.devices_status == STATUS_CRACKED) break;
15907 if (data.devices_status == STATUS_ABORTED) break;
15908
15909 dictpos++;
15910
15911 continue;
15912 }
15913 }
15914 }
15915 else if (attack_mode == ATTACK_MODE_COMBI)
15916 {
15917 char *dictfile = data.dictfile;
15918 char *dictfile2 = data.dictfile2;
15919
15920 logfile_sub_string (dictfile);
15921 logfile_sub_string (dictfile2);
15922
15923 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15924 {
15925 FILE *fd2 = fopen (dictfile, "rb");
15926
15927 if (fd2 == NULL)
15928 {
15929 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15930
15931 return (-1);
15932 }
15933
15934 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15935
15936 fclose (fd2);
15937 }
15938 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15939 {
15940 FILE *fd2 = fopen (dictfile2, "rb");
15941
15942 if (fd2 == NULL)
15943 {
15944 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15945
15946 return (-1);
15947 }
15948
15949 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15950
15951 fclose (fd2);
15952 }
15953
15954 if (data.words_cnt == 0)
15955 {
15956 if (data.devices_status == STATUS_CRACKED) break;
15957 if (data.devices_status == STATUS_ABORTED) break;
15958
15959 dictpos++;
15960
15961 continue;
15962 }
15963 }
15964 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15965 {
15966 char *dictfile = NULL;
15967
15968 if (induction_dictionaries_cnt)
15969 {
15970 dictfile = induction_dictionaries[0];
15971 }
15972 else
15973 {
15974 dictfile = dictfiles[dictpos];
15975 }
15976
15977 data.dictfile = dictfile;
15978
15979 char *mask = data.mask;
15980
15981 logfile_sub_string (dictfile);
15982 logfile_sub_string (mask);
15983
15984 FILE *fd2 = fopen (dictfile, "rb");
15985
15986 if (fd2 == NULL)
15987 {
15988 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15989
15990 return (-1);
15991 }
15992
15993 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15994
15995 fclose (fd2);
15996
15997 if (data.words_cnt == 0)
15998 {
15999 if (data.devices_status == STATUS_CRACKED) break;
16000 if (data.devices_status == STATUS_ABORTED) break;
16001
16002 dictpos++;
16003
16004 continue;
16005 }
16006 }
16007 else if (attack_mode == ATTACK_MODE_BF)
16008 {
16009 local_free (css_buf);
16010 local_free (data.root_css_buf);
16011 local_free (data.markov_css_buf);
16012
16013 char *mask = dictfiles[dictpos];
16014
16015 logfile_sub_string (mask);
16016
16017 // base
16018
16019 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16020
16021 if (opts_type & OPTS_TYPE_PT_UNICODE)
16022 {
16023 uint css_cnt_unicode = css_cnt * 2;
16024
16025 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16026
16027 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16028 {
16029 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16030
16031 css_buf_unicode[j + 1].cs_buf[0] = 0;
16032 css_buf_unicode[j + 1].cs_len = 1;
16033 }
16034
16035 free (css_buf);
16036
16037 css_buf = css_buf_unicode;
16038 css_cnt = css_cnt_unicode;
16039 }
16040
16041 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16042
16043 uint mask_min = pw_min;
16044 uint mask_max = pw_max;
16045
16046 if (opts_type & OPTS_TYPE_PT_UNICODE)
16047 {
16048 mask_min *= 2;
16049 mask_max *= 2;
16050 }
16051
16052 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16053 {
16054 if (css_cnt < mask_min)
16055 {
16056 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16057 }
16058
16059 if (css_cnt > mask_max)
16060 {
16061 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16062 }
16063
16064 // skip to next mask
16065
16066 dictpos++;
16067
16068 rd->dictpos = dictpos;
16069
16070 logfile_sub_msg ("STOP");
16071
16072 continue;
16073 }
16074
16075 uint save_css_cnt = css_cnt;
16076
16077 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16078 {
16079 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16080 {
16081 uint salt_len = (uint) data.salts_buf[0].salt_len;
16082 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16083
16084 uint css_cnt_salt = css_cnt + salt_len;
16085
16086 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16087
16088 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16089
16090 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16091 {
16092 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16093 css_buf_salt[j].cs_len = 1;
16094 }
16095
16096 free (css_buf);
16097
16098 css_buf = css_buf_salt;
16099 css_cnt = css_cnt_salt;
16100 }
16101 }
16102
16103 data.mask = mask;
16104 data.css_cnt = css_cnt;
16105 data.css_buf = css_buf;
16106
16107 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16108
16109 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16110
16111 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16112
16113 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16114 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16115
16116 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16117
16118 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16119
16120 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16121 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16122
16123 data.root_css_buf = root_css_buf;
16124 data.markov_css_buf = markov_css_buf;
16125
16126 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16127
16128 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16129
16130 local_free (root_table_buf);
16131 local_free (markov_table_buf);
16132
16133 // copy + args
16134
16135 uint css_cnt_l = css_cnt;
16136 uint css_cnt_r;
16137
16138 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16139 {
16140 if (save_css_cnt < 6)
16141 {
16142 css_cnt_r = 1;
16143 }
16144 else if (save_css_cnt == 6)
16145 {
16146 css_cnt_r = 2;
16147 }
16148 else
16149 {
16150 if (opts_type & OPTS_TYPE_PT_UNICODE)
16151 {
16152 if (save_css_cnt == 8 || save_css_cnt == 10)
16153 {
16154 css_cnt_r = 2;
16155 }
16156 else
16157 {
16158 css_cnt_r = 4;
16159 }
16160 }
16161 else
16162 {
16163 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16164 {
16165 css_cnt_r = 3;
16166 }
16167 else
16168 {
16169 css_cnt_r = 4;
16170 }
16171 }
16172 }
16173 }
16174 else
16175 {
16176 css_cnt_r = 1;
16177
16178 /* unfinished code?
16179 int sum = css_buf[css_cnt_r - 1].cs_len;
16180
16181 for (uint i = 1; i < 4 && i < css_cnt; i++)
16182 {
16183 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16184
16185 css_cnt_r++;
16186
16187 sum *= css_buf[css_cnt_r - 1].cs_len;
16188 }
16189 */
16190 }
16191
16192 css_cnt_l -= css_cnt_r;
16193
16194 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16195
16196 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16197 {
16198 hc_device_param_t *device_param = &data.devices_param[device_id];
16199
16200 if (device_param->skipped) continue;
16201
16202 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16203 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16204 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16205
16206 device_param->kernel_params_mp_l_buf64[3] = 0;
16207 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16208 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16209 device_param->kernel_params_mp_l_buf32[6] = 0;
16210 device_param->kernel_params_mp_l_buf32[7] = 0;
16211 device_param->kernel_params_mp_l_buf32[8] = 0;
16212
16213 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16214 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16215 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16216 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16217
16218 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16219 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16220 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16221
16222 device_param->kernel_params_mp_r_buf64[3] = 0;
16223 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16224 device_param->kernel_params_mp_r_buf32[5] = 0;
16225 device_param->kernel_params_mp_r_buf32[6] = 0;
16226 device_param->kernel_params_mp_r_buf32[7] = 0;
16227
16228 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]);
16229 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]);
16230 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]);
16231
16232 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]);
16233 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]);
16234 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]);
16235
16236 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);
16237 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);
16238 }
16239 }
16240
16241 u64 words_base = data.words_cnt;
16242
16243 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16244 {
16245 if (data.kernel_rules_cnt)
16246 {
16247 words_base /= data.kernel_rules_cnt;
16248 }
16249 }
16250 else if (data.attack_kern == ATTACK_KERN_COMBI)
16251 {
16252 if (data.combs_cnt)
16253 {
16254 words_base /= data.combs_cnt;
16255 }
16256 }
16257 else if (data.attack_kern == ATTACK_KERN_BF)
16258 {
16259 if (data.bfs_cnt)
16260 {
16261 words_base /= data.bfs_cnt;
16262 }
16263 }
16264
16265 data.words_base = words_base;
16266
16267 if (keyspace == 1)
16268 {
16269 log_info ("%llu", (unsigned long long int) words_base);
16270
16271 return (0);
16272 }
16273
16274 if (data.words_cur > data.words_base)
16275 {
16276 log_error ("ERROR: restore value greater keyspace");
16277
16278 return (-1);
16279 }
16280
16281 if (data.words_cur)
16282 {
16283 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16284 {
16285 for (uint i = 0; i < data.salts_cnt; i++)
16286 {
16287 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16288 }
16289 }
16290 else if (data.attack_kern == ATTACK_KERN_COMBI)
16291 {
16292 for (uint i = 0; i < data.salts_cnt; i++)
16293 {
16294 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16295 }
16296 }
16297 else if (data.attack_kern == ATTACK_KERN_BF)
16298 {
16299 for (uint i = 0; i < data.salts_cnt; i++)
16300 {
16301 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16302 }
16303 }
16304 }
16305
16306 /*
16307 * Inform user about possible slow speeds
16308 */
16309
16310 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16311 {
16312 if (data.words_base < kernel_power_all)
16313 {
16314 if (quiet == 0)
16315 {
16316 log_info ("");
16317 log_info ("ATTENTION!");
16318 log_info (" The wordlist or mask you are using is too small.");
16319 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16320 log_info (" The cracking speed will drop.");
16321 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16322 log_info ("");
16323 }
16324 }
16325 }
16326
16327 /*
16328 * Update loopback file
16329 */
16330
16331 if (loopback == 1)
16332 {
16333 time_t now;
16334
16335 time (&now);
16336
16337 uint random_num = get_random_num (0, 9999);
16338
16339 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16340
16341 data.loopback_file = loopback_file;
16342 }
16343
16344 /*
16345 * Update dictionary statistic
16346 */
16347
16348 if (keyspace == 0)
16349 {
16350 dictstat_fp = fopen (dictstat, "wb");
16351
16352 if (dictstat_fp)
16353 {
16354 lock_file (dictstat_fp);
16355
16356 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16357
16358 fclose (dictstat_fp);
16359 }
16360 }
16361
16362 data.devices_status = STATUS_RUNNING;
16363
16364 if (initial_restore_done == 0)
16365 {
16366 if (data.restore_disable == 0) cycle_restore ();
16367
16368 initial_restore_done = 1;
16369 }
16370
16371 hc_timer_set (&data.timer_running);
16372
16373 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16374 {
16375 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16376 {
16377 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16378 if (quiet == 0) fflush (stdout);
16379 }
16380 }
16381 else if (wordlist_mode == WL_MODE_STDIN)
16382 {
16383 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16384 if (data.quiet == 0) log_info ("");
16385 }
16386
16387 time_t runtime_start;
16388
16389 time (&runtime_start);
16390
16391 data.runtime_start = runtime_start;
16392
16393 /**
16394 * create cracker threads
16395 */
16396
16397 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16398
16399 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16400 {
16401 hc_device_param_t *device_param = &devices_param[device_id];
16402
16403 if (wordlist_mode == WL_MODE_STDIN)
16404 {
16405 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16406 }
16407 else
16408 {
16409 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16410 }
16411 }
16412
16413 // wait for crack threads to exit
16414
16415 hc_thread_wait (data.devices_cnt, c_threads);
16416
16417 local_free (c_threads);
16418
16419 data.restore = 0;
16420
16421 // finalize task
16422
16423 logfile_sub_var_uint ("status-after-work", data.devices_status);
16424
16425 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16426
16427 if (data.devices_status == STATUS_CRACKED) break;
16428 if (data.devices_status == STATUS_ABORTED) break;
16429
16430 if (data.devices_status == STATUS_BYPASS)
16431 {
16432 data.devices_status = STATUS_RUNNING;
16433 }
16434
16435 if (induction_dictionaries_cnt)
16436 {
16437 unlink (induction_dictionaries[0]);
16438 }
16439
16440 free (induction_dictionaries);
16441
16442 if (attack_mode != ATTACK_MODE_BF)
16443 {
16444 induction_dictionaries = scan_directory (induction_directory);
16445
16446 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16447 }
16448
16449 if (benchmark == 0)
16450 {
16451 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16452 {
16453 if (quiet == 0) clear_prompt ();
16454
16455 if (quiet == 0) log_info ("");
16456
16457 if (status == 1)
16458 {
16459 status_display ();
16460 }
16461 else
16462 {
16463 if (quiet == 0) status_display ();
16464 }
16465
16466 if (quiet == 0) log_info ("");
16467 }
16468 }
16469
16470 if (attack_mode == ATTACK_MODE_BF)
16471 {
16472 dictpos++;
16473
16474 rd->dictpos = dictpos;
16475 }
16476 else
16477 {
16478 if (induction_dictionaries_cnt)
16479 {
16480 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16481 }
16482 else
16483 {
16484 dictpos++;
16485
16486 rd->dictpos = dictpos;
16487 }
16488 }
16489
16490 time_t runtime_stop;
16491
16492 time (&runtime_stop);
16493
16494 data.runtime_stop = runtime_stop;
16495
16496 logfile_sub_uint (runtime_start);
16497 logfile_sub_uint (runtime_stop);
16498
16499 logfile_sub_msg ("STOP");
16500
16501 global_free (subid);
16502 }
16503
16504 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16505
16506 if (data.devices_status == STATUS_CRACKED) break;
16507 if (data.devices_status == STATUS_ABORTED) break;
16508 if (data.devices_status == STATUS_QUIT) break;
16509
16510 if (data.devices_status == STATUS_BYPASS)
16511 {
16512 data.devices_status = STATUS_RUNNING;
16513 }
16514 }
16515
16516 // 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
16517
16518 if (attack_mode == ATTACK_MODE_STRAIGHT)
16519 {
16520 if (data.wordlist_mode == WL_MODE_FILE)
16521 {
16522 if (data.dictfile == NULL)
16523 {
16524 if (dictfiles != NULL)
16525 {
16526 data.dictfile = dictfiles[0];
16527
16528 hc_timer_set (&data.timer_running);
16529 }
16530 }
16531 }
16532 }
16533 // NOTE: combi is okay because it is already set beforehand
16534 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16535 {
16536 if (data.dictfile == NULL)
16537 {
16538 if (dictfiles != NULL)
16539 {
16540 hc_timer_set (&data.timer_running);
16541
16542 data.dictfile = dictfiles[0];
16543 }
16544 }
16545 }
16546 else if (attack_mode == ATTACK_MODE_BF)
16547 {
16548 if (data.mask == NULL)
16549 {
16550 hc_timer_set (&data.timer_running);
16551
16552 data.mask = masks[0];
16553 }
16554 }
16555
16556 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16557 {
16558 data.devices_status = STATUS_EXHAUSTED;
16559 }
16560
16561 // if cracked / aborted remove last induction dictionary
16562
16563 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16564 {
16565 struct stat induct_stat;
16566
16567 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16568 {
16569 unlink (induction_dictionaries[file_pos]);
16570 }
16571 }
16572
16573 // wait for non-interactive threads
16574
16575 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16576 {
16577 hc_thread_wait (1, &ni_threads[thread_idx]);
16578 }
16579
16580 local_free (ni_threads);
16581
16582 // wait for interactive threads
16583
16584 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16585 {
16586 hc_thread_wait (1, &i_thread);
16587 }
16588
16589 // we dont need restore file anymore
16590 if (data.restore_disable == 0)
16591 {
16592 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16593 {
16594 unlink (eff_restore_file);
16595 unlink (new_restore_file);
16596 }
16597 else
16598 {
16599 cycle_restore ();
16600 }
16601 }
16602
16603 // finally save left hashes
16604
16605 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16606 {
16607 save_hash ();
16608 }
16609
16610 /**
16611 * Clean up
16612 */
16613
16614 if (benchmark == 1)
16615 {
16616 status_benchmark ();
16617
16618 log_info ("");
16619 }
16620 else
16621 {
16622 if (quiet == 0) clear_prompt ();
16623
16624 if (quiet == 0) log_info ("");
16625
16626 if (status == 1)
16627 {
16628 status_display ();
16629 }
16630 else
16631 {
16632 if (quiet == 0) status_display ();
16633 }
16634
16635 if (quiet == 0) log_info ("");
16636 }
16637
16638 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16639 {
16640 hc_device_param_t *device_param = &data.devices_param[device_id];
16641
16642 if (device_param->skipped) continue;
16643
16644 local_free (device_param->result);
16645
16646 local_free (device_param->combs_buf);
16647
16648 local_free (device_param->hooks_buf);
16649
16650 local_free (device_param->device_name);
16651
16652 local_free (device_param->device_name_chksum);
16653
16654 local_free (device_param->device_version);
16655
16656 local_free (device_param->driver_version);
16657
16658 if (device_param->pws_buf) myfree (device_param->pws_buf);
16659 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16660 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16661 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16662 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16663 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16664 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16665 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16666 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16667 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16668 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16669 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16670 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16671 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16672 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16673 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16674 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16675 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16676 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16677 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16678 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16679 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16680 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16681 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16682 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16683 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16684 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16685 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16686 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16687
16688 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16689 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16690 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16691 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16692 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16693 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16694 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16695 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16696 if (device_param->kernel_tb) hc_clReleaseKernel (data.ocl, device_param->kernel_tb);
16697 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16698 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16699
16700 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16701 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16702 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16703
16704 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16705 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16706 }
16707
16708 // reset default fan speed
16709
16710 #ifdef HAVE_HWMON
16711 if (gpu_temp_disable == 0)
16712 {
16713 #ifdef HAVE_ADL
16714 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16715 {
16716 hc_thread_mutex_lock (mux_adl);
16717
16718 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16719 {
16720 hc_device_param_t *device_param = &data.devices_param[device_id];
16721
16722 if (device_param->skipped) continue;
16723
16724 if (data.hm_device[device_id].fan_supported == 1)
16725 {
16726 int fanspeed = temp_retain_fanspeed_value[device_id];
16727
16728 if (fanspeed == -1) continue;
16729
16730 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16731
16732 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16733 }
16734 }
16735
16736 hc_thread_mutex_unlock (mux_adl);
16737 }
16738 #endif // HAVE_ADL
16739 }
16740
16741 #ifdef HAVE_ADL
16742 // reset power tuning
16743
16744 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16745 {
16746 hc_thread_mutex_lock (mux_adl);
16747
16748 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16749 {
16750 hc_device_param_t *device_param = &data.devices_param[device_id];
16751
16752 if (device_param->skipped) continue;
16753
16754 if (data.hm_device[device_id].od_version == 6)
16755 {
16756 // check powertune capabilities first, if not available then skip device
16757
16758 int powertune_supported = 0;
16759
16760 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16761 {
16762 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16763
16764 return (-1);
16765 }
16766
16767 if (powertune_supported != 0)
16768 {
16769 // powercontrol settings
16770
16771 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)
16772 {
16773 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16774
16775 return (-1);
16776 }
16777
16778 // clocks
16779
16780 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16781
16782 performance_state->iNumberOfPerformanceLevels = 2;
16783
16784 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16785 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16786 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16787 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16788
16789 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)
16790 {
16791 log_info ("ERROR: Failed to restore ADL performance state");
16792
16793 return (-1);
16794 }
16795
16796 local_free (performance_state);
16797 }
16798 }
16799 }
16800
16801 hc_thread_mutex_unlock (mux_adl);
16802 }
16803 #endif // HAVE_ADL
16804
16805 if (gpu_temp_disable == 0)
16806 {
16807 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
16808 if (data.hm_nv)
16809 {
16810 #if defined(LINUX) && defined(HAVE_NVML)
16811
16812 hm_NVML_nvmlShutdown (data.hm_nv);
16813
16814 nvml_close (data.hm_nv);
16815
16816 #elif defined(WIN) && (HAVE_NVAPI)
16817
16818 hm_NvAPI_Unload (data.hm_nv);
16819
16820 nvapi_close (data.hm_nv);
16821
16822 #endif
16823
16824 data.hm_nv = NULL;
16825 }
16826 #endif
16827
16828 #ifdef HAVE_ADL
16829 if (data.hm_amd)
16830 {
16831 hm_ADL_Main_Control_Destroy (data.hm_amd);
16832
16833 adl_close (data.hm_amd);
16834 data.hm_amd = NULL;
16835 }
16836 #endif
16837 }
16838 #endif // HAVE_HWMON
16839
16840 // free memory
16841
16842 local_free (masks);
16843
16844 local_free (dictstat_base);
16845
16846 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16847 {
16848 pot_t *pot_ptr = &pot[pot_pos];
16849
16850 hash_t *hash = &pot_ptr->hash;
16851
16852 local_free (hash->digest);
16853
16854 if (isSalted)
16855 {
16856 local_free (hash->salt);
16857 }
16858 }
16859
16860 local_free (pot);
16861
16862 local_free (all_kernel_rules_cnt);
16863 local_free (all_kernel_rules_buf);
16864
16865 local_free (wl_data->buf);
16866 local_free (wl_data);
16867
16868 local_free (bitmap_s1_a);
16869 local_free (bitmap_s1_b);
16870 local_free (bitmap_s1_c);
16871 local_free (bitmap_s1_d);
16872 local_free (bitmap_s2_a);
16873 local_free (bitmap_s2_b);
16874 local_free (bitmap_s2_c);
16875 local_free (bitmap_s2_d);
16876
16877 #ifdef HAVE_HWMON
16878 local_free (temp_retain_fanspeed_value);
16879 #ifdef HAVE_ADL
16880 local_free (od_clock_mem_status);
16881 local_free (od_power_control_status);
16882 #endif // ADL
16883 #endif
16884
16885 global_free (devices_param);
16886
16887 global_free (kernel_rules_buf);
16888
16889 global_free (root_css_buf);
16890 global_free (markov_css_buf);
16891
16892 global_free (digests_buf);
16893 global_free (digests_shown);
16894 global_free (digests_shown_tmp);
16895
16896 global_free (salts_buf);
16897 global_free (salts_shown);
16898
16899 global_free (esalts_buf);
16900
16901 global_free (words_progress_done);
16902 global_free (words_progress_rejected);
16903 global_free (words_progress_restored);
16904
16905 if (pot_fp) fclose (pot_fp);
16906
16907 if (data.devices_status == STATUS_QUIT) break;
16908 }
16909
16910 // destroy others mutex
16911
16912 hc_thread_mutex_delete (mux_dispatcher);
16913 hc_thread_mutex_delete (mux_counter);
16914 hc_thread_mutex_delete (mux_display);
16915 hc_thread_mutex_delete (mux_adl);
16916
16917 // free memory
16918
16919 local_free (eff_restore_file);
16920 local_free (new_restore_file);
16921
16922 local_free (rd);
16923
16924 // tuning db
16925
16926 tuning_db_destroy (tuning_db);
16927
16928 // loopback
16929
16930 local_free (loopback_file);
16931
16932 if (loopback == 1) unlink (loopback_file);
16933
16934 // induction directory
16935
16936 if (induction_dir == NULL)
16937 {
16938 if (attack_mode != ATTACK_MODE_BF)
16939 {
16940 if (rmdir (induction_directory) == -1)
16941 {
16942 if (errno == ENOENT)
16943 {
16944 // good, we can ignore
16945 }
16946 else if (errno == ENOTEMPTY)
16947 {
16948 // good, we can ignore
16949 }
16950 else
16951 {
16952 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16953
16954 return (-1);
16955 }
16956 }
16957
16958 local_free (induction_directory);
16959 }
16960 }
16961
16962 // outfile-check directory
16963
16964 if (outfile_check_dir == NULL)
16965 {
16966 if (rmdir (outfile_check_directory) == -1)
16967 {
16968 if (errno == ENOENT)
16969 {
16970 // good, we can ignore
16971 }
16972 else if (errno == ENOTEMPTY)
16973 {
16974 // good, we can ignore
16975 }
16976 else
16977 {
16978 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16979
16980 return (-1);
16981 }
16982 }
16983
16984 local_free (outfile_check_directory);
16985 }
16986
16987 time_t proc_stop;
16988
16989 time (&proc_stop);
16990
16991 logfile_top_uint (proc_start);
16992 logfile_top_uint (proc_stop);
16993
16994 logfile_top_msg ("STOP");
16995
16996 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16997 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16998
16999 if (data.ocl) ocl_close (data.ocl);
17000
17001 if (data.devices_status == STATUS_ABORTED) return 2;
17002 if (data.devices_status == STATUS_QUIT) return 2;
17003 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17004 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17005 if (data.devices_status == STATUS_CRACKED) return 0;
17006
17007 return -1;
17008 }
Hashcat additions to support pwdhash