projects / hashcat.git / blob
? search:


6e376613e6c4e4cb3f99e82806f033247592d700
[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 HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 135
152
153 #define global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
168 {
169 900,
170 0,
171 5100,
172 100,
173 1400,
174 10800,
175 1700,
176 5000,
177 10100,
178 6000,
179 6100,
180 6900,
181 11700,
182 11800,
183 400,
184 8900,
185 11900,
186 12000,
187 10900,
188 12100,
189 23,
190 2500,
191 5300,
192 5400,
193 5500,
194 5600,
195 7300,
196 7500,
197 13100,
198 8300,
199 11100,
200 11200,
201 11400,
202 121,
203 2611,
204 2711,
205 2811,
206 8400,
207 11,
208 2612,
209 7900,
210 21,
211 11000,
212 124,
213 10000,
214 3711,
215 7600,
216 12,
217 131,
218 132,
219 1731,
220 200,
221 300,
222 3100,
223 112,
224 12300,
225 8000,
226 141,
227 1441,
228 1600,
229 12600,
230 1421,
231 101,
232 111,
233 1711,
234 3000,
235 1000,
236 1100,
237 2100,
238 12800,
239 1500,
240 12400,
241 500,
242 3200,
243 7400,
244 1800,
245 122,
246 1722,
247 7100,
248 6300,
249 6700,
250 6400,
251 6500,
252 2400,
253 2410,
254 5700,
255 9200,
256 9300,
257 22,
258 501,
259 5800,
260 8100,
261 8500,
262 7200,
263 9900,
264 7700,
265 7800,
266 10300,
267 8600,
268 8700,
269 9100,
270 133,
271 11600,
272 12500,
273 13000,
274 13200,
275 13300,
276 6211,
277 6221,
278 6231,
279 6241,
280 8800,
281 12900,
282 12200,
283 9700,
284 9710,
285 9800,
286 9810,
287 9400,
288 9500,
289 9600,
290 10400,
291 10410,
292 10500,
293 10600,
294 10700,
295 9000,
296 5200,
297 6800,
298 6600,
299 8200,
300 11300,
301 12700,
302 13400,
303 125
304 };
305
306 /**
307 * types
308 */
309
310 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
311
312 /**
313 * globals
314 */
315
316 static unsigned int full01 = 0x01010101;
317 static unsigned int full80 = 0x80808080;
318
319 int SUPPRESS_OUTPUT = 0;
320
321 hc_thread_mutex_t mux_adl;
322 hc_thread_mutex_t mux_counter;
323 hc_thread_mutex_t mux_dispatcher;
324 hc_thread_mutex_t mux_display;
325
326 hc_global_data_t data;
327
328 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
329
330 const char *USAGE_MINI[] =
331 {
332 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
333 "",
334 "Try --help for more help.",
335 NULL
336 };
337
338 const char *USAGE_BIG[] =
339 {
340 "%s, advanced password recovery",
341 "",
342 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
343 "",
344 "=======",
345 "Options",
346 "=======",
347 "",
348 "* General:",
349 "",
350 " -m, --hash-type=NUM Hash-type, see references below",
351 " -a, --attack-mode=NUM Attack-mode, see references below",
352 " -V, --version Print version",
353 " -h, --help Print help",
354 " --quiet Suppress output",
355 "",
356 "* Misc:",
357 "",
358 " --hex-charset Assume charset is given in hex",
359 " --hex-salt Assume salt is given in hex",
360 " --hex-wordlist Assume words in wordlist is given in hex",
361 " --force Ignore warnings",
362 " --status Enable automatic update of the status-screen",
363 " --status-timer=NUM Seconds between status-screen update",
364 " --status-automat Display the status view in a machine readable format",
365 " --loopback Add new plains to induct directory",
366 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
367 "",
368 "* Markov:",
369 "",
370 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
371 " --markov-disable Disables markov-chains, emulates classic brute-force",
372 " --markov-classic Enables classic markov-chains, no per-position enhancement",
373 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
374 "",
375 "* Session:",
376 "",
377 " --runtime=NUM Abort session after NUM seconds of runtime",
378 " --session=STR Define specific session name",
379 " --restore Restore session from --session",
380 " --restore-disable Do not write restore file",
381 "",
382 "* Files:",
383 "",
384 " -o, --outfile=FILE Define outfile for recovered hash",
385 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
386 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
387 " --outfile-check-timer=NUM Seconds between outfile checks",
388 " -p, --separator=CHAR Separator char for hashlists and outfile",
389 " --show Show cracked passwords only",
390 " --left Show un-cracked passwords only",
391 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
392 " --remove Enable remove of hash once it is cracked",
393 " --remove-timer=NUM Update input hash file each NUM seconds",
394 " --potfile-disable Do not write potfile",
395 " --potfile-path Specific path to potfile",
396 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
397 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
398 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
399 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
400 " --logfile-disable Disable the logfile",
401 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
402 "",
403 "* Resources:",
404 "",
405 " -b, --benchmark Run benchmark",
406 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
407 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
408 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
409 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
410 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
411 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
412 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
413 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
414 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
415 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
416 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
417 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
418 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
419 #ifdef HAVE_HWMON
420 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
421 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
422 #ifdef HAVE_ADL
423 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
424 #endif
425 #endif
426 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
427 "",
428 "* Distributed:",
429 "",
430 " -s, --skip=NUM Skip number of words",
431 " -l, --limit=NUM Limit number of words",
432 " --keyspace Show keyspace base:mod values and quit",
433 "",
434 "* Rules:",
435 "",
436 " -j, --rule-left=RULE Single rule applied to each word from left dict",
437 " -k, --rule-right=RULE Single rule applied to each word from right dict",
438 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
439 " -g, --generate-rules=NUM Generate NUM random rules",
440 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
441 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
442 " --generate-rules-seed=NUM Force RNG seed to NUM",
443 "",
444 "* Custom charsets:",
445 "",
446 " -1, --custom-charset1=CS User-defined charsets",
447 " -2, --custom-charset2=CS Example:",
448 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
449 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
450 "",
451 "* Increment:",
452 "",
453 " -i, --increment Enable increment mode",
454 " --increment-min=NUM Start incrementing at NUM",
455 " --increment-max=NUM Stop incrementing at NUM",
456 "",
457 "==========",
458 "References",
459 "==========",
460 "",
461 "* Workload Profile:",
462 "",
463 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
464 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
465 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
466 "",
467 "* OpenCL device-types:",
468 "",
469 " 1 = CPU devices",
470 " 2 = GPU devices",
471 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
472 "",
473 "* Outfile Formats:",
474 "",
475 " 1 = hash[:salt]",
476 " 2 = plain",
477 " 3 = hash[:salt]:plain",
478 " 4 = hex_plain",
479 " 5 = hash[:salt]:hex_plain",
480 " 6 = plain:hex_plain",
481 " 7 = hash[:salt]:plain:hex_plain",
482 " 8 = crackpos",
483 " 9 = hash[:salt]:crackpos",
484 " 10 = plain:crackpos",
485 " 11 = hash[:salt]:plain:crackpos",
486 " 12 = hex_plain:crackpos",
487 " 13 = hash[:salt]:hex_plain:crackpos",
488 " 14 = plain:hex_plain:crackpos",
489 " 15 = hash[:salt]:plain:hex_plain:crackpos",
490 "",
491 "* Debug mode output formats (for hybrid mode only, by using rules):",
492 "",
493 " 1 = save finding rule",
494 " 2 = save original word",
495 " 3 = save original word and finding rule",
496 " 4 = save original word, finding rule and modified plain",
497 "",
498 "* Built-in charsets:",
499 "",
500 " ?l = abcdefghijklmnopqrstuvwxyz",
501 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
502 " ?d = 0123456789",
503 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
504 " ?a = ?l?u?d?s",
505 " ?b = 0x00 - 0xff",
506 "",
507 "* Attack modes:",
508 "",
509 " 0 = Straight",
510 " 1 = Combination",
511 " 3 = Brute-force",
512 " 6 = Hybrid dict + mask",
513 " 7 = Hybrid mask + dict",
514 "",
515 "* Hash types:",
516 "",
517 "[[ Roll-your-own: Raw Hashes ]]",
518 "",
519 " 900 = MD4",
520 " 0 = MD5",
521 " 5100 = Half MD5",
522 " 100 = SHA1",
523 " 10800 = SHA-384",
524 " 1400 = SHA-256",
525 " 1700 = SHA-512",
526 " 5000 = SHA-3(Keccak)",
527 " 10100 = SipHash",
528 " 6000 = RipeMD160",
529 " 6100 = Whirlpool",
530 " 6900 = GOST R 34.11-94",
531 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
532 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
533 "",
534 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
535 "",
536 " 10 = md5($pass.$salt)",
537 " 20 = md5($salt.$pass)",
538 " 30 = md5(unicode($pass).$salt)",
539 " 40 = md5($salt.unicode($pass))",
540 " 3800 = md5($salt.$pass.$salt)",
541 " 3710 = md5($salt.md5($pass))",
542 " 2600 = md5(md5($pass)",
543 " 4300 = md5(strtoupper(md5($pass)))",
544 " 4400 = md5(sha1($pass))",
545 " 110 = sha1($pass.$salt)",
546 " 120 = sha1($salt.$pass)",
547 " 130 = sha1(unicode($pass).$salt)",
548 " 140 = sha1($salt.unicode($pass))",
549 " 4500 = sha1(sha1($pass)",
550 " 4700 = sha1(md5($pass))",
551 " 4900 = sha1($salt.$pass.$salt)",
552 " 1410 = sha256($pass.$salt)",
553 " 1420 = sha256($salt.$pass)",
554 " 1430 = sha256(unicode($pass).$salt)",
555 " 1440 = sha256($salt.unicode($pass))",
556 " 1710 = sha512($pass.$salt)",
557 " 1720 = sha512($salt.$pass)",
558 " 1730 = sha512(unicode($pass).$salt)",
559 " 1740 = sha512($salt.unicode($pass))",
560 "",
561 "[[ Roll-your-own: Authenticated Hashes ]]",
562 "",
563 " 50 = HMAC-MD5 (key = $pass)",
564 " 60 = HMAC-MD5 (key = $salt)",
565 " 150 = HMAC-SHA1 (key = $pass)",
566 " 160 = HMAC-SHA1 (key = $salt)",
567 " 1450 = HMAC-SHA256 (key = $pass)",
568 " 1460 = HMAC-SHA256 (key = $salt)",
569 " 1750 = HMAC-SHA512 (key = $pass)",
570 " 1760 = HMAC-SHA512 (key = $salt)",
571 "",
572 "[[ Generic KDF ]]",
573 "",
574 " 400 = phpass",
575 " 8900 = scrypt",
576 " 11900 = PBKDF2-HMAC-MD5",
577 " 12000 = PBKDF2-HMAC-SHA1",
578 " 10900 = PBKDF2-HMAC-SHA256",
579 " 12100 = PBKDF2-HMAC-SHA512",
580 "",
581 "[[ Network protocols, Challenge-Response ]]",
582 "",
583 " 23 = Skype",
584 " 2500 = WPA/WPA2",
585 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
586 " 5300 = IKE-PSK MD5",
587 " 5400 = IKE-PSK SHA1",
588 " 5500 = NetNTLMv1",
589 " 5500 = NetNTLMv1 + ESS",
590 " 5600 = NetNTLMv2",
591 " 7300 = IPMI2 RAKP HMAC-SHA1",
592 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
593 " 8300 = DNSSEC (NSEC3)",
594 " 10200 = Cram MD5",
595 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
596 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
597 " 11400 = SIP digest authentication (MD5)",
598 " 13100 = Kerberos 5 TGS-REP etype 23",
599 "",
600 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
601 "",
602 " 121 = SMF (Simple Machines Forum)",
603 " 400 = phpBB3",
604 " 2611 = vBulletin < v3.8.5",
605 " 2711 = vBulletin > v3.8.5",
606 " 2811 = MyBB",
607 " 2811 = IPB (Invison Power Board)",
608 " 8400 = WBB3 (Woltlab Burning Board)",
609 " 11 = Joomla < 2.5.18",
610 " 400 = Joomla > 2.5.18",
611 " 400 = Wordpress",
612 " 2612 = PHPS",
613 " 7900 = Drupal7",
614 " 21 = osCommerce",
615 " 21 = xt:Commerce",
616 " 11000 = PrestaShop",
617 " 124 = Django (SHA-1)",
618 " 10000 = Django (PBKDF2-SHA256)",
619 " 3711 = Mediawiki B type",
620 " 7600 = Redmine",
621 "",
622 "[[ Database Server ]]",
623 "",
624 " 12 = PostgreSQL",
625 " 131 = MSSQL(2000)",
626 " 132 = MSSQL(2005)",
627 " 1731 = MSSQL(2012)",
628 " 1731 = MSSQL(2014)",
629 " 200 = MySQL323",
630 " 300 = MySQL4.1/MySQL5",
631 " 3100 = Oracle H: Type (Oracle 7+)",
632 " 112 = Oracle S: Type (Oracle 11+)",
633 " 12300 = Oracle T: Type (Oracle 12+)",
634 " 8000 = Sybase ASE",
635 "",
636 "[[ HTTP, SMTP, LDAP Server ]]",
637 "",
638 " 141 = EPiServer 6.x < v4",
639 " 1441 = EPiServer 6.x > v4",
640 " 1600 = Apache $apr1$",
641 " 12600 = ColdFusion 10+",
642 " 1421 = hMailServer",
643 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
644 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
645 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
646 "",
647 "[[ Checksums ]]",
648 "",
649 " 11500 = CRC32",
650 "",
651 "[[ Operating-Systems ]]",
652 "",
653 " 3000 = LM",
654 " 1000 = NTLM",
655 " 1100 = Domain Cached Credentials (DCC), MS Cache",
656 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
657 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
658 " 1500 = descrypt, DES(Unix), Traditional DES",
659 " 12400 = BSDiCrypt, Extended DES",
660 " 500 = md5crypt $1$, MD5(Unix)",
661 " 3200 = bcrypt $2*$, Blowfish(Unix)",
662 " 7400 = sha256crypt $5$, SHA256(Unix)",
663 " 1800 = sha512crypt $6$, SHA512(Unix)",
664 " 122 = OSX v10.4",
665 " 122 = OSX v10.5",
666 " 122 = OSX v10.6",
667 " 1722 = OSX v10.7",
668 " 7100 = OSX v10.8",
669 " 7100 = OSX v10.9",
670 " 7100 = OSX v10.10",
671 " 6300 = AIX {smd5}",
672 " 6700 = AIX {ssha1}",
673 " 6400 = AIX {ssha256}",
674 " 6500 = AIX {ssha512}",
675 " 2400 = Cisco-PIX",
676 " 2410 = Cisco-ASA",
677 " 500 = Cisco-IOS $1$",
678 " 5700 = Cisco-IOS $4$",
679 " 9200 = Cisco-IOS $8$",
680 " 9300 = Cisco-IOS $9$",
681 " 22 = Juniper Netscreen/SSG (ScreenOS)",
682 " 501 = Juniper IVE",
683 " 5800 = Android PIN",
684 " 8100 = Citrix Netscaler",
685 " 8500 = RACF",
686 " 7200 = GRUB 2",
687 " 9900 = Radmin2",
688 " 125 = ArubaOS",
689 "",
690 "[[ Enterprise Application Software (EAS) ]]",
691 "",
692 " 7700 = SAP CODVN B (BCODE)",
693 " 7800 = SAP CODVN F/G (PASSCODE)",
694 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
695 " 8600 = Lotus Notes/Domino 5",
696 " 8700 = Lotus Notes/Domino 6",
697 " 9100 = Lotus Notes/Domino 8",
698 " 133 = PeopleSoft",
699 "",
700 "[[ Archives ]]",
701 "",
702 " 11600 = 7-Zip",
703 " 12500 = RAR3-hp",
704 " 13000 = RAR5",
705 " 13200 = AxCrypt",
706 " 13300 = AxCrypt in memory SHA1",
707 "",
708 "[[ Full-Disk encryptions (FDE) ]]",
709 "",
710 " 62XY = TrueCrypt 5.0+",
711 " X = 1 = PBKDF2-HMAC-RipeMD160",
712 " X = 2 = PBKDF2-HMAC-SHA512",
713 " X = 3 = PBKDF2-HMAC-Whirlpool",
714 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
715 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
716 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
717 " Y = 3 = XTS 1536 bit (Ciphers: All)",
718 " 8800 = Android FDE < v4.3",
719 " 12900 = Android FDE (Samsung DEK)",
720 " 12200 = eCryptfs",
721 "",
722 "[[ Documents ]]",
723 "",
724 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
725 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
726 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
727 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
728 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
729 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
730 " 9400 = MS Office 2007",
731 " 9500 = MS Office 2010",
732 " 9600 = MS Office 2013",
733 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
734 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
735 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
736 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
737 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
738 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
739 "",
740 "[[ Password Managers ]]",
741 "",
742 " 9000 = Password Safe v2",
743 " 5200 = Password Safe v3",
744 " 6800 = Lastpass",
745 " 6600 = 1Password, agilekeychain",
746 " 8200 = 1Password, cloudkeychain",
747 " 11300 = Bitcoin/Litecoin wallet.dat",
748 " 12700 = Blockchain, My Wallet",
749 " 13400 = Keepass 1 (AES/Twofish) and Keepass 2 (AES)",
750 "",
751 NULL
752 };
753
754 /**
755 * oclHashcat specific functions
756 */
757
758 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
759 {
760 int exec_pos = (int) device_param->exec_pos - last_num_entries;
761
762 if (exec_pos < 0) exec_pos += EXEC_CACHE;
763
764 double exec_ms_sum = 0;
765
766 int exec_ms_cnt = 0;
767
768 for (int i = 0; i < last_num_entries; i++)
769 {
770 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
771
772 if (exec_ms)
773 {
774 exec_ms_sum += exec_ms;
775
776 exec_ms_cnt++;
777 }
778 }
779
780 if (exec_ms_cnt == 0) return 0;
781
782 return exec_ms_sum / exec_ms_cnt;
783 }
784
785 void status_display_automat ()
786 {
787 FILE *out = stdout;
788
789 fprintf (out, "STATUS\t%u\t", data.devices_status);
790
791 /**
792 * speed new
793 */
794
795 fprintf (out, "SPEED\t");
796
797 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
798 {
799 hc_device_param_t *device_param = &data.devices_param[device_id];
800
801 if (device_param->skipped) continue;
802
803 u64 speed_cnt = 0;
804 float speed_ms = 0;
805
806 for (int i = 0; i < SPEED_CACHE; i++)
807 {
808 float rec_ms;
809
810 hc_timer_get (device_param->speed_rec[i], rec_ms);
811
812 if (rec_ms > SPEED_MAXAGE) continue;
813
814 speed_cnt += device_param->speed_cnt[i];
815 speed_ms += device_param->speed_ms[i];
816 }
817
818 speed_cnt /= SPEED_CACHE;
819 speed_ms /= SPEED_CACHE;
820
821 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
822 }
823
824 /**
825 * exec time
826 */
827
828 fprintf (out, "EXEC_RUNTIME\t");
829
830 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
831 {
832 hc_device_param_t *device_param = &data.devices_param[device_id];
833
834 if (device_param->skipped) continue;
835
836 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
837
838 fprintf (out, "%f\t", exec_ms_avg);
839 }
840
841 /**
842 * words_cur
843 */
844
845 u64 words_cur = get_lowest_words_done ();
846
847 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
848
849 /**
850 * counter
851 */
852
853 u64 progress_total = data.words_cnt * data.salts_cnt;
854
855 u64 all_done = 0;
856 u64 all_rejected = 0;
857 u64 all_restored = 0;
858
859 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
860 {
861 all_done += data.words_progress_done[salt_pos];
862 all_rejected += data.words_progress_rejected[salt_pos];
863 all_restored += data.words_progress_restored[salt_pos];
864 }
865
866 u64 progress_cur = all_restored + all_done + all_rejected;
867 u64 progress_end = progress_total;
868
869 u64 progress_skip = 0;
870
871 if (data.skip)
872 {
873 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
874
875 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
876 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
877 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
878 }
879
880 if (data.limit)
881 {
882 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
883
884 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
885 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
886 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
887 }
888
889 u64 progress_cur_relative_skip = progress_cur - progress_skip;
890 u64 progress_end_relative_skip = progress_end - progress_skip;
891
892 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
893
894 /**
895 * cracks
896 */
897
898 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
899 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
900
901 /**
902 * temperature
903 */
904
905 #ifdef HAVE_HWMON
906 if (data.gpu_temp_disable == 0)
907 {
908 fprintf (out, "TEMP\t");
909
910 hc_thread_mutex_lock (mux_adl);
911
912 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
913 {
914 hc_device_param_t *device_param = &data.devices_param[device_id];
915
916 if (device_param->skipped) continue;
917
918 int temp = hm_get_temperature_with_device_id (device_id);
919
920 fprintf (out, "%d\t", temp);
921 }
922
923 hc_thread_mutex_unlock (mux_adl);
924 }
925 #endif // HAVE_HWMON
926
927 /**
928 * flush
929 */
930
931 #ifdef _WIN
932 fputc ('\r', out);
933 fputc ('\n', out);
934 #endif
935
936 #ifdef _POSIX
937 fputc ('\n', out);
938 #endif
939
940 fflush (out);
941 }
942
943 void status_display ()
944 {
945 if (data.devices_status == STATUS_INIT) return;
946 if (data.devices_status == STATUS_STARTING) return;
947 if (data.devices_status == STATUS_BYPASS) return;
948
949 if (data.status_automat == 1)
950 {
951 status_display_automat ();
952
953 return;
954 }
955
956 char tmp_buf[1000] = { 0 };
957
958 uint tmp_len = 0;
959
960 log_info ("Session.Name...: %s", data.session);
961
962 char *status_type = strstatus (data.devices_status);
963
964 uint hash_mode = data.hash_mode;
965
966 char *hash_type = strhashtype (hash_mode); // not a bug
967
968 log_info ("Status.........: %s", status_type);
969
970 /**
971 * show rules
972 */
973
974 if (data.rp_files_cnt)
975 {
976 uint i;
977
978 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
979 {
980 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
981 }
982
983 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
984
985 log_info ("Rules.Type.....: %s", tmp_buf);
986
987 tmp_len = 0;
988 }
989
990 if (data.rp_gen)
991 {
992 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
993
994 if (data.rp_gen_seed)
995 {
996 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
997 }
998 }
999
1000 /**
1001 * show input
1002 */
1003
1004 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1005 {
1006 if (data.wordlist_mode == WL_MODE_FILE)
1007 {
1008 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1009 }
1010 else if (data.wordlist_mode == WL_MODE_STDIN)
1011 {
1012 log_info ("Input.Mode.....: Pipe");
1013 }
1014 }
1015 else if (data.attack_mode == ATTACK_MODE_COMBI)
1016 {
1017 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1018 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1019 }
1020 else if (data.attack_mode == ATTACK_MODE_BF)
1021 {
1022 char *mask = data.mask;
1023
1024 if (mask != NULL)
1025 {
1026 uint mask_len = data.css_cnt;
1027
1028 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1029
1030 if (mask_len > 0)
1031 {
1032 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1033 {
1034 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1035 {
1036 mask_len -= data.salts_buf[0].salt_len;
1037 }
1038 }
1039
1040 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1041
1042 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1043 }
1044
1045 if (data.maskcnt > 1)
1046 {
1047 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1048
1049 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1050 }
1051
1052 log_info ("Input.Mode.....: %s", tmp_buf);
1053 }
1054
1055 tmp_len = 0;
1056 }
1057 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1058 {
1059 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1060 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1061 }
1062 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1063 {
1064 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1065 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1066 }
1067
1068 if (data.digests_cnt == 1)
1069 {
1070 if (data.hash_mode == 2500)
1071 {
1072 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1073
1074 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1075 (char *) data.salts_buf[0].salt_buf,
1076 wpa->orig_mac1[0],
1077 wpa->orig_mac1[1],
1078 wpa->orig_mac1[2],
1079 wpa->orig_mac1[3],
1080 wpa->orig_mac1[4],
1081 wpa->orig_mac1[5],
1082 wpa->orig_mac2[0],
1083 wpa->orig_mac2[1],
1084 wpa->orig_mac2[2],
1085 wpa->orig_mac2[3],
1086 wpa->orig_mac2[4],
1087 wpa->orig_mac2[5]);
1088 }
1089 else if (data.hash_mode == 5200)
1090 {
1091 log_info ("Hash.Target....: File (%s)", data.hashfile);
1092 }
1093 else if (data.hash_mode == 9000)
1094 {
1095 log_info ("Hash.Target....: File (%s)", data.hashfile);
1096 }
1097 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1098 {
1099 log_info ("Hash.Target....: File (%s)", data.hashfile);
1100 }
1101 else
1102 {
1103 char out_buf[HCBUFSIZ] = { 0 };
1104
1105 ascii_digest (out_buf, 0, 0);
1106
1107 // limit length
1108 if (strlen (out_buf) > 40)
1109 {
1110 out_buf[41] = '.';
1111 out_buf[42] = '.';
1112 out_buf[43] = '.';
1113 out_buf[44] = 0;
1114 }
1115
1116 log_info ("Hash.Target....: %s", out_buf);
1117 }
1118 }
1119 else
1120 {
1121 if (data.hash_mode == 3000)
1122 {
1123 char out_buf1[32] = { 0 };
1124 char out_buf2[32] = { 0 };
1125
1126 ascii_digest (out_buf1, 0, 0);
1127 ascii_digest (out_buf2, 0, 1);
1128
1129 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1130 }
1131 else
1132 {
1133 log_info ("Hash.Target....: File (%s)", data.hashfile);
1134 }
1135 }
1136
1137 log_info ("Hash.Type......: %s", hash_type);
1138
1139 /**
1140 * speed new
1141 */
1142
1143 u64 speed_cnt[DEVICES_MAX] = { 0 };
1144 float speed_ms[DEVICES_MAX] = { 0 };
1145
1146 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1147 {
1148 hc_device_param_t *device_param = &data.devices_param[device_id];
1149
1150 if (device_param->skipped) continue;
1151
1152 // we need to clear values (set to 0) because in case the device does
1153 // not get new candidates it idles around but speed display would
1154 // show it as working.
1155 // if we instantly set it to 0 after reading it happens that the
1156 // speed can be shown as zero if the users refreshes too fast.
1157 // therefore, we add a timestamp when a stat was recorded and if its
1158 // too old we will not use it
1159
1160 speed_cnt[device_id] = 0;
1161 speed_ms[device_id] = 0;
1162
1163 for (int i = 0; i < SPEED_CACHE; i++)
1164 {
1165 float rec_ms;
1166
1167 hc_timer_get (device_param->speed_rec[i], rec_ms);
1168
1169 if (rec_ms > SPEED_MAXAGE) continue;
1170
1171 speed_cnt[device_id] += device_param->speed_cnt[i];
1172 speed_ms[device_id] += device_param->speed_ms[i];
1173 }
1174
1175 speed_cnt[device_id] /= SPEED_CACHE;
1176 speed_ms[device_id] /= SPEED_CACHE;
1177 }
1178
1179 float hashes_all_ms = 0;
1180
1181 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1182
1183 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1184 {
1185 hc_device_param_t *device_param = &data.devices_param[device_id];
1186
1187 if (device_param->skipped) continue;
1188
1189 hashes_dev_ms[device_id] = 0;
1190
1191 if (speed_ms[device_id])
1192 {
1193 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1194
1195 hashes_all_ms += hashes_dev_ms[device_id];
1196 }
1197 }
1198
1199 /**
1200 * exec time
1201 */
1202
1203 double exec_all_ms[DEVICES_MAX] = { 0 };
1204
1205 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1206 {
1207 hc_device_param_t *device_param = &data.devices_param[device_id];
1208
1209 if (device_param->skipped) continue;
1210
1211 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1212
1213 exec_all_ms[device_id] = exec_ms_avg;
1214 }
1215
1216 /**
1217 * timers
1218 */
1219
1220 float ms_running = 0;
1221
1222 hc_timer_get (data.timer_running, ms_running);
1223
1224 float ms_paused = data.ms_paused;
1225
1226 if (data.devices_status == STATUS_PAUSED)
1227 {
1228 float ms_paused_tmp = 0;
1229
1230 hc_timer_get (data.timer_paused, ms_paused_tmp);
1231
1232 ms_paused += ms_paused_tmp;
1233 }
1234
1235 #ifdef WIN
1236
1237 __time64_t sec_run = ms_running / 1000;
1238
1239 #else
1240
1241 time_t sec_run = ms_running / 1000;
1242
1243 #endif
1244
1245 if (sec_run)
1246 {
1247 char display_run[32] = { 0 };
1248
1249 struct tm tm_run;
1250
1251 struct tm *tmp = NULL;
1252
1253 #ifdef WIN
1254
1255 tmp = _gmtime64 (&sec_run);
1256
1257 #else
1258
1259 tmp = gmtime (&sec_run);
1260
1261 #endif
1262
1263 if (tmp != NULL)
1264 {
1265 memset (&tm_run, 0, sizeof (tm_run));
1266
1267 memcpy (&tm_run, tmp, sizeof (tm_run));
1268
1269 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1270
1271 char *start = ctime (&data.proc_start);
1272
1273 size_t start_len = strlen (start);
1274
1275 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1276 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1277
1278 log_info ("Time.Started...: %s (%s)", start, display_run);
1279 }
1280 }
1281 else
1282 {
1283 log_info ("Time.Started...: 0 secs");
1284 }
1285
1286 /**
1287 * counters
1288 */
1289
1290 u64 progress_total = data.words_cnt * data.salts_cnt;
1291
1292 u64 all_done = 0;
1293 u64 all_rejected = 0;
1294 u64 all_restored = 0;
1295
1296 u64 progress_noneed = 0;
1297
1298 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1299 {
1300 all_done += data.words_progress_done[salt_pos];
1301 all_rejected += data.words_progress_rejected[salt_pos];
1302 all_restored += data.words_progress_restored[salt_pos];
1303
1304 // Important for ETA only
1305
1306 if (data.salts_shown[salt_pos] == 1)
1307 {
1308 const u64 all = data.words_progress_done[salt_pos]
1309 + data.words_progress_rejected[salt_pos]
1310 + data.words_progress_restored[salt_pos];
1311
1312 const u64 left = data.words_cnt - all;
1313
1314 progress_noneed += left;
1315 }
1316 }
1317
1318 u64 progress_cur = all_restored + all_done + all_rejected;
1319 u64 progress_end = progress_total;
1320
1321 u64 progress_skip = 0;
1322
1323 if (data.skip)
1324 {
1325 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1326
1327 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1328 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1329 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1330 }
1331
1332 if (data.limit)
1333 {
1334 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1335
1336 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1337 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1338 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1339 }
1340
1341 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1342 u64 progress_end_relative_skip = progress_end - progress_skip;
1343
1344 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1345 {
1346 if (data.devices_status != STATUS_CRACKED)
1347 {
1348 #ifdef WIN
1349 __time64_t sec_etc = 0;
1350 #else
1351 time_t sec_etc = 0;
1352 #endif
1353
1354 if (hashes_all_ms)
1355 {
1356 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1357
1358 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1359
1360 sec_etc = ms_left / 1000;
1361 }
1362
1363 if (sec_etc == 0)
1364 {
1365 //log_info ("Time.Estimated.: 0 secs");
1366 }
1367 else if ((u64) sec_etc > ETC_MAX)
1368 {
1369 log_info ("Time.Estimated.: > 10 Years");
1370 }
1371 else
1372 {
1373 char display_etc[32] = { 0 };
1374
1375 struct tm tm_etc;
1376
1377 struct tm *tmp = NULL;
1378
1379 #ifdef WIN
1380
1381 tmp = _gmtime64 (&sec_etc);
1382
1383 #else
1384
1385 tmp = gmtime (&sec_etc);
1386
1387 #endif
1388
1389 if (tmp != NULL)
1390 {
1391 memset (&tm_etc, 0, sizeof (tm_etc));
1392
1393 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1394
1395 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1396
1397 time_t now;
1398
1399 time (&now);
1400
1401 now += sec_etc;
1402
1403 char *etc = ctime (&now);
1404
1405 size_t etc_len = strlen (etc);
1406
1407 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1408 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1409
1410 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1411 }
1412 }
1413 }
1414 }
1415
1416 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1417 {
1418 hc_device_param_t *device_param = &data.devices_param[device_id];
1419
1420 if (device_param->skipped) continue;
1421
1422 char display_dev_cur[16] = { 0 };
1423
1424 strncpy (display_dev_cur, "0.00", 4);
1425
1426 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1427
1428 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1429 }
1430
1431 char display_all_cur[16] = { 0 };
1432
1433 strncpy (display_all_cur, "0.00", 4);
1434
1435 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1436
1437 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1438
1439 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1440 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1441
1442 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);
1443
1444 // crack-per-time
1445
1446 if (data.digests_cnt > 100)
1447 {
1448 time_t now = time (NULL);
1449
1450 int cpt_cur_min = 0;
1451 int cpt_cur_hour = 0;
1452 int cpt_cur_day = 0;
1453
1454 for (int i = 0; i < CPT_BUF; i++)
1455 {
1456 const uint cracked = data.cpt_buf[i].cracked;
1457 const time_t timestamp = data.cpt_buf[i].timestamp;
1458
1459 if ((timestamp + 60) > now)
1460 {
1461 cpt_cur_min += cracked;
1462 }
1463
1464 if ((timestamp + 3600) > now)
1465 {
1466 cpt_cur_hour += cracked;
1467 }
1468
1469 if ((timestamp + 86400) > now)
1470 {
1471 cpt_cur_day += cracked;
1472 }
1473 }
1474
1475 float ms_real = ms_running - ms_paused;
1476
1477 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1478 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1479 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1480
1481 if ((data.cpt_start + 86400) < now)
1482 {
1483 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1484 cpt_cur_min,
1485 cpt_cur_hour,
1486 cpt_cur_day,
1487 cpt_avg_min,
1488 cpt_avg_hour,
1489 cpt_avg_day);
1490 }
1491 else if ((data.cpt_start + 3600) < now)
1492 {
1493 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1494 cpt_cur_min,
1495 cpt_cur_hour,
1496 cpt_avg_min,
1497 cpt_avg_hour,
1498 cpt_avg_day);
1499 }
1500 else if ((data.cpt_start + 60) < now)
1501 {
1502 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1503 cpt_cur_min,
1504 cpt_avg_min,
1505 cpt_avg_hour,
1506 cpt_avg_day);
1507 }
1508 else
1509 {
1510 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1511 cpt_avg_min,
1512 cpt_avg_hour,
1513 cpt_avg_day);
1514 }
1515 }
1516
1517 // Restore point
1518
1519 u64 restore_point = get_lowest_words_done ();
1520
1521 u64 restore_total = data.words_base;
1522
1523 float percent_restore = 0;
1524
1525 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1526
1527 if (progress_end_relative_skip)
1528 {
1529 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1530 {
1531 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1532 float percent_rejected = 0.0;
1533
1534 if (progress_cur)
1535 {
1536 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1537 }
1538
1539 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);
1540 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1541
1542 if (data.restore_disable == 0)
1543 {
1544 if (percent_finished != 1)
1545 {
1546 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1547 }
1548 }
1549 }
1550 }
1551 else
1552 {
1553 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1554 {
1555 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1556 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1557
1558 if (data.restore_disable == 0)
1559 {
1560 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1561 }
1562 }
1563 else
1564 {
1565 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1566 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1567
1568 // --restore not allowed if stdin is used -- really? why?
1569
1570 //if (data.restore_disable == 0)
1571 //{
1572 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1573 //}
1574 }
1575 }
1576
1577 #ifdef HAVE_HWMON
1578 if (data.gpu_temp_disable == 0)
1579 {
1580 hc_thread_mutex_lock (mux_adl);
1581
1582 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1583 {
1584 hc_device_param_t *device_param = &data.devices_param[device_id];
1585
1586 if (device_param->skipped) continue;
1587
1588 #define HM_STR_BUF_SIZE 255
1589
1590 if (data.hm_device[device_id].fan_supported == 1)
1591 {
1592 char utilization[HM_STR_BUF_SIZE] = { 0 };
1593 char temperature[HM_STR_BUF_SIZE] = { 0 };
1594 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1595
1596 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1597 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1598
1599 if (device_param->vendor_id == VENDOR_ID_AMD)
1600 {
1601 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1602 }
1603 else if (device_param->vendor_id == VENDOR_ID_NV)
1604 {
1605 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1606 }
1607
1608 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1609 }
1610 else
1611 {
1612 char utilization[HM_STR_BUF_SIZE] = { 0 };
1613 char temperature[HM_STR_BUF_SIZE] = { 0 };
1614
1615 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1616 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1617
1618 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1619 }
1620 }
1621
1622 hc_thread_mutex_unlock (mux_adl);
1623 }
1624 #endif // HAVE_HWMON
1625 }
1626
1627 static void status_benchmark ()
1628 {
1629 if (data.devices_status == STATUS_INIT) return;
1630 if (data.devices_status == STATUS_STARTING) return;
1631
1632 if (data.words_cnt == 0) return;
1633
1634 u64 speed_cnt[DEVICES_MAX] = { 0 };
1635 float speed_ms[DEVICES_MAX] = { 0 };
1636
1637 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1638 {
1639 hc_device_param_t *device_param = &data.devices_param[device_id];
1640
1641 if (device_param->skipped) continue;
1642
1643 speed_cnt[device_id] = 0;
1644 speed_ms[device_id] = 0;
1645
1646 for (int i = 0; i < SPEED_CACHE; i++)
1647 {
1648 speed_cnt[device_id] += device_param->speed_cnt[i];
1649 speed_ms[device_id] += device_param->speed_ms[i];
1650 }
1651
1652 speed_cnt[device_id] /= SPEED_CACHE;
1653 speed_ms[device_id] /= SPEED_CACHE;
1654 }
1655
1656 float hashes_all_ms = 0;
1657
1658 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1659
1660 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1661 {
1662 hc_device_param_t *device_param = &data.devices_param[device_id];
1663
1664 if (device_param->skipped) continue;
1665
1666 hashes_dev_ms[device_id] = 0;
1667
1668 if (speed_ms[device_id])
1669 {
1670 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1671
1672 hashes_all_ms += hashes_dev_ms[device_id];
1673 }
1674 }
1675
1676 /**
1677 * exec time
1678 */
1679
1680 double exec_all_ms[DEVICES_MAX] = { 0 };
1681
1682 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1683 {
1684 hc_device_param_t *device_param = &data.devices_param[device_id];
1685
1686 if (device_param->skipped) continue;
1687
1688 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1689
1690 exec_all_ms[device_id] = exec_ms_avg;
1691 }
1692
1693 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1694 {
1695 hc_device_param_t *device_param = &data.devices_param[device_id];
1696
1697 if (device_param->skipped) continue;
1698
1699 char display_dev_cur[16] = { 0 };
1700
1701 strncpy (display_dev_cur, "0.00", 4);
1702
1703 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1704
1705 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1706 }
1707
1708 char display_all_cur[16] = { 0 };
1709
1710 strncpy (display_all_cur, "0.00", 4);
1711
1712 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1713
1714 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1715 }
1716
1717 /**
1718 * oclHashcat -only- functions
1719 */
1720
1721 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1722 {
1723 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1724 {
1725 if (attack_kern == ATTACK_KERN_STRAIGHT)
1726 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1727 else if (attack_kern == ATTACK_KERN_COMBI)
1728 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1729 else if (attack_kern == ATTACK_KERN_BF)
1730 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1731 }
1732 else
1733 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1734 }
1735
1736 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)
1737 {
1738 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1739 {
1740 if (attack_kern == ATTACK_KERN_STRAIGHT)
1741 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1742 else if (attack_kern == ATTACK_KERN_COMBI)
1743 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1744 else if (attack_kern == ATTACK_KERN_BF)
1745 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1746 }
1747 else
1748 {
1749 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1750 }
1751 }
1752
1753 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1754 {
1755 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1756 {
1757 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1758 }
1759 else
1760 {
1761 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1762 }
1763 }
1764
1765 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)
1766 {
1767 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1768 {
1769 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1770 }
1771 else
1772 {
1773 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1774 }
1775 }
1776
1777 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1778 {
1779 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1780 }
1781
1782 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1783 {
1784 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1785 }
1786
1787 static uint convert_from_hex (char *line_buf, const uint line_len)
1788 {
1789 if (line_len & 1) return (line_len); // not in hex
1790
1791 if (data.hex_wordlist == 1)
1792 {
1793 uint i;
1794 uint j;
1795
1796 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1797 {
1798 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1799 }
1800
1801 memset (line_buf + i, 0, line_len - i);
1802
1803 return (i);
1804 }
1805 else if (line_len >= 6) // $HEX[] = 6
1806 {
1807 if (line_buf[0] != '$') return (line_len);
1808 if (line_buf[1] != 'H') return (line_len);
1809 if (line_buf[2] != 'E') return (line_len);
1810 if (line_buf[3] != 'X') return (line_len);
1811 if (line_buf[4] != '[') return (line_len);
1812 if (line_buf[line_len - 1] != ']') return (line_len);
1813
1814 uint i;
1815 uint j;
1816
1817 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1818 {
1819 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1820 }
1821
1822 memset (line_buf + i, 0, line_len - i);
1823
1824 return (i);
1825 }
1826
1827 return (line_len);
1828 }
1829
1830 static void clear_prompt ()
1831 {
1832 fputc ('\r', stdout);
1833
1834 for (size_t i = 0; i < strlen (PROMPT); i++)
1835 {
1836 fputc (' ', stdout);
1837 }
1838
1839 fputc ('\r', stdout);
1840
1841 fflush (stdout);
1842 }
1843
1844 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1845 {
1846 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);
1847 }
1848
1849 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1850 {
1851 char *outfile = data.outfile;
1852 uint quiet = data.quiet;
1853 FILE *pot_fp = data.pot_fp;
1854 uint loopback = data.loopback;
1855 uint debug_mode = data.debug_mode;
1856 char *debug_file = data.debug_file;
1857
1858 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1859 int debug_rule_len = 0; // -1 error
1860 uint debug_plain_len = 0;
1861
1862 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1863
1864 // hash
1865
1866 char out_buf[HCBUFSIZ] = { 0 };
1867
1868 ascii_digest (out_buf, salt_pos, digest_pos);
1869
1870 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1871
1872 // plain
1873
1874 plain_t plain;
1875
1876 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);
1877
1878 uint gidvid = plain.gidvid;
1879 uint il_pos = plain.il_pos;
1880
1881 u64 crackpos = device_param->words_off;
1882
1883 uint plain_buf[16] = { 0 };
1884
1885 u8 *plain_ptr = (u8 *) plain_buf;
1886 unsigned int plain_len = 0;
1887
1888 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1889 {
1890 u64 gidd = gidvid;
1891 u64 gidm = 0;
1892
1893 pw_t pw;
1894
1895 gidd_to_pw_t (device_param, gidd, &pw);
1896
1897 for (int i = 0, j = gidm; i < 16; i++, j++)
1898 {
1899 plain_buf[i] = pw.i[j];
1900 }
1901
1902 plain_len = pw.pw_len;
1903
1904 const uint off = device_param->innerloop_pos + il_pos;
1905
1906 if (debug_mode > 0)
1907 {
1908 debug_rule_len = 0;
1909
1910 // save rule
1911 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1912 {
1913 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1914
1915 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1916 }
1917
1918 // save plain
1919 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1920 {
1921 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1922
1923 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1924
1925 debug_plain_len = plain_len;
1926 }
1927 }
1928
1929 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1930
1931 crackpos += gidvid;
1932 crackpos *= data.kernel_rules_cnt;
1933 crackpos += device_param->innerloop_pos + il_pos;
1934
1935 if (plain_len > data.pw_max) plain_len = data.pw_max;
1936 }
1937 else if (data.attack_mode == ATTACK_MODE_COMBI)
1938 {
1939 u64 gidd = gidvid;
1940 u64 gidm = 0;
1941
1942 pw_t pw;
1943
1944 gidd_to_pw_t (device_param, gidd, &pw);
1945
1946 for (int i = 0, j = gidm; i < 16; i++, j++)
1947 {
1948 plain_buf[i] = pw.i[j];
1949 }
1950
1951 plain_len = pw.pw_len;
1952
1953 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1954 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1955
1956 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1957 {
1958 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1959 }
1960 else
1961 {
1962 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1963
1964 memcpy (plain_ptr, comb_buf, comb_len);
1965 }
1966
1967 plain_len += comb_len;
1968
1969 crackpos += gidvid;
1970 crackpos *= data.combs_cnt;
1971 crackpos += device_param->innerloop_pos + il_pos;
1972
1973 if (data.pw_max != PW_DICTMAX1)
1974 {
1975 if (plain_len > data.pw_max) plain_len = data.pw_max;
1976 }
1977 }
1978 else if (data.attack_mode == ATTACK_MODE_BF)
1979 {
1980 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1981 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1982
1983 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1984 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1985
1986 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1987 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1988
1989 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1990 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1991
1992 plain_len = data.css_cnt;
1993
1994 crackpos += gidvid;
1995 crackpos *= data.bfs_cnt;
1996 crackpos += device_param->innerloop_pos + il_pos;
1997 }
1998 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1999 {
2000 u64 gidd = gidvid;
2001 u64 gidm = 0;
2002
2003 pw_t pw;
2004
2005 gidd_to_pw_t (device_param, gidd, &pw);
2006
2007 for (int i = 0, j = gidm; i < 16; i++, j++)
2008 {
2009 plain_buf[i] = pw.i[j];
2010 }
2011
2012 plain_len = pw.pw_len;
2013
2014 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2015
2016 uint start = 0;
2017 uint stop = device_param->kernel_params_mp_buf32[4];
2018
2019 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2020
2021 plain_len += start + stop;
2022
2023 crackpos += gidvid;
2024 crackpos *= data.combs_cnt;
2025 crackpos += device_param->innerloop_pos + il_pos;
2026
2027 if (data.pw_max != PW_DICTMAX1)
2028 {
2029 if (plain_len > data.pw_max) plain_len = data.pw_max;
2030 }
2031 }
2032 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2033 {
2034 u64 gidd = gidvid;
2035 u64 gidm = 0;
2036
2037 pw_t pw;
2038
2039 gidd_to_pw_t (device_param, gidd, &pw);
2040
2041 for (int i = 0, j = gidm; i < 16; i++, j++)
2042 {
2043 plain_buf[i] = pw.i[j];
2044 }
2045
2046 plain_len = pw.pw_len;
2047
2048 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2049
2050 uint start = 0;
2051 uint stop = device_param->kernel_params_mp_buf32[4];
2052
2053 memmove (plain_ptr + stop, plain_ptr, plain_len);
2054
2055 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2056
2057 plain_len += start + stop;
2058
2059 crackpos += gidvid;
2060 crackpos *= data.combs_cnt;
2061 crackpos += device_param->innerloop_pos + il_pos;
2062
2063 if (data.pw_max != PW_DICTMAX1)
2064 {
2065 if (plain_len > data.pw_max) plain_len = data.pw_max;
2066 }
2067 }
2068
2069 if (data.attack_mode == ATTACK_MODE_BF)
2070 {
2071 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2072 {
2073 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2074 {
2075 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2076 {
2077 plain_len = plain_len - data.salts_buf[0].salt_len;
2078 }
2079 }
2080
2081 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2082 {
2083 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2084 {
2085 plain_ptr[j] = plain_ptr[i];
2086 }
2087
2088 plain_len = plain_len / 2;
2089 }
2090 }
2091 }
2092
2093 // if enabled, update also the potfile
2094
2095 if (pot_fp)
2096 {
2097 lock_file (pot_fp);
2098
2099 fprintf (pot_fp, "%s:", out_buf);
2100
2101 format_plain (pot_fp, plain_ptr, plain_len, 1);
2102
2103 fputc ('\n', pot_fp);
2104
2105 fflush (pot_fp);
2106
2107 unlock_file (pot_fp);
2108 }
2109
2110 // outfile
2111
2112 FILE *out_fp = NULL;
2113
2114 if (outfile != NULL)
2115 {
2116 if ((out_fp = fopen (outfile, "ab")) == NULL)
2117 {
2118 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2119
2120 out_fp = stdout;
2121 }
2122 lock_file (out_fp);
2123 }
2124 else
2125 {
2126 out_fp = stdout;
2127
2128 if (quiet == 0) clear_prompt ();
2129 }
2130
2131 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2132
2133 if (outfile != NULL)
2134 {
2135 if (out_fp != stdout)
2136 {
2137 fclose (out_fp);
2138 }
2139 }
2140 else
2141 {
2142 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2143 {
2144 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2145 {
2146 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2147 if (quiet == 0) fflush (stdout);
2148 }
2149 }
2150 }
2151
2152 // loopback
2153
2154 if (loopback)
2155 {
2156 char *loopback_file = data.loopback_file;
2157
2158 FILE *fb_fp = NULL;
2159
2160 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2161 {
2162 lock_file (fb_fp);
2163
2164 format_plain (fb_fp, plain_ptr, plain_len, 1);
2165
2166 fputc ('\n', fb_fp);
2167
2168 fclose (fb_fp);
2169 }
2170 }
2171
2172 // (rule) debug mode
2173
2174 // the next check implies that:
2175 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2176 // - debug_mode > 0
2177
2178 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2179 {
2180 if (debug_rule_len < 0) debug_rule_len = 0;
2181
2182 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2183
2184 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2185
2186 if ((quiet == 0) && (debug_file == NULL))
2187 {
2188 fprintf (stdout, "%s", PROMPT);
2189 fflush (stdout);
2190 }
2191 }
2192 }
2193
2194 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2195 {
2196 salt_t *salt_buf = &data.salts_buf[salt_pos];
2197
2198 int found = 0;
2199
2200 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);
2201
2202 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2203
2204 if (found == 1)
2205 {
2206 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2207
2208 log_info_nn ("");
2209
2210 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);
2211
2212 uint cpt_cracked = 0;
2213
2214 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2215 {
2216 uint idx = salt_buf->digests_offset + digest_pos;
2217
2218 if (data.digests_shown_tmp[idx] == 0) continue;
2219
2220 if (data.digests_shown[idx] == 1) continue;
2221
2222 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2223 {
2224 data.digests_shown[idx] = 1;
2225
2226 data.digests_done++;
2227
2228 cpt_cracked++;
2229
2230 salt_buf->digests_done++;
2231
2232 if (salt_buf->digests_done == salt_buf->digests_cnt)
2233 {
2234 data.salts_shown[salt_pos] = 1;
2235
2236 data.salts_done++;
2237 }
2238 }
2239
2240 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2241
2242 check_hash (device_param, salt_pos, digest_pos);
2243 }
2244
2245 if (cpt_cracked > 0)
2246 {
2247 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2248 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2249
2250 data.cpt_pos++;
2251
2252 data.cpt_total += cpt_cracked;
2253
2254 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2255 }
2256
2257 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2258 {
2259 // we need to reset cracked state on the device
2260 // otherwise host thinks again and again the hash was cracked
2261 // and returns invalid password each time
2262
2263 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2264
2265 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);
2266 }
2267
2268 memset (device_param->result, 0, device_param->size_results);
2269
2270 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);
2271 }
2272 }
2273
2274 static void save_hash ()
2275 {
2276 char *hashfile = data.hashfile;
2277
2278 char new_hashfile[256] = { 0 };
2279 char old_hashfile[256] = { 0 };
2280
2281 snprintf (new_hashfile, 255, "%s.new", hashfile);
2282 snprintf (old_hashfile, 255, "%s.old", hashfile);
2283
2284 unlink (new_hashfile);
2285
2286 char separator = data.separator;
2287
2288 FILE *fp = fopen (new_hashfile, "wb");
2289
2290 if (fp == NULL)
2291 {
2292 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2293
2294 exit (-1);
2295 }
2296
2297 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2298 {
2299 if (data.salts_shown[salt_pos] == 1) continue;
2300
2301 salt_t *salt_buf = &data.salts_buf[salt_pos];
2302
2303 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2304 {
2305 uint idx = salt_buf->digests_offset + digest_pos;
2306
2307 if (data.digests_shown[idx] == 1) continue;
2308
2309 if (data.hash_mode != 2500)
2310 {
2311 char out_buf[HCBUFSIZ] = { 0 };
2312
2313 if (data.username == 1)
2314 {
2315 user_t *user = data.hash_info[idx]->user;
2316
2317 uint i;
2318
2319 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2320
2321 fputc (separator, fp);
2322 }
2323
2324 ascii_digest (out_buf, salt_pos, digest_pos);
2325
2326 fputs (out_buf, fp);
2327
2328 log_out (fp, "");
2329 }
2330 else
2331 {
2332 hccap_t hccap;
2333
2334 to_hccap_t (&hccap, salt_pos, digest_pos);
2335
2336 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2337 }
2338 }
2339 }
2340
2341 fflush (fp);
2342
2343 fclose (fp);
2344
2345 unlink (old_hashfile);
2346
2347 if (rename (hashfile, old_hashfile) != 0)
2348 {
2349 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2350
2351 exit (-1);
2352 }
2353
2354 unlink (hashfile);
2355
2356 if (rename (new_hashfile, hashfile) != 0)
2357 {
2358 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2359
2360 exit (-1);
2361 }
2362
2363 unlink (old_hashfile);
2364 }
2365
2366 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2367 {
2368 // function called only in case kernel_power_all > words_left
2369
2370 float kernel_power_div = (float) (total_left) / kernel_power_all;
2371
2372 kernel_power_div += kernel_power_div / 100;
2373
2374 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2375
2376 while (kernel_power_new < total_left)
2377 {
2378 kernel_power_div += kernel_power_div / 100;
2379
2380 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2381 }
2382
2383 if (data.quiet == 0)
2384 {
2385 clear_prompt ();
2386
2387 log_info ("");
2388
2389 log_info ("INFO: approaching final keyspace, workload adjusted");
2390
2391 log_info ("");
2392
2393 fprintf (stdout, "%s", PROMPT);
2394
2395 fflush (stdout);
2396 }
2397
2398 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2399
2400 return kernel_power_div;
2401 }
2402
2403 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2404 {
2405 uint num_elements = num;
2406
2407 device_param->kernel_params_buf32[30] = data.combs_mode;
2408 device_param->kernel_params_buf32[31] = num;
2409
2410 uint kernel_threads = device_param->kernel_threads;
2411
2412 while (num_elements % kernel_threads) num_elements++;
2413
2414 cl_kernel kernel = NULL;
2415
2416 switch (kern_run)
2417 {
2418 case KERN_RUN_1: kernel = device_param->kernel1; break;
2419 case KERN_RUN_12: kernel = device_param->kernel12; break;
2420 case KERN_RUN_2: kernel = device_param->kernel2; break;
2421 case KERN_RUN_23: kernel = device_param->kernel23; break;
2422 case KERN_RUN_3: kernel = device_param->kernel3; break;
2423 }
2424
2425 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2426 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2427 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2428 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2429 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2430 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2431 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2432 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2433 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2434 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2435 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2436
2437 hc_timer_t timer;
2438
2439 hc_timer_set (&timer);
2440
2441 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2442 {
2443 const size_t global_work_size[3] = { num_elements, 32, 1 };
2444 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2445
2446 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2447 }
2448 else
2449 {
2450 size_t workgroup_size = 0;
2451
2452 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2453
2454 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2455
2456 const size_t global_work_size[3] = { num_elements, 1, 1 };
2457 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2458
2459 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2460 }
2461
2462 hc_clFlush (data.ocl, device_param->command_queue);
2463
2464 hc_clFinish (data.ocl, device_param->command_queue);
2465
2466 if (event_update)
2467 {
2468 float exec_time;
2469
2470 hc_timer_get (timer, exec_time);
2471
2472 uint exec_pos = device_param->exec_pos;
2473
2474 device_param->exec_ms[exec_pos] = exec_time;
2475
2476 exec_pos++;
2477
2478 if (exec_pos == EXEC_CACHE)
2479 {
2480 exec_pos = 0;
2481 }
2482
2483 device_param->exec_pos = exec_pos;
2484 }
2485 }
2486
2487 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2488 {
2489 uint num_elements = num;
2490
2491 switch (kern_run)
2492 {
2493 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2494 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2495 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2496 }
2497
2498 // causes problems with special threads like in bcrypt
2499 // const uint kernel_threads = device_param->kernel_threads;
2500
2501 uint kernel_threads = KERNEL_THREADS;
2502
2503 while (num_elements % kernel_threads) num_elements++;
2504
2505 cl_kernel kernel = NULL;
2506
2507 switch (kern_run)
2508 {
2509 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2510 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2511 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2512 }
2513
2514 switch (kern_run)
2515 {
2516 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2517 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2518 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2519 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2520 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2521 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2522 break;
2523 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2524 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2525 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2526 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2527 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2528 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2529 break;
2530 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2531 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2532 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2533 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2534 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2535 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2536 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2537 break;
2538 }
2539
2540 size_t workgroup_size = 0;
2541 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
2542 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2543
2544 const size_t global_work_size[3] = { num_elements, 1, 1 };
2545 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2546
2547 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2548
2549 hc_clFlush (data.ocl, device_param->command_queue);
2550
2551 hc_clFinish (data.ocl, device_param->command_queue);
2552 }
2553
2554 static void run_kernel_tm (hc_device_param_t *device_param)
2555 {
2556 const uint num_elements = 1024; // fixed
2557
2558 uint kernel_threads = 32;
2559
2560 cl_kernel kernel = device_param->kernel_tm;
2561
2562 size_t workgroup_size = 0;
2563 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2564 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2565
2566 const size_t global_work_size[3] = { num_elements, 1, 1 };
2567 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2568
2569 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2570
2571 hc_clFlush (data.ocl, device_param->command_queue);
2572
2573 hc_clFinish (data.ocl, device_param->command_queue);
2574 }
2575
2576 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2577 {
2578 uint num_elements = num;
2579
2580 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2581 device_param->kernel_params_amp_buf32[6] = num_elements;
2582
2583 // causes problems with special threads like in bcrypt
2584 // const uint kernel_threads = device_param->kernel_threads;
2585
2586 uint kernel_threads = KERNEL_THREADS;
2587
2588 while (num_elements % kernel_threads) num_elements++;
2589
2590 cl_kernel kernel = device_param->kernel_amp;
2591
2592 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2593 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2594
2595 size_t workgroup_size = 0;
2596 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2597 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2598
2599 const size_t global_work_size[3] = { num_elements, 1, 1 };
2600 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2601
2602 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2603
2604 hc_clFlush (data.ocl, device_param->command_queue);
2605
2606 hc_clFinish (data.ocl, device_param->command_queue);
2607 }
2608
2609 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2610 {
2611 int rc = -1;
2612
2613 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2614 {
2615 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2616
2617 const cl_uchar zero = 0;
2618
2619 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2620 }
2621
2622 if (rc != 0)
2623 {
2624 // NOTE: clEnqueueFillBuffer () always fails with -59
2625 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2626 // How's that possible, OpenCL 1.2 support is advertised??
2627 // We need to workaround...
2628
2629 #define FILLSZ 0x100000
2630
2631 char *tmp = (char *) mymalloc (FILLSZ);
2632
2633 for (uint i = 0; i < size; i += FILLSZ)
2634 {
2635 const int left = size - i;
2636
2637 const int fillsz = MIN (FILLSZ, left);
2638
2639 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2640 }
2641
2642 myfree (tmp);
2643 }
2644 }
2645
2646 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)
2647 {
2648 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2649 {
2650 if (attack_mode == ATTACK_MODE_BF)
2651 {
2652 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2653 {
2654 const uint size_tm = 32 * sizeof (bs_word_t);
2655
2656 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2657
2658 run_kernel_tm (device_param);
2659
2660 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);
2661 }
2662 }
2663
2664 if (highest_pw_len < 16)
2665 {
2666 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2667 }
2668 else if (highest_pw_len < 32)
2669 {
2670 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2671 }
2672 else
2673 {
2674 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2675 }
2676 }
2677 else
2678 {
2679 run_kernel_amp (device_param, pws_cnt);
2680
2681 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2682
2683 if (opts_type & OPTS_TYPE_HOOK12)
2684 {
2685 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2686 }
2687
2688 uint iter = salt_buf->salt_iter;
2689
2690 uint loop_step = device_param->kernel_loops;
2691
2692 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2693 {
2694 uint loop_left = iter - loop_pos;
2695
2696 loop_left = MIN (loop_left, loop_step);
2697
2698 device_param->kernel_params_buf32[25] = loop_pos;
2699 device_param->kernel_params_buf32[26] = loop_left;
2700
2701 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2702
2703 if (data.devices_status == STATUS_CRACKED) break;
2704 if (data.devices_status == STATUS_ABORTED) break;
2705 if (data.devices_status == STATUS_QUIT) break;
2706 }
2707
2708 if (opts_type & OPTS_TYPE_HOOK23)
2709 {
2710 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2711
2712 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);
2713
2714 // do something with data
2715
2716 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);
2717 }
2718
2719 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2720 }
2721 }
2722
2723 static int run_rule_engine (const int rule_len, const char *rule_buf)
2724 {
2725 if (rule_len == 0)
2726 {
2727 return 0;
2728 }
2729 else if (rule_len == 1)
2730 {
2731 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2732 }
2733
2734 return 1;
2735 }
2736
2737 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2738 {
2739 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2740 {
2741 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);
2742 }
2743 else if (data.attack_kern == ATTACK_KERN_COMBI)
2744 {
2745 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2746 {
2747 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2748 {
2749 for (u32 i = 0; i < pws_cnt; i++)
2750 {
2751 const u32 pw_len = device_param->pws_buf[i].pw_len;
2752
2753 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2754
2755 ptr[pw_len] = 0x01;
2756 }
2757 }
2758 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2759 {
2760 for (u32 i = 0; i < pws_cnt; i++)
2761 {
2762 const u32 pw_len = device_param->pws_buf[i].pw_len;
2763
2764 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2765
2766 ptr[pw_len] = 0x80;
2767 }
2768 }
2769 }
2770
2771 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);
2772 }
2773 else if (data.attack_kern == ATTACK_KERN_BF)
2774 {
2775 const u64 off = device_param->words_off;
2776
2777 device_param->kernel_params_mp_l_buf64[3] = off;
2778
2779 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2780 }
2781 }
2782
2783 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops, const int repeat)
2784 {
2785 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2786
2787 device_param->kernel_params_buf32[26] = kernel_loops;
2788 device_param->kernel_params_buf32[27] = kernel_loops;
2789
2790 // init some fake words
2791
2792 for (u32 i = 0; i < kernel_power; i++)
2793 {
2794 device_param->pws_buf[i].i[0] = i;
2795 device_param->pws_buf[i].i[1] = 0x01234567;
2796 device_param->pws_buf[i].pw_len = 4 + (i & 3);
2797 }
2798
2799 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);
2800
2801 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2802 {
2803 run_kernel_amp (device_param, kernel_power);
2804 }
2805
2806 // caching run
2807
2808 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2809 {
2810 run_kernel (KERN_RUN_1, device_param, kernel_power, false);
2811 }
2812 else
2813 {
2814 run_kernel (KERN_RUN_2, device_param, kernel_power, false);
2815 }
2816
2817 // now user repeats
2818
2819 for (int i = 0; i < repeat; i++)
2820 {
2821 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2822 {
2823 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2824 }
2825 else
2826 {
2827 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2828 }
2829 }
2830
2831 const double exec_ms_prev = get_avg_exec_time (device_param, repeat);
2832
2833 // reset fake words
2834
2835 memset (device_param->pws_buf, 0, kernel_power * sizeof (pw_t));
2836
2837 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);
2838 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);
2839
2840 return exec_ms_prev;
2841 }
2842
2843 static void autotune (hc_device_param_t *device_param)
2844 {
2845 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2846
2847 const u32 kernel_accel_min = device_param->kernel_accel_min;
2848 const u32 kernel_accel_max = device_param->kernel_accel_max;
2849
2850 const u32 kernel_loops_min = device_param->kernel_loops_min;
2851 const u32 kernel_loops_max = device_param->kernel_loops_max;
2852
2853 u32 kernel_accel = kernel_accel_min;
2854 u32 kernel_loops = kernel_loops_min;
2855
2856 // steps
2857
2858 #define STEPS_CNT 10
2859
2860 #define STEPS_ACCEL_CNT (STEPS_CNT + 2)
2861 #define STEPS_LOOPS_CNT (STEPS_CNT + 2)
2862
2863 u32 steps_accel[STEPS_ACCEL_CNT];
2864 u32 steps_loops[STEPS_LOOPS_CNT];
2865
2866 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2867 {
2868 steps_accel[i] = 1 << i;
2869 }
2870
2871 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2872 {
2873 steps_loops[i] = 1 << i;
2874 }
2875
2876 steps_accel[STEPS_CNT + 0] = kernel_accel_min;
2877 steps_accel[STEPS_CNT + 1] = kernel_accel_max;
2878
2879 steps_loops[STEPS_CNT + 0] = kernel_loops_min;
2880 steps_loops[STEPS_CNT + 1] = kernel_loops_max;
2881
2882 qsort (steps_accel, STEPS_ACCEL_CNT, sizeof (u32), sort_by_u32);
2883 qsort (steps_loops, STEPS_LOOPS_CNT, sizeof (u32), sort_by_u32);
2884
2885 // find out highest kernel-loops that stays below target_ms, we can use it later for multiplication as this is a linear function
2886
2887 u32 kernel_loops_tmp;
2888
2889 for (kernel_loops_tmp = kernel_loops_max; kernel_loops_tmp > kernel_loops_min; kernel_loops_tmp >>= 1)
2890 {
2891 const double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops_tmp, 1);
2892
2893 if (exec_ms < target_ms) break;
2894 }
2895
2896 // kernel-accel
2897
2898 if (kernel_accel_min < kernel_accel_max)
2899 {
2900 double e_best = 0;
2901
2902 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2903 {
2904 const u32 kernel_accel_try = steps_accel[i];
2905
2906 if (kernel_accel_try < kernel_accel_min) continue;
2907 if (kernel_accel_try > kernel_accel_max) break;
2908
2909 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_tmp, 1);
2910
2911 if (exec_ms > target_ms) break;
2912
2913 const double e = kernel_accel_try / exec_ms;
2914
2915 if (e > e_best)
2916 {
2917 kernel_accel = kernel_accel_try;
2918
2919 e_best = e;
2920 }
2921 }
2922 }
2923
2924 // kernel-loops final
2925
2926 if (kernel_loops_min < kernel_loops_max)
2927 {
2928 double e_best = 0;
2929
2930 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2931 {
2932 const u32 kernel_loops_try = steps_loops[i];
2933
2934 if (kernel_loops_try < kernel_loops_min) continue;
2935 if (kernel_loops_try > kernel_loops_max) break;
2936
2937 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops_try, 1);
2938
2939 if (exec_ms > target_ms) break;
2940
2941 const double e = kernel_loops_try / exec_ms;
2942
2943 if (e > e_best)
2944 {
2945 kernel_loops = kernel_loops_try;
2946
2947 e_best = e;
2948 }
2949 }
2950 }
2951
2952 // final balance
2953
2954 u32 kernel_accel_best = kernel_accel;
2955 u32 kernel_loops_best = kernel_loops;
2956
2957 u32 exec_best = -1;
2958
2959 if ((kernel_accel_min < kernel_accel_max) || (kernel_loops_min < kernel_loops_max))
2960 {
2961 const double exec_ms = try_run (device_param, kernel_accel_best, kernel_loops_best, 1);
2962
2963 exec_best = exec_ms;
2964 }
2965
2966 // reset
2967
2968 if (kernel_accel_min < kernel_accel_max)
2969 {
2970 u32 kernel_accel_try = kernel_accel;
2971 u32 kernel_loops_try = kernel_loops;
2972
2973 for (int i = 0; i < 2; i++)
2974 {
2975 kernel_accel_try >>= 1;
2976 kernel_loops_try <<= 1;
2977
2978 if (kernel_accel_try < kernel_accel_min) break;
2979 if (kernel_loops_try > kernel_loops_max) break;
2980
2981 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
2982
2983 if (exec_ms < exec_best)
2984 {
2985 kernel_accel_best = kernel_accel_try;
2986 kernel_loops_best = kernel_loops_try;
2987
2988 exec_best = exec_ms;
2989 }
2990 }
2991 }
2992
2993 // reset
2994
2995 if (kernel_loops_min < kernel_loops_max)
2996 {
2997 u32 kernel_accel_try = kernel_accel;
2998 u32 kernel_loops_try = kernel_loops;
2999
3000 for (int i = 0; i < 2; i++)
3001 {
3002 kernel_accel_try <<= 1;
3003 kernel_loops_try >>= 1;
3004
3005 if (kernel_accel_try > kernel_accel_max) break;
3006 if (kernel_loops_try < kernel_loops_min) break;
3007
3008 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
3009
3010 if (exec_ms < exec_best)
3011 {
3012 kernel_accel_best = kernel_accel_try;
3013 kernel_loops_best = kernel_loops_try;
3014
3015 exec_best = exec_ms;
3016 }
3017 }
3018 }
3019
3020 // reset timer
3021
3022 device_param->exec_pos = 0;
3023
3024 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3025
3026 // store
3027
3028 kernel_accel = kernel_accel_best;
3029 kernel_loops = kernel_loops_best;
3030
3031 device_param->kernel_accel = kernel_accel;
3032 device_param->kernel_loops = kernel_loops;
3033
3034 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3035
3036 device_param->kernel_power = kernel_power;
3037
3038 #ifdef DEBUG
3039
3040 if (data.quiet == 0)
3041 {
3042 clear_prompt ();
3043
3044 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3045 "Device #%u: autotuned kernel-loops to %u\n",
3046 device_param->device_id + 1,
3047 kernel_accel,
3048 device_param->device_id + 1,
3049 kernel_loops);
3050
3051 fprintf (stdout, "%s", PROMPT);
3052 fflush (stdout);
3053 }
3054
3055 #endif
3056 }
3057
3058 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3059 {
3060 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3061
3062 // init speed timer
3063
3064 uint speed_pos = device_param->speed_pos;
3065
3066 #ifdef _POSIX
3067 if (device_param->timer_speed.tv_sec == 0)
3068 {
3069 hc_timer_set (&device_param->timer_speed);
3070 }
3071 #endif
3072
3073 #ifdef _WIN
3074 if (device_param->timer_speed.QuadPart == 0)
3075 {
3076 hc_timer_set (&device_param->timer_speed);
3077 }
3078 #endif
3079
3080 // find higest password length, this is for optimization stuff
3081
3082 uint highest_pw_len = 0;
3083
3084 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3085 {
3086 }
3087 else if (data.attack_kern == ATTACK_KERN_COMBI)
3088 {
3089 }
3090 else if (data.attack_kern == ATTACK_KERN_BF)
3091 {
3092 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3093 + device_param->kernel_params_mp_l_buf32[5];
3094 }
3095
3096 // iteration type
3097
3098 uint innerloop_step = 0;
3099 uint innerloop_cnt = 0;
3100
3101 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3102 else innerloop_step = 1;
3103
3104 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3105 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3106 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3107
3108 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3109
3110 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3111 {
3112 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3113
3114 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3115
3116 if (data.devices_status == STATUS_CRACKED) break;
3117 if (data.devices_status == STATUS_ABORTED) break;
3118 if (data.devices_status == STATUS_QUIT) break;
3119 if (data.devices_status == STATUS_BYPASS) break;
3120
3121 salt_t *salt_buf = &data.salts_buf[salt_pos];
3122
3123 device_param->kernel_params_buf32[24] = salt_pos;
3124 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3125 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3126
3127 FILE *combs_fp = device_param->combs_fp;
3128
3129 if (data.attack_mode == ATTACK_MODE_COMBI)
3130 {
3131 rewind (combs_fp);
3132 }
3133
3134 // innerloops
3135
3136 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3137 {
3138 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3139
3140 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3141
3142 if (data.devices_status == STATUS_CRACKED) break;
3143 if (data.devices_status == STATUS_ABORTED) break;
3144 if (data.devices_status == STATUS_QUIT) break;
3145 if (data.devices_status == STATUS_BYPASS) break;
3146
3147 uint innerloop_left = innerloop_cnt - innerloop_pos;
3148
3149 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3150
3151 device_param->innerloop_pos = innerloop_pos;
3152 device_param->innerloop_left = innerloop_left;
3153
3154 device_param->kernel_params_buf32[27] = innerloop_left;
3155
3156 // i think we can get rid of this
3157 if (innerloop_left == 0)
3158 {
3159 puts ("bug, how should this happen????\n");
3160
3161 continue;
3162 }
3163
3164 if (data.salts_shown[salt_pos] == 1)
3165 {
3166 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3167
3168 continue;
3169 }
3170
3171 // initialize amplifiers
3172
3173 if (data.attack_mode == ATTACK_MODE_COMBI)
3174 {
3175 uint i = 0;
3176
3177 while (i < innerloop_left)
3178 {
3179 if (feof (combs_fp)) break;
3180
3181 int line_len = fgetl (combs_fp, line_buf);
3182
3183 if (line_len >= PW_MAX1) continue;
3184
3185 line_len = convert_from_hex (line_buf, line_len);
3186
3187 char *line_buf_new = line_buf;
3188
3189 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3190 {
3191 char rule_buf_out[BLOCK_SIZE] = { 0 };
3192
3193 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3194
3195 if (rule_len_out < 0)
3196 {
3197 data.words_progress_rejected[salt_pos] += pws_cnt;
3198
3199 continue;
3200 }
3201
3202 line_len = rule_len_out;
3203
3204 line_buf_new = rule_buf_out;
3205 }
3206
3207 line_len = MIN (line_len, PW_DICTMAX);
3208
3209 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3210
3211 memcpy (ptr, line_buf_new, line_len);
3212
3213 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3214
3215 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3216 {
3217 uppercase (ptr, line_len);
3218 }
3219
3220 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3221 {
3222 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3223 {
3224 ptr[line_len] = 0x80;
3225 }
3226
3227 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3228 {
3229 ptr[line_len] = 0x01;
3230 }
3231 }
3232
3233 device_param->combs_buf[i].pw_len = line_len;
3234
3235 i++;
3236 }
3237
3238 for (uint j = i; j < innerloop_left; j++)
3239 {
3240 device_param->combs_buf[j].i[0] = 0;
3241 device_param->combs_buf[j].i[1] = 0;
3242 device_param->combs_buf[j].i[2] = 0;
3243 device_param->combs_buf[j].i[3] = 0;
3244 device_param->combs_buf[j].i[4] = 0;
3245 device_param->combs_buf[j].i[5] = 0;
3246 device_param->combs_buf[j].i[6] = 0;
3247 device_param->combs_buf[j].i[7] = 0;
3248
3249 device_param->combs_buf[j].pw_len = 0;
3250 }
3251
3252 innerloop_left = i;
3253 }
3254 else if (data.attack_mode == ATTACK_MODE_BF)
3255 {
3256 u64 off = innerloop_pos;
3257
3258 device_param->kernel_params_mp_r_buf64[3] = off;
3259
3260 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3261 }
3262 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3263 {
3264 u64 off = innerloop_pos;
3265
3266 device_param->kernel_params_mp_buf64[3] = off;
3267
3268 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3269 }
3270 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3271 {
3272 u64 off = innerloop_pos;
3273
3274 device_param->kernel_params_mp_buf64[3] = off;
3275
3276 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3277 }
3278
3279 // copy amplifiers
3280
3281 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3282 {
3283 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);
3284 }
3285 else if (data.attack_mode == ATTACK_MODE_COMBI)
3286 {
3287 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);
3288 }
3289 else if (data.attack_mode == ATTACK_MODE_BF)
3290 {
3291 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);
3292 }
3293 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3294 {
3295 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);
3296 }
3297 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3298 {
3299 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);
3300 }
3301
3302 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3303
3304 if (data.benchmark == 1)
3305 {
3306 for (u32 i = 0; i < data.benchmark_repeats; i++)
3307 {
3308 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3309 }
3310 }
3311
3312 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3313
3314 if (data.devices_status == STATUS_CRACKED) break;
3315 if (data.devices_status == STATUS_ABORTED) break;
3316 if (data.devices_status == STATUS_QUIT) break;
3317
3318 /**
3319 * result
3320 */
3321
3322 hc_thread_mutex_lock (mux_display);
3323
3324 check_cracked (device_param, salt_pos);
3325
3326 hc_thread_mutex_unlock (mux_display);
3327
3328 /**
3329 * progress
3330 */
3331
3332 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3333
3334 if (data.benchmark == 1)
3335 {
3336 perf_sum_all = (perf_sum_all * data.benchmark_repeats) + perf_sum_all;
3337 }
3338
3339 hc_thread_mutex_lock (mux_counter);
3340
3341 data.words_progress_done[salt_pos] += perf_sum_all;
3342
3343 hc_thread_mutex_unlock (mux_counter);
3344
3345 /**
3346 * speed
3347 */
3348
3349 float speed_ms;
3350
3351 hc_timer_get (device_param->timer_speed, speed_ms);
3352
3353 hc_timer_set (&device_param->timer_speed);
3354
3355 hc_thread_mutex_lock (mux_display);
3356
3357 device_param->speed_cnt[speed_pos] = perf_sum_all;
3358
3359 device_param->speed_ms[speed_pos] = speed_ms;
3360
3361 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3362
3363 hc_thread_mutex_unlock (mux_display);
3364
3365 speed_pos++;
3366
3367 if (speed_pos == SPEED_CACHE)
3368 {
3369 speed_pos = 0;
3370 }
3371
3372 /**
3373 * benchmark
3374 */
3375
3376 if (data.benchmark == 1) break;
3377 }
3378 }
3379
3380 device_param->speed_pos = speed_pos;
3381
3382 myfree (line_buf);
3383 }
3384
3385 static void load_segment (wl_data_t *wl_data, FILE *fd)
3386 {
3387 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3388
3389 wl_data->pos = 0;
3390
3391 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3392
3393 wl_data->buf[wl_data->cnt] = 0;
3394
3395 if (wl_data->cnt == 0) return;
3396
3397 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3398
3399 while (!feof (fd))
3400 {
3401 if (wl_data->cnt == wl_data->avail)
3402 {
3403 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3404
3405 wl_data->avail += wl_data->incr;
3406 }
3407
3408 const int c = fgetc (fd);
3409
3410 if (c == EOF) break;
3411
3412 wl_data->buf[wl_data->cnt] = (char) c;
3413
3414 wl_data->cnt++;
3415
3416 if (c == '\n') break;
3417 }
3418
3419 // ensure stream ends with a newline
3420
3421 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3422 {
3423 wl_data->cnt++;
3424
3425 wl_data->buf[wl_data->cnt - 1] = '\n';
3426 }
3427
3428 return;
3429 }
3430
3431 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3432 {
3433 char *ptr = buf;
3434
3435 for (u32 i = 0; i < sz; i++, ptr++)
3436 {
3437 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3438
3439 if (i == 7)
3440 {
3441 *off = i;
3442 *len = i;
3443
3444 return;
3445 }
3446
3447 if (*ptr != '\n') continue;
3448
3449 *off = i + 1;
3450
3451 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3452
3453 *len = i;
3454
3455 return;
3456 }
3457
3458 *off = sz;
3459 *len = sz;
3460 }
3461
3462 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3463 {
3464 char *ptr = buf;
3465
3466 for (u32 i = 0; i < sz; i++, ptr++)
3467 {
3468 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3469
3470 if (*ptr != '\n') continue;
3471
3472 *off = i + 1;
3473
3474 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3475
3476 *len = i;
3477
3478 return;
3479 }
3480
3481 *off = sz;
3482 *len = sz;
3483 }
3484
3485 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3486 {
3487 char *ptr = buf;
3488
3489 for (u32 i = 0; i < sz; i++, ptr++)
3490 {
3491 if (*ptr != '\n') continue;
3492
3493 *off = i + 1;
3494
3495 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3496
3497 *len = i;
3498
3499 return;
3500 }
3501
3502 *off = sz;
3503 *len = sz;
3504 }
3505
3506 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3507 {
3508 while (wl_data->pos < wl_data->cnt)
3509 {
3510 uint off;
3511 uint len;
3512
3513 char *ptr = wl_data->buf + wl_data->pos;
3514
3515 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3516
3517 wl_data->pos += off;
3518
3519 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3520 {
3521 char rule_buf_out[BLOCK_SIZE] = { 0 };
3522
3523 int rule_len_out = -1;
3524
3525 if (len < BLOCK_SIZE)
3526 {
3527 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3528 }
3529
3530 if (rule_len_out < 0)
3531 {
3532 continue;
3533 }
3534
3535 if (rule_len_out > PW_MAX)
3536 {
3537 continue;
3538 }
3539 }
3540 else
3541 {
3542 if (len > PW_MAX)
3543 {
3544 continue;
3545 }
3546 }
3547
3548 *out_buf = ptr;
3549 *out_len = len;
3550
3551 return;
3552 }
3553
3554 if (feof (fd))
3555 {
3556 fprintf (stderr, "BUG feof()!!\n");
3557
3558 return;
3559 }
3560
3561 load_segment (wl_data, fd);
3562
3563 get_next_word (wl_data, fd, out_buf, out_len);
3564 }
3565
3566 #ifdef _POSIX
3567 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3568 #endif
3569
3570 #ifdef _WIN
3571 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3572 #endif
3573 {
3574 hc_signal (NULL);
3575
3576 dictstat_t d;
3577
3578 d.cnt = 0;
3579
3580 #ifdef _POSIX
3581 fstat (fileno (fd), &d.stat);
3582 #endif
3583
3584 #ifdef _WIN
3585 _fstat64 (fileno (fd), &d.stat);
3586 #endif
3587
3588 d.stat.st_mode = 0;
3589 d.stat.st_nlink = 0;
3590 d.stat.st_uid = 0;
3591 d.stat.st_gid = 0;
3592 d.stat.st_rdev = 0;
3593 d.stat.st_atime = 0;
3594
3595 #ifdef _POSIX
3596 d.stat.st_blksize = 0;
3597 d.stat.st_blocks = 0;
3598 #endif
3599
3600 if (d.stat.st_size == 0) return 0;
3601
3602 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3603
3604 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3605 {
3606 if (d_cache)
3607 {
3608 u64 cnt = d_cache->cnt;
3609
3610 u64 keyspace = cnt;
3611
3612 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3613 {
3614 keyspace *= data.kernel_rules_cnt;
3615 }
3616 else if (data.attack_kern == ATTACK_KERN_COMBI)
3617 {
3618 keyspace *= data.combs_cnt;
3619 }
3620
3621 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);
3622 if (data.quiet == 0) log_info ("");
3623
3624 hc_signal (sigHandler_default);
3625
3626 return (keyspace);
3627 }
3628 }
3629
3630 time_t now = 0;
3631 time_t prev = 0;
3632
3633 u64 comp = 0;
3634 u64 cnt = 0;
3635 u64 cnt2 = 0;
3636
3637 while (!feof (fd))
3638 {
3639 load_segment (wl_data, fd);
3640
3641 comp += wl_data->cnt;
3642
3643 u32 i = 0;
3644
3645 while (i < wl_data->cnt)
3646 {
3647 u32 len;
3648 u32 off;
3649
3650 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3651
3652 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3653 {
3654 char rule_buf_out[BLOCK_SIZE] = { 0 };
3655
3656 int rule_len_out = -1;
3657
3658 if (len < BLOCK_SIZE)
3659 {
3660 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3661 }
3662
3663 if (rule_len_out < 0)
3664 {
3665 len = PW_MAX1;
3666 }
3667 else
3668 {
3669 len = rule_len_out;
3670 }
3671 }
3672
3673 if (len < PW_MAX1)
3674 {
3675 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3676 {
3677 cnt += data.kernel_rules_cnt;
3678 }
3679 else if (data.attack_kern == ATTACK_KERN_COMBI)
3680 {
3681 cnt += data.combs_cnt;
3682 }
3683
3684 d.cnt++;
3685 }
3686
3687 i += off;
3688
3689 cnt2++;
3690 }
3691
3692 time (&now);
3693
3694 if ((now - prev) == 0) continue;
3695
3696 float percent = (float) comp / (float) d.stat.st_size;
3697
3698 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);
3699
3700 time (&prev);
3701 }
3702
3703 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);
3704 if (data.quiet == 0) log_info ("");
3705
3706 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3707
3708 hc_signal (sigHandler_default);
3709
3710 return (cnt);
3711 }
3712
3713 static void *thread_monitor (void *p)
3714 {
3715 uint runtime_check = 0;
3716 uint remove_check = 0;
3717 uint status_check = 0;
3718 uint restore_check = 0;
3719
3720 uint restore_left = data.restore_timer;
3721 uint remove_left = data.remove_timer;
3722 uint status_left = data.status_timer;
3723
3724 #ifdef HAVE_HWMON
3725 uint hwmon_check = 0;
3726
3727 // these variables are mainly used for fan control (AMD only)
3728
3729 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3730
3731 // temperature controller "loopback" values
3732
3733 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3734 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3735
3736 #ifdef HAVE_ADL
3737 int temp_threshold = 1; // degrees celcius
3738
3739 int fan_speed_min = 15; // in percentage
3740 int fan_speed_max = 100;
3741 #endif // HAVE_ADL
3742
3743 time_t last_temp_check_time;
3744 #endif // HAVE_HWMON
3745
3746 uint sleep_time = 1;
3747
3748 if (data.runtime)
3749 {
3750 runtime_check = 1;
3751 }
3752
3753 if (data.restore_timer)
3754 {
3755 restore_check = 1;
3756 }
3757
3758 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3759 {
3760 remove_check = 1;
3761 }
3762
3763 if (data.status == 1)
3764 {
3765 status_check = 1;
3766 }
3767
3768 #ifdef HAVE_HWMON
3769 if (data.gpu_temp_disable == 0)
3770 {
3771 time (&last_temp_check_time);
3772
3773 hwmon_check = 1;
3774 }
3775 #endif
3776
3777 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3778 {
3779 #ifdef HAVE_HWMON
3780 if (hwmon_check == 0)
3781 #endif
3782 return (p);
3783 }
3784
3785 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3786 {
3787 hc_sleep (sleep_time);
3788
3789 if (data.devices_status != STATUS_RUNNING) continue;
3790
3791 #ifdef HAVE_HWMON
3792 if (hwmon_check == 1)
3793 {
3794 hc_thread_mutex_lock (mux_adl);
3795
3796 time_t temp_check_time;
3797
3798 time (&temp_check_time);
3799
3800 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3801
3802 if (Ta == 0) Ta = 1;
3803
3804 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3805 {
3806 hc_device_param_t *device_param = &data.devices_param[device_id];
3807
3808 if (device_param->skipped) continue;
3809
3810 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3811
3812 const int temperature = hm_get_temperature_with_device_id (device_id);
3813
3814 if (temperature > (int) data.gpu_temp_abort)
3815 {
3816 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3817
3818 if (data.devices_status != STATUS_QUIT) myabort ();
3819
3820 break;
3821 }
3822
3823 #ifdef HAVE_ADL
3824 const int gpu_temp_retain = data.gpu_temp_retain;
3825
3826 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3827 {
3828 if (data.hm_device[device_id].fan_supported == 1)
3829 {
3830 int temp_cur = temperature;
3831
3832 int temp_diff_new = gpu_temp_retain - temp_cur;
3833
3834 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3835
3836 // calculate Ta value (time difference in seconds between the last check and this check)
3837
3838 last_temp_check_time = temp_check_time;
3839
3840 float Kp = 1.8;
3841 float Ki = 0.005;
3842 float Kd = 6;
3843
3844 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3845
3846 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);
3847
3848 if (abs (fan_diff_required) >= temp_threshold)
3849 {
3850 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3851
3852 int fan_speed_level = fan_speed_cur;
3853
3854 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3855
3856 int fan_speed_new = fan_speed_level - fan_diff_required;
3857
3858 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3859 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3860
3861 if (fan_speed_new != fan_speed_cur)
3862 {
3863 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3864 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3865
3866 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3867 {
3868 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3869
3870 fan_speed_chgd[device_id] = 1;
3871 }
3872
3873 temp_diff_old[device_id] = temp_diff_new;
3874 }
3875 }
3876 }
3877 }
3878 #endif // HAVE_ADL
3879 }
3880
3881 hc_thread_mutex_unlock (mux_adl);
3882 }
3883 #endif // HAVE_HWMON
3884
3885 if (restore_check == 1)
3886 {
3887 restore_left--;
3888
3889 if (restore_left == 0)
3890 {
3891 if (data.restore_disable == 0) cycle_restore ();
3892
3893 restore_left = data.restore_timer;
3894 }
3895 }
3896
3897 if ((runtime_check == 1) && (data.runtime_start > 0))
3898 {
3899 time_t runtime_cur;
3900
3901 time (&runtime_cur);
3902
3903 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3904
3905 if (runtime_left <= 0)
3906 {
3907 if (data.benchmark == 0)
3908 {
3909 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3910 }
3911
3912 if (data.devices_status != STATUS_QUIT) myabort ();
3913 }
3914 }
3915
3916 if (remove_check == 1)
3917 {
3918 remove_left--;
3919
3920 if (remove_left == 0)
3921 {
3922 if (data.digests_saved != data.digests_done)
3923 {
3924 data.digests_saved = data.digests_done;
3925
3926 save_hash ();
3927 }
3928
3929 remove_left = data.remove_timer;
3930 }
3931 }
3932
3933 if (status_check == 1)
3934 {
3935 status_left--;
3936
3937 if (status_left == 0)
3938 {
3939 hc_thread_mutex_lock (mux_display);
3940
3941 if (data.quiet == 0) clear_prompt ();
3942
3943 if (data.quiet == 0) log_info ("");
3944
3945 status_display ();
3946
3947 if (data.quiet == 0) log_info ("");
3948
3949 hc_thread_mutex_unlock (mux_display);
3950
3951 status_left = data.status_timer;
3952 }
3953 }
3954 }
3955
3956 #ifdef HAVE_HWMON
3957 myfree (fan_speed_chgd);
3958
3959 myfree (temp_diff_old);
3960 myfree (temp_diff_sum);
3961 #endif
3962
3963 p = NULL;
3964
3965 return (p);
3966 }
3967
3968 static void *thread_outfile_remove (void *p)
3969 {
3970 // some hash-dependent constants
3971 char *outfile_dir = data.outfile_check_directory;
3972 uint dgst_size = data.dgst_size;
3973 uint isSalted = data.isSalted;
3974 uint esalt_size = data.esalt_size;
3975 uint hash_mode = data.hash_mode;
3976
3977 uint outfile_check_timer = data.outfile_check_timer;
3978
3979 char separator = data.separator;
3980
3981 // some hash-dependent functions
3982 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3983 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3984
3985 // buffers
3986 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3987
3988 hash_buf.digest = mymalloc (dgst_size);
3989
3990 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3991
3992 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3993
3994 uint digest_buf[64] = { 0 };
3995
3996 outfile_data_t *out_info = NULL;
3997
3998 char **out_files = NULL;
3999
4000 time_t folder_mtime = 0;
4001
4002 int out_cnt = 0;
4003
4004 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4005
4006 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4007 {
4008 hc_sleep (1);
4009
4010 if (data.devices_status != STATUS_RUNNING) continue;
4011
4012 check_left--;
4013
4014 if (check_left == 0)
4015 {
4016 struct stat outfile_check_stat;
4017
4018 if (stat (outfile_dir, &outfile_check_stat) == 0)
4019 {
4020 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4021
4022 if (is_dir == 1)
4023 {
4024 if (outfile_check_stat.st_mtime > folder_mtime)
4025 {
4026 char **out_files_new = scan_directory (outfile_dir);
4027
4028 int out_cnt_new = count_dictionaries (out_files_new);
4029
4030 outfile_data_t *out_info_new = NULL;
4031
4032 if (out_cnt_new > 0)
4033 {
4034 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4035
4036 for (int i = 0; i < out_cnt_new; i++)
4037 {
4038 out_info_new[i].file_name = out_files_new[i];
4039
4040 // check if there are files that we have seen/checked before (and not changed)
4041
4042 for (int j = 0; j < out_cnt; j++)
4043 {
4044 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4045 {
4046 struct stat outfile_stat;
4047
4048 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4049 {
4050 if (outfile_stat.st_ctime == out_info[j].ctime)
4051 {
4052 out_info_new[i].ctime = out_info[j].ctime;
4053 out_info_new[i].seek = out_info[j].seek;
4054 }
4055 }
4056 }
4057 }
4058 }
4059 }
4060
4061 local_free (out_info);
4062 local_free (out_files);
4063
4064 out_files = out_files_new;
4065 out_cnt = out_cnt_new;
4066 out_info = out_info_new;
4067
4068 folder_mtime = outfile_check_stat.st_mtime;
4069 }
4070
4071 for (int j = 0; j < out_cnt; j++)
4072 {
4073 FILE *fp = fopen (out_info[j].file_name, "rb");
4074
4075 if (fp != NULL)
4076 {
4077 //hc_thread_mutex_lock (mux_display);
4078
4079 #ifdef _POSIX
4080 struct stat outfile_stat;
4081
4082 fstat (fileno (fp), &outfile_stat);
4083 #endif
4084
4085 #ifdef _WIN
4086 struct stat64 outfile_stat;
4087
4088 _fstat64 (fileno (fp), &outfile_stat);
4089 #endif
4090
4091 if (outfile_stat.st_ctime > out_info[j].ctime)
4092 {
4093 out_info[j].ctime = outfile_stat.st_ctime;
4094 out_info[j].seek = 0;
4095 }
4096
4097 fseek (fp, out_info[j].seek, SEEK_SET);
4098
4099 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4100
4101 while (!feof (fp))
4102 {
4103 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4104
4105 if (ptr == NULL) break;
4106
4107 int line_len = strlen (line_buf);
4108
4109 if (line_len <= 0) continue;
4110
4111 int iter = MAX_CUT_TRIES;
4112
4113 for (uint i = line_len - 1; i && iter; i--, line_len--)
4114 {
4115 if (line_buf[i] != separator) continue;
4116
4117 int parser_status = PARSER_OK;
4118
4119 if ((hash_mode != 2500) && (hash_mode != 6800))
4120 {
4121 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4122 }
4123
4124 uint found = 0;
4125
4126 if (parser_status == PARSER_OK)
4127 {
4128 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4129 {
4130 if (data.salts_shown[salt_pos] == 1) continue;
4131
4132 salt_t *salt_buf = &data.salts_buf[salt_pos];
4133
4134 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4135 {
4136 uint idx = salt_buf->digests_offset + digest_pos;
4137
4138 if (data.digests_shown[idx] == 1) continue;
4139
4140 uint cracked = 0;
4141
4142 if (hash_mode == 6800)
4143 {
4144 if (i == salt_buf->salt_len)
4145 {
4146 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4147 }
4148 }
4149 else if (hash_mode == 2500)
4150 {
4151 // BSSID : MAC1 : MAC2 (:plain)
4152 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4153 {
4154 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4155
4156 if (!cracked) continue;
4157
4158 // now compare MAC1 and MAC2 too, since we have this additional info
4159 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4160 char *mac2_pos = mac1_pos + 12 + 1;
4161
4162 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4163 wpa_t *wpa = &wpas[salt_pos];
4164
4165 // compare hex string(s) vs binary MAC address(es)
4166
4167 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4168 {
4169 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4170 {
4171 cracked = 0;
4172
4173 break;
4174 }
4175 }
4176
4177 // early skip ;)
4178 if (!cracked) continue;
4179
4180 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4181 {
4182 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4183 {
4184 cracked = 0;
4185
4186 break;
4187 }
4188 }
4189 }
4190 }
4191 else
4192 {
4193 char *digests_buf_ptr = (char *) data.digests_buf;
4194
4195 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4196
4197 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4198 }
4199
4200 if (cracked == 1)
4201 {
4202 found = 1;
4203
4204 data.digests_shown[idx] = 1;
4205
4206 data.digests_done++;
4207
4208 salt_buf->digests_done++;
4209
4210 if (salt_buf->digests_done == salt_buf->digests_cnt)
4211 {
4212 data.salts_shown[salt_pos] = 1;
4213
4214 data.salts_done++;
4215
4216 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4217 }
4218 }
4219 }
4220
4221 if (data.devices_status == STATUS_CRACKED) break;
4222 }
4223 }
4224
4225 if (found) break;
4226
4227 if (data.devices_status == STATUS_CRACKED) break;
4228
4229 iter--;
4230 }
4231
4232 if (data.devices_status == STATUS_CRACKED) break;
4233 }
4234
4235 myfree (line_buf);
4236
4237 out_info[j].seek = ftell (fp);
4238
4239 //hc_thread_mutex_unlock (mux_display);
4240
4241 fclose (fp);
4242 }
4243 }
4244 }
4245 }
4246
4247 check_left = outfile_check_timer;
4248 }
4249 }
4250
4251 if (esalt_size) local_free (hash_buf.esalt);
4252
4253 if (isSalted) local_free (hash_buf.salt);
4254
4255 local_free (hash_buf.digest);
4256
4257 local_free (out_info);
4258
4259 local_free (out_files);
4260
4261 p = NULL;
4262
4263 return (p);
4264 }
4265
4266 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4267 {
4268 if (device_param->pws_cnt < device_param->kernel_power)
4269 {
4270 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4271
4272 u8 *ptr = (u8 *) pw->i;
4273
4274 memcpy (ptr, pw_buf, pw_len);
4275
4276 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4277
4278 pw->pw_len = pw_len;
4279
4280 device_param->pws_cnt++;
4281 }
4282 else
4283 {
4284 fprintf (stderr, "BUG pw_add()!!\n");
4285
4286 return;
4287 }
4288 }
4289
4290 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4291 {
4292 hc_thread_mutex_lock (mux_dispatcher);
4293
4294 const u64 words_cur = data.words_cur;
4295 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4296
4297 device_param->words_off = words_cur;
4298
4299 const u64 words_left = words_base - words_cur;
4300
4301 if (allow_div)
4302 {
4303 if (data.kernel_power_all > words_left)
4304 {
4305 if (data.kernel_power_div == 0)
4306 {
4307 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4308 }
4309 }
4310
4311 if (data.kernel_power_div)
4312 {
4313 if (device_param->kernel_power == device_param->kernel_power_user)
4314 {
4315 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4316
4317 if (kernel_power_new < device_param->kernel_power)
4318 {
4319 device_param->kernel_power = kernel_power_new;
4320 }
4321 }
4322 }
4323 }
4324
4325 const uint kernel_power = device_param->kernel_power;
4326
4327 uint work = MIN (words_left, kernel_power);
4328
4329 work = MIN (work, max);
4330
4331 data.words_cur += work;
4332
4333 hc_thread_mutex_unlock (mux_dispatcher);
4334
4335 return work;
4336 }
4337
4338 static void *thread_calc_stdin (void *p)
4339 {
4340 hc_device_param_t *device_param = (hc_device_param_t *) p;
4341
4342 if (device_param->skipped) return NULL;
4343
4344 autotune (device_param);
4345
4346 char *buf = (char *) mymalloc (HCBUFSIZ);
4347
4348 const uint attack_kern = data.attack_kern;
4349
4350 const uint kernel_power = device_param->kernel_power;
4351
4352 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4353 {
4354 hc_thread_mutex_lock (mux_dispatcher);
4355
4356 if (feof (stdin) != 0)
4357 {
4358 hc_thread_mutex_unlock (mux_dispatcher);
4359
4360 break;
4361 }
4362
4363 uint words_cur = 0;
4364
4365 while (words_cur < kernel_power)
4366 {
4367 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4368
4369 if (line_buf == NULL) break;
4370
4371 uint line_len = in_superchop (line_buf);
4372
4373 line_len = convert_from_hex (line_buf, line_len);
4374
4375 // post-process rule engine
4376
4377 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4378 {
4379 char rule_buf_out[BLOCK_SIZE] = { 0 };
4380
4381 int rule_len_out = -1;
4382
4383 if (line_len < BLOCK_SIZE)
4384 {
4385 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4386 }
4387
4388 if (rule_len_out < 0) continue;
4389
4390 line_buf = rule_buf_out;
4391 line_len = rule_len_out;
4392 }
4393
4394 if (line_len > PW_MAX)
4395 {
4396 continue;
4397 }
4398
4399 if (attack_kern == ATTACK_KERN_STRAIGHT)
4400 {
4401 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4402 {
4403 hc_thread_mutex_lock (mux_counter);
4404
4405 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4406 {
4407 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4408 }
4409
4410 hc_thread_mutex_unlock (mux_counter);
4411
4412 continue;
4413 }
4414 }
4415 else if (attack_kern == ATTACK_KERN_COMBI)
4416 {
4417 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4418 // since we still need to combine the plains
4419
4420 if (line_len > data.pw_max)
4421 {
4422 hc_thread_mutex_lock (mux_counter);
4423
4424 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4425 {
4426 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4427 }
4428
4429 hc_thread_mutex_unlock (mux_counter);
4430
4431 continue;
4432 }
4433 }
4434
4435 pw_add (device_param, (u8 *) line_buf, line_len);
4436
4437 words_cur++;
4438
4439 if (data.devices_status == STATUS_CRACKED) break;
4440 if (data.devices_status == STATUS_ABORTED) break;
4441 if (data.devices_status == STATUS_QUIT) break;
4442 if (data.devices_status == STATUS_BYPASS) break;
4443 }
4444
4445 hc_thread_mutex_unlock (mux_dispatcher);
4446
4447 if (data.devices_status == STATUS_CRACKED) break;
4448 if (data.devices_status == STATUS_ABORTED) break;
4449 if (data.devices_status == STATUS_QUIT) break;
4450 if (data.devices_status == STATUS_BYPASS) break;
4451
4452 // flush
4453
4454 const uint pws_cnt = device_param->pws_cnt;
4455
4456 if (pws_cnt)
4457 {
4458 run_copy (device_param, pws_cnt);
4459
4460 run_cracker (device_param, pws_cnt);
4461
4462 device_param->pws_cnt = 0;
4463
4464 if (attack_kern == ATTACK_KERN_STRAIGHT)
4465 {
4466 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4467 }
4468 else if (attack_kern == ATTACK_KERN_COMBI)
4469 {
4470 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4471 }
4472 }
4473 }
4474
4475 device_param->kernel_accel = 0;
4476 device_param->kernel_loops = 0;
4477
4478 myfree (buf);
4479
4480 return NULL;
4481 }
4482
4483 static void *thread_calc (void *p)
4484 {
4485 hc_device_param_t *device_param = (hc_device_param_t *) p;
4486
4487 if (device_param->skipped) return NULL;
4488
4489 autotune (device_param);
4490
4491 const uint attack_mode = data.attack_mode;
4492 const uint attack_kern = data.attack_kern;
4493
4494 if (attack_mode == ATTACK_MODE_BF)
4495 {
4496 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4497 {
4498 const uint work = get_work (device_param, -1, true);
4499
4500 if (work == 0) break;
4501
4502 const u64 words_off = device_param->words_off;
4503 const u64 words_fin = words_off + work;
4504
4505 const uint pws_cnt = work;
4506
4507 device_param->pws_cnt = pws_cnt;
4508
4509 if (pws_cnt)
4510 {
4511 run_copy (device_param, pws_cnt);
4512
4513 run_cracker (device_param, pws_cnt);
4514
4515 device_param->pws_cnt = 0;
4516
4517 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4518 }
4519
4520 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4521
4522 if (data.devices_status == STATUS_CRACKED) break;
4523 if (data.devices_status == STATUS_ABORTED) break;
4524 if (data.devices_status == STATUS_QUIT) break;
4525 if (data.devices_status == STATUS_BYPASS) break;
4526
4527 if (data.benchmark == 1) break;
4528
4529 device_param->words_done = words_fin;
4530 }
4531 }
4532 else
4533 {
4534 const uint segment_size = data.segment_size;
4535
4536 char *dictfile = data.dictfile;
4537
4538 if (attack_mode == ATTACK_MODE_COMBI)
4539 {
4540 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4541 {
4542 dictfile = data.dictfile2;
4543 }
4544 }
4545
4546 FILE *fd = fopen (dictfile, "rb");
4547
4548 if (fd == NULL)
4549 {
4550 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4551
4552 return NULL;
4553 }
4554
4555 if (attack_mode == ATTACK_MODE_COMBI)
4556 {
4557 const uint combs_mode = data.combs_mode;
4558
4559 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4560 {
4561 const char *dictfilec = data.dictfile2;
4562
4563 FILE *combs_fp = fopen (dictfilec, "rb");
4564
4565 if (combs_fp == NULL)
4566 {
4567 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4568
4569 fclose (fd);
4570
4571 return NULL;
4572 }
4573
4574 device_param->combs_fp = combs_fp;
4575 }
4576 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4577 {
4578 const char *dictfilec = data.dictfile;
4579
4580 FILE *combs_fp = fopen (dictfilec, "rb");
4581
4582 if (combs_fp == NULL)
4583 {
4584 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4585
4586 fclose (fd);
4587
4588 return NULL;
4589 }
4590
4591 device_param->combs_fp = combs_fp;
4592 }
4593 }
4594
4595 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4596
4597 wl_data->buf = (char *) mymalloc (segment_size);
4598 wl_data->avail = segment_size;
4599 wl_data->incr = segment_size;
4600 wl_data->cnt = 0;
4601 wl_data->pos = 0;
4602
4603 u64 words_cur = 0;
4604
4605 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4606 {
4607 u64 words_off = 0;
4608 u64 words_fin = 0;
4609
4610 bool allow_div = true;
4611
4612 u64 max = -1;
4613
4614 while (max)
4615 {
4616 const uint work = get_work (device_param, max, allow_div);
4617
4618 allow_div = false;
4619
4620 if (work == 0) break;
4621
4622 words_off = device_param->words_off;
4623 words_fin = words_off + work;
4624
4625 char *line_buf;
4626 uint line_len;
4627
4628 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4629
4630 max = 0;
4631
4632 for ( ; words_cur < words_fin; words_cur++)
4633 {
4634 get_next_word (wl_data, fd, &line_buf, &line_len);
4635
4636 line_len = convert_from_hex (line_buf, line_len);
4637
4638 // post-process rule engine
4639
4640 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4641 {
4642 char rule_buf_out[BLOCK_SIZE] = { 0 };
4643
4644 int rule_len_out = -1;
4645
4646 if (line_len < BLOCK_SIZE)
4647 {
4648 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4649 }
4650
4651 if (rule_len_out < 0) continue;
4652
4653 line_buf = rule_buf_out;
4654 line_len = rule_len_out;
4655 }
4656
4657 if (attack_kern == ATTACK_KERN_STRAIGHT)
4658 {
4659 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4660 {
4661 max++;
4662
4663 hc_thread_mutex_lock (mux_counter);
4664
4665 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4666 {
4667 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4668 }
4669
4670 hc_thread_mutex_unlock (mux_counter);
4671
4672 continue;
4673 }
4674 }
4675 else if (attack_kern == ATTACK_KERN_COMBI)
4676 {
4677 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4678 // since we still need to combine the plains
4679
4680 if (line_len > data.pw_max)
4681 {
4682 max++;
4683
4684 hc_thread_mutex_lock (mux_counter);
4685
4686 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4687 {
4688 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4689 }
4690
4691 hc_thread_mutex_unlock (mux_counter);
4692
4693 continue;
4694 }
4695 }
4696
4697 pw_add (device_param, (u8 *) line_buf, line_len);
4698
4699 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4700
4701 if (data.devices_status == STATUS_CRACKED) break;
4702 if (data.devices_status == STATUS_ABORTED) break;
4703 if (data.devices_status == STATUS_QUIT) break;
4704 if (data.devices_status == STATUS_BYPASS) break;
4705 }
4706
4707 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4708
4709 if (data.devices_status == STATUS_CRACKED) break;
4710 if (data.devices_status == STATUS_ABORTED) break;
4711 if (data.devices_status == STATUS_QUIT) break;
4712 if (data.devices_status == STATUS_BYPASS) break;
4713 }
4714
4715 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4716
4717 if (data.devices_status == STATUS_CRACKED) break;
4718 if (data.devices_status == STATUS_ABORTED) break;
4719 if (data.devices_status == STATUS_QUIT) break;
4720 if (data.devices_status == STATUS_BYPASS) break;
4721
4722 //
4723 // flush
4724 //
4725
4726 const uint pws_cnt = device_param->pws_cnt;
4727
4728 if (pws_cnt)
4729 {
4730 run_copy (device_param, pws_cnt);
4731
4732 run_cracker (device_param, pws_cnt);
4733
4734 device_param->pws_cnt = 0;
4735
4736 if (attack_kern == ATTACK_KERN_STRAIGHT)
4737 {
4738 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4739 }
4740 else if (attack_kern == ATTACK_KERN_COMBI)
4741 {
4742 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4743 }
4744 }
4745
4746 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4747
4748 if (data.devices_status == STATUS_CRACKED) break;
4749 if (data.devices_status == STATUS_ABORTED) break;
4750 if (data.devices_status == STATUS_QUIT) break;
4751 if (data.devices_status == STATUS_BYPASS) break;
4752
4753 if (words_fin == 0) break;
4754
4755 device_param->words_done = words_fin;
4756 }
4757
4758 if (attack_mode == ATTACK_MODE_COMBI)
4759 {
4760 fclose (device_param->combs_fp);
4761 }
4762
4763 free (wl_data->buf);
4764 free (wl_data);
4765
4766 fclose (fd);
4767 }
4768
4769 device_param->kernel_accel = 0;
4770 device_param->kernel_loops = 0;
4771
4772 return NULL;
4773 }
4774
4775 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4776 {
4777 if (!device_param)
4778 {
4779 log_error ("ERROR: %s : Invalid argument", __func__);
4780
4781 exit (-1);
4782 }
4783
4784 salt_t *salt_buf = &data.salts_buf[salt_pos];
4785
4786 device_param->kernel_params_buf32[24] = salt_pos;
4787 device_param->kernel_params_buf32[27] = 1;
4788 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4789 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4790 device_param->kernel_params_buf32[30] = 0;
4791 device_param->kernel_params_buf32[31] = 1;
4792
4793 char *dictfile_old = data.dictfile;
4794
4795 const char *weak_hash_check = "weak-hash-check";
4796
4797 data.dictfile = (char *) weak_hash_check;
4798
4799 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4800
4801 data.kernel_rules_buf[0].cmds[0] = 0;
4802
4803 /**
4804 * run the kernel
4805 */
4806
4807 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4808 {
4809 run_kernel (KERN_RUN_1, device_param, 1, false);
4810 }
4811 else
4812 {
4813 run_kernel (KERN_RUN_1, device_param, 1, false);
4814
4815 uint loop_step = 16;
4816
4817 const uint iter = salt_buf->salt_iter;
4818
4819 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4820 {
4821 uint loop_left = iter - loop_pos;
4822
4823 loop_left = MIN (loop_left, loop_step);
4824
4825 device_param->kernel_params_buf32[25] = loop_pos;
4826 device_param->kernel_params_buf32[26] = loop_left;
4827
4828 run_kernel (KERN_RUN_2, device_param, 1, false);
4829 }
4830
4831 run_kernel (KERN_RUN_3, device_param, 1, false);
4832 }
4833
4834 /**
4835 * result
4836 */
4837
4838 check_cracked (device_param, salt_pos);
4839
4840 /**
4841 * cleanup
4842 */
4843
4844 device_param->kernel_params_buf32[24] = 0;
4845 device_param->kernel_params_buf32[25] = 0;
4846 device_param->kernel_params_buf32[26] = 0;
4847 device_param->kernel_params_buf32[27] = 0;
4848 device_param->kernel_params_buf32[28] = 0;
4849 device_param->kernel_params_buf32[29] = 0;
4850 device_param->kernel_params_buf32[30] = 0;
4851 device_param->kernel_params_buf32[31] = 0;
4852
4853 data.dictfile = dictfile_old;
4854
4855 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4856 }
4857
4858 // hlfmt hashcat
4859
4860 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4861 {
4862 if (data.username == 0)
4863 {
4864 *hashbuf_pos = line_buf;
4865 *hashbuf_len = line_len;
4866 }
4867 else
4868 {
4869 char *pos = line_buf;
4870 int len = line_len;
4871
4872 for (int i = 0; i < line_len; i++, pos++, len--)
4873 {
4874 if (line_buf[i] == data.separator)
4875 {
4876 pos++;
4877
4878 len--;
4879
4880 break;
4881 }
4882 }
4883
4884 *hashbuf_pos = pos;
4885 *hashbuf_len = len;
4886 }
4887 }
4888
4889 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4890 {
4891 char *pos = NULL;
4892 int len = 0;
4893
4894 int sep_cnt = 0;
4895
4896 for (int i = 0; i < line_len; i++)
4897 {
4898 if (line_buf[i] == data.separator)
4899 {
4900 sep_cnt++;
4901
4902 continue;
4903 }
4904
4905 if (sep_cnt == 0)
4906 {
4907 if (pos == NULL) pos = line_buf + i;
4908
4909 len++;
4910 }
4911 }
4912
4913 *userbuf_pos = pos;
4914 *userbuf_len = len;
4915 }
4916
4917 // hlfmt pwdump
4918
4919 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4920 {
4921 int sep_cnt = 0;
4922
4923 int sep2_len = 0;
4924 int sep3_len = 0;
4925
4926 for (int i = 0; i < line_len; i++)
4927 {
4928 if (line_buf[i] == ':')
4929 {
4930 sep_cnt++;
4931
4932 continue;
4933 }
4934
4935 if (sep_cnt == 2) sep2_len++;
4936 if (sep_cnt == 3) sep3_len++;
4937 }
4938
4939 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4940
4941 return 0;
4942 }
4943
4944 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4945 {
4946 char *pos = NULL;
4947 int len = 0;
4948
4949 int sep_cnt = 0;
4950
4951 for (int i = 0; i < line_len; i++)
4952 {
4953 if (line_buf[i] == ':')
4954 {
4955 sep_cnt++;
4956
4957 continue;
4958 }
4959
4960 if (data.hash_mode == 1000)
4961 {
4962 if (sep_cnt == 3)
4963 {
4964 if (pos == NULL) pos = line_buf + i;
4965
4966 len++;
4967 }
4968 }
4969 else if (data.hash_mode == 3000)
4970 {
4971 if (sep_cnt == 2)
4972 {
4973 if (pos == NULL) pos = line_buf + i;
4974
4975 len++;
4976 }
4977 }
4978 }
4979
4980 *hashbuf_pos = pos;
4981 *hashbuf_len = len;
4982 }
4983
4984 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4985 {
4986 char *pos = NULL;
4987 int len = 0;
4988
4989 int sep_cnt = 0;
4990
4991 for (int i = 0; i < line_len; i++)
4992 {
4993 if (line_buf[i] == ':')
4994 {
4995 sep_cnt++;
4996
4997 continue;
4998 }
4999
5000 if (sep_cnt == 0)
5001 {
5002 if (pos == NULL) pos = line_buf + i;
5003
5004 len++;
5005 }
5006 }
5007
5008 *userbuf_pos = pos;
5009 *userbuf_len = len;
5010 }
5011
5012 // hlfmt passwd
5013
5014 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5015 {
5016 int sep_cnt = 0;
5017
5018 char sep5_first = 0;
5019 char sep6_first = 0;
5020
5021 for (int i = 0; i < line_len; i++)
5022 {
5023 if (line_buf[i] == ':')
5024 {
5025 sep_cnt++;
5026
5027 continue;
5028 }
5029
5030 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5031 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5032 }
5033
5034 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5035
5036 return 0;
5037 }
5038
5039 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5040 {
5041 char *pos = NULL;
5042 int len = 0;
5043
5044 int sep_cnt = 0;
5045
5046 for (int i = 0; i < line_len; i++)
5047 {
5048 if (line_buf[i] == ':')
5049 {
5050 sep_cnt++;
5051
5052 continue;
5053 }
5054
5055 if (sep_cnt == 1)
5056 {
5057 if (pos == NULL) pos = line_buf + i;
5058
5059 len++;
5060 }
5061 }
5062
5063 *hashbuf_pos = pos;
5064 *hashbuf_len = len;
5065 }
5066
5067 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5068 {
5069 char *pos = NULL;
5070 int len = 0;
5071
5072 int sep_cnt = 0;
5073
5074 for (int i = 0; i < line_len; i++)
5075 {
5076 if (line_buf[i] == ':')
5077 {
5078 sep_cnt++;
5079
5080 continue;
5081 }
5082
5083 if (sep_cnt == 0)
5084 {
5085 if (pos == NULL) pos = line_buf + i;
5086
5087 len++;
5088 }
5089 }
5090
5091 *userbuf_pos = pos;
5092 *userbuf_len = len;
5093 }
5094
5095 // hlfmt shadow
5096
5097 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5098 {
5099 int sep_cnt = 0;
5100
5101 for (int i = 0; i < line_len; i++)
5102 {
5103 if (line_buf[i] == ':') sep_cnt++;
5104 }
5105
5106 if (sep_cnt == 8) return 1;
5107
5108 return 0;
5109 }
5110
5111 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5112 {
5113 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5114 }
5115
5116 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5117 {
5118 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5119 }
5120
5121 // hlfmt main
5122
5123 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5124 {
5125 switch (hashfile_format)
5126 {
5127 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5128 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5129 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5130 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5131 }
5132 }
5133
5134 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5135 {
5136 switch (hashfile_format)
5137 {
5138 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5139 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5140 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5141 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5142 }
5143 }
5144
5145 char *strhlfmt (const uint hashfile_format)
5146 {
5147 switch (hashfile_format)
5148 {
5149 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5150 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5151 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5152 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5153 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5154 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5155 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5156 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5157 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5158 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5159 }
5160
5161 return ((char *) "Unknown");
5162 }
5163
5164 static uint hlfmt_detect (FILE *fp, uint max_check)
5165 {
5166 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5167
5168 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5169 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5170
5171 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5172
5173 uint num_check = 0;
5174
5175 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5176
5177 while (!feof (fp))
5178 {
5179 int line_len = fgetl (fp, line_buf);
5180
5181 if (line_len == 0) continue;
5182
5183 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5184 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5185 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5186
5187 if (num_check == max_check) break;
5188
5189 num_check++;
5190 }
5191
5192 myfree (line_buf);
5193
5194 uint hashlist_format = HLFMT_HASHCAT;
5195
5196 for (int i = 1; i < HLFMTS_CNT; i++)
5197 {
5198 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5199
5200 hashlist_format = i;
5201 }
5202
5203 free (formats_cnt);
5204
5205 return hashlist_format;
5206 }
5207
5208 /**
5209 * some further helper function
5210 */
5211
5212 // wrapper around mymalloc for ADL
5213
5214 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5215 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5216 {
5217 return mymalloc (iSize);
5218 }
5219 #endif
5220
5221 static uint generate_bitmaps (const uint digests_cnt, const uint dgst_size, const uint dgst_shifts, char *digests_buf_ptr, const uint bitmap_mask, const uint bitmap_size, uint *bitmap_a, uint *bitmap_b, uint *bitmap_c, uint *bitmap_d, const u64 collisions_max)
5222 {
5223 u64 collisions = 0;
5224
5225 const uint dgst_pos0 = data.dgst_pos0;
5226 const uint dgst_pos1 = data.dgst_pos1;
5227 const uint dgst_pos2 = data.dgst_pos2;
5228 const uint dgst_pos3 = data.dgst_pos3;
5229
5230 memset (bitmap_a, 0, bitmap_size);
5231 memset (bitmap_b, 0, bitmap_size);
5232 memset (bitmap_c, 0, bitmap_size);
5233 memset (bitmap_d, 0, bitmap_size);
5234
5235 for (uint i = 0; i < digests_cnt; i++)
5236 {
5237 uint *digest_ptr = (uint *) digests_buf_ptr;
5238
5239 digests_buf_ptr += dgst_size;
5240
5241 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5242 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5243 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5244 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5245
5246 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5247 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5248 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5249 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5250
5251 if (bitmap_a[idx0] & val0) collisions++;
5252 if (bitmap_b[idx1] & val1) collisions++;
5253 if (bitmap_c[idx2] & val2) collisions++;
5254 if (bitmap_d[idx3] & val3) collisions++;
5255
5256 bitmap_a[idx0] |= val0;
5257 bitmap_b[idx1] |= val1;
5258 bitmap_c[idx2] |= val2;
5259 bitmap_d[idx3] |= val3;
5260
5261 if (collisions >= collisions_max) return 0x7fffffff;
5262 }
5263
5264 return collisions;
5265 }
5266
5267 /**
5268 * main
5269 */
5270
5271 int main (int argc, char **argv)
5272 {
5273 /**
5274 * To help users a bit
5275 */
5276
5277 char *compute = getenv ("COMPUTE");
5278
5279 if (compute)
5280 {
5281 static char display[100];
5282
5283 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5284
5285 putenv (display);
5286 }
5287 else
5288 {
5289 if (getenv ("DISPLAY") == NULL)
5290 putenv ((char *) "DISPLAY=:0");
5291 }
5292
5293 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5294 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5295
5296 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5297 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5298
5299 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5300 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5301
5302 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5303 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5304
5305 /**
5306 * Real init
5307 */
5308
5309 memset (&data, 0, sizeof (hc_global_data_t));
5310
5311 time_t proc_start;
5312
5313 time (&proc_start);
5314
5315 data.proc_start = proc_start;
5316
5317 int myargc = argc;
5318 char **myargv = argv;
5319
5320 hc_thread_mutex_init (mux_dispatcher);
5321 hc_thread_mutex_init (mux_counter);
5322 hc_thread_mutex_init (mux_display);
5323 hc_thread_mutex_init (mux_adl);
5324
5325 /**
5326 * commandline parameters
5327 */
5328
5329 uint usage = USAGE;
5330 uint version = VERSION;
5331 uint quiet = QUIET;
5332 uint benchmark = BENCHMARK;
5333 uint benchmark_repeats = BENCHMARK_REPEATS;
5334 uint show = SHOW;
5335 uint left = LEFT;
5336 uint username = USERNAME;
5337 uint remove = REMOVE;
5338 uint remove_timer = REMOVE_TIMER;
5339 u64 skip = SKIP;
5340 u64 limit = LIMIT;
5341 uint keyspace = KEYSPACE;
5342 uint potfile_disable = POTFILE_DISABLE;
5343 char *potfile_path = NULL;
5344 uint debug_mode = DEBUG_MODE;
5345 char *debug_file = NULL;
5346 char *induction_dir = NULL;
5347 char *outfile_check_dir = NULL;
5348 uint force = FORCE;
5349 uint runtime = RUNTIME;
5350 uint hash_mode = HASH_MODE;
5351 uint attack_mode = ATTACK_MODE;
5352 uint markov_disable = MARKOV_DISABLE;
5353 uint markov_classic = MARKOV_CLASSIC;
5354 uint markov_threshold = MARKOV_THRESHOLD;
5355 char *markov_hcstat = NULL;
5356 char *outfile = NULL;
5357 uint outfile_format = OUTFILE_FORMAT;
5358 uint outfile_autohex = OUTFILE_AUTOHEX;
5359 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5360 uint restore = RESTORE;
5361 uint restore_timer = RESTORE_TIMER;
5362 uint restore_disable = RESTORE_DISABLE;
5363 uint status = STATUS;
5364 uint status_timer = STATUS_TIMER;
5365 uint status_automat = STATUS_AUTOMAT;
5366 uint loopback = LOOPBACK;
5367 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5368 char *session = NULL;
5369 uint hex_charset = HEX_CHARSET;
5370 uint hex_salt = HEX_SALT;
5371 uint hex_wordlist = HEX_WORDLIST;
5372 uint rp_gen = RP_GEN;
5373 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5374 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5375 uint rp_gen_seed = RP_GEN_SEED;
5376 char *rule_buf_l = (char *) RULE_BUF_L;
5377 char *rule_buf_r = (char *) RULE_BUF_R;
5378 uint increment = INCREMENT;
5379 uint increment_min = INCREMENT_MIN;
5380 uint increment_max = INCREMENT_MAX;
5381 char *cpu_affinity = NULL;
5382 OCL_PTR *ocl = NULL;
5383 char *opencl_devices = NULL;
5384 char *opencl_platforms = NULL;
5385 char *opencl_device_types = NULL;
5386 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5387 char *truecrypt_keyfiles = NULL;
5388 uint workload_profile = WORKLOAD_PROFILE;
5389 uint kernel_accel = KERNEL_ACCEL;
5390 uint kernel_loops = KERNEL_LOOPS;
5391 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5392 #ifdef HAVE_HWMON
5393 uint gpu_temp_abort = GPU_TEMP_ABORT;
5394 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5395 #ifdef HAVE_ADL
5396 uint powertune_enable = POWERTUNE_ENABLE;
5397 #endif
5398 #endif
5399 uint logfile_disable = LOGFILE_DISABLE;
5400 uint segment_size = SEGMENT_SIZE;
5401 uint scrypt_tmto = SCRYPT_TMTO;
5402 char separator = SEPARATOR;
5403 uint bitmap_min = BITMAP_MIN;
5404 uint bitmap_max = BITMAP_MAX;
5405 char *custom_charset_1 = NULL;
5406 char *custom_charset_2 = NULL;
5407 char *custom_charset_3 = NULL;
5408 char *custom_charset_4 = NULL;
5409
5410 #define IDX_HELP 'h'
5411 #define IDX_VERSION 'V'
5412 #define IDX_VERSION_LOWER 'v'
5413 #define IDX_QUIET 0xff02
5414 #define IDX_SHOW 0xff03
5415 #define IDX_LEFT 0xff04
5416 #define IDX_REMOVE 0xff05
5417 #define IDX_REMOVE_TIMER 0xff37
5418 #define IDX_SKIP 's'
5419 #define IDX_LIMIT 'l'
5420 #define IDX_KEYSPACE 0xff35
5421 #define IDX_POTFILE_DISABLE 0xff06
5422 #define IDX_POTFILE_PATH 0xffe0
5423 #define IDX_DEBUG_MODE 0xff43
5424 #define IDX_DEBUG_FILE 0xff44
5425 #define IDX_INDUCTION_DIR 0xff46
5426 #define IDX_OUTFILE_CHECK_DIR 0xff47
5427 #define IDX_USERNAME 0xff07
5428 #define IDX_FORCE 0xff08
5429 #define IDX_RUNTIME 0xff09
5430 #define IDX_BENCHMARK 'b'
5431 #define IDX_BENCHMARK_REPEATS 0xff78
5432 #define IDX_HASH_MODE 'm'
5433 #define IDX_ATTACK_MODE 'a'
5434 #define IDX_RP_FILE 'r'
5435 #define IDX_RP_GEN 'g'
5436 #define IDX_RP_GEN_FUNC_MIN 0xff10
5437 #define IDX_RP_GEN_FUNC_MAX 0xff11
5438 #define IDX_RP_GEN_SEED 0xff34
5439 #define IDX_RULE_BUF_L 'j'
5440 #define IDX_RULE_BUF_R 'k'
5441 #define IDX_INCREMENT 'i'
5442 #define IDX_INCREMENT_MIN 0xff12
5443 #define IDX_INCREMENT_MAX 0xff13
5444 #define IDX_OUTFILE 'o'
5445 #define IDX_OUTFILE_FORMAT 0xff14
5446 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5447 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5448 #define IDX_RESTORE 0xff15
5449 #define IDX_RESTORE_DISABLE 0xff27
5450 #define IDX_STATUS 0xff17
5451 #define IDX_STATUS_TIMER 0xff18
5452 #define IDX_STATUS_AUTOMAT 0xff50
5453 #define IDX_LOOPBACK 0xff38
5454 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5455 #define IDX_SESSION 0xff19
5456 #define IDX_HEX_CHARSET 0xff20
5457 #define IDX_HEX_SALT 0xff21
5458 #define IDX_HEX_WORDLIST 0xff40
5459 #define IDX_MARKOV_DISABLE 0xff22
5460 #define IDX_MARKOV_CLASSIC 0xff23
5461 #define IDX_MARKOV_THRESHOLD 't'
5462 #define IDX_MARKOV_HCSTAT 0xff24
5463 #define IDX_CPU_AFFINITY 0xff25
5464 #define IDX_OPENCL_DEVICES 'd'
5465 #define IDX_OPENCL_PLATFORMS 0xff72
5466 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5467 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5468 #define IDX_WORKLOAD_PROFILE 'w'
5469 #define IDX_KERNEL_ACCEL 'n'
5470 #define IDX_KERNEL_LOOPS 'u'
5471 #define IDX_GPU_TEMP_DISABLE 0xff29
5472 #define IDX_GPU_TEMP_ABORT 0xff30
5473 #define IDX_GPU_TEMP_RETAIN 0xff31
5474 #define IDX_POWERTUNE_ENABLE 0xff41
5475 #define IDX_LOGFILE_DISABLE 0xff51
5476 #define IDX_TRUECRYPT_KEYFILES 0xff52
5477 #define IDX_SCRYPT_TMTO 0xff61
5478 #define IDX_SEGMENT_SIZE 'c'
5479 #define IDX_SEPARATOR 'p'
5480 #define IDX_BITMAP_MIN 0xff70
5481 #define IDX_BITMAP_MAX 0xff71
5482 #define IDX_CUSTOM_CHARSET_1 '1'
5483 #define IDX_CUSTOM_CHARSET_2 '2'
5484 #define IDX_CUSTOM_CHARSET_3 '3'
5485 #define IDX_CUSTOM_CHARSET_4 '4'
5486
5487 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5488
5489 struct option long_options[] =
5490 {
5491 {"help", no_argument, 0, IDX_HELP},
5492 {"version", no_argument, 0, IDX_VERSION},
5493 {"quiet", no_argument, 0, IDX_QUIET},
5494 {"show", no_argument, 0, IDX_SHOW},
5495 {"left", no_argument, 0, IDX_LEFT},
5496 {"username", no_argument, 0, IDX_USERNAME},
5497 {"remove", no_argument, 0, IDX_REMOVE},
5498 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5499 {"skip", required_argument, 0, IDX_SKIP},
5500 {"limit", required_argument, 0, IDX_LIMIT},
5501 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5502 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5503 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5504 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5505 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5506 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5507 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5508 {"force", no_argument, 0, IDX_FORCE},
5509 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5510 {"benchmark-repeats", required_argument, 0, IDX_BENCHMARK_REPEATS},
5511 {"restore", no_argument, 0, IDX_RESTORE},
5512 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5513 {"status", no_argument, 0, IDX_STATUS},
5514 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5515 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5516 {"loopback", no_argument, 0, IDX_LOOPBACK},
5517 {"weak-hash-threshold",
5518 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5519 {"session", required_argument, 0, IDX_SESSION},
5520 {"runtime", required_argument, 0, IDX_RUNTIME},
5521 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5522 {"generate-rules-func-min",
5523 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5524 {"generate-rules-func-max",
5525 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5526 {"generate-rules-seed",
5527 required_argument, 0, IDX_RP_GEN_SEED},
5528 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5529 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5530 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5531 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5532 {"rules-file", required_argument, 0, IDX_RP_FILE},
5533 {"outfile", required_argument, 0, IDX_OUTFILE},
5534 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5535 {"outfile-autohex-disable",
5536 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5537 {"outfile-check-timer",
5538 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5539 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5540 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5541 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5542 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5543 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5544 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5545 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5546 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5547 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5548 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5549 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5550 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5551 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5552 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5553 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5554 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5555 #ifdef HAVE_HWMON
5556 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5557 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5558 #ifdef HAVE_ADL
5559 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5560 #endif
5561 #endif // HAVE_HWMON
5562 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5563 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5564 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5565 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5566 // deprecated
5567 {"seperator", required_argument, 0, IDX_SEPARATOR},
5568 {"separator", required_argument, 0, IDX_SEPARATOR},
5569 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5570 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5571 {"increment", no_argument, 0, IDX_INCREMENT},
5572 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5573 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5574 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5575 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5576 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5577 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5578
5579 {0, 0, 0, 0}
5580 };
5581
5582 uint rp_files_cnt = 0;
5583
5584 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5585
5586 int option_index = 0;
5587 int c = -1;
5588
5589 optind = 1;
5590 optopt = 0;
5591
5592 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5593 {
5594 switch (c)
5595 {
5596 case IDX_HELP: usage = 1; break;
5597 case IDX_VERSION:
5598 case IDX_VERSION_LOWER: version = 1; break;
5599 case IDX_RESTORE: restore = 1; break;
5600 case IDX_SESSION: session = optarg; break;
5601 case IDX_SHOW: show = 1; break;
5602 case IDX_LEFT: left = 1; break;
5603 case '?': return (-1);
5604 }
5605 }
5606
5607 if (optopt != 0)
5608 {
5609 log_error ("ERROR: Invalid argument specified");
5610
5611 return (-1);
5612 }
5613
5614 /**
5615 * exit functions
5616 */
5617
5618 if (version)
5619 {
5620 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5621
5622 return (0);
5623 }
5624
5625 if (usage)
5626 {
5627 usage_big_print (PROGNAME);
5628
5629 return (0);
5630 }
5631
5632 /**
5633 * session needs to be set, always!
5634 */
5635
5636 if (session == NULL) session = (char *) PROGNAME;
5637
5638 /**
5639 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5640 */
5641
5642 char *exec_path = get_exec_path ();
5643
5644 #ifdef LINUX
5645
5646 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5647 char *resolved_exec_path = realpath (exec_path, NULL);
5648
5649 char *install_dir = get_install_dir (resolved_exec_path);
5650 char *profile_dir = NULL;
5651 char *session_dir = NULL;
5652 char *shared_dir = NULL;
5653
5654 if (strcmp (install_dir, resolved_install_folder) == 0)
5655 {
5656 struct passwd *pw = getpwuid (getuid ());
5657
5658 const char *homedir = pw->pw_dir;
5659
5660 profile_dir = get_profile_dir (homedir);
5661 session_dir = get_session_dir (profile_dir);
5662 shared_dir = strdup (SHARED_FOLDER);
5663
5664 mkdir (profile_dir, 0700);
5665 mkdir (session_dir, 0700);
5666 }
5667 else
5668 {
5669 profile_dir = install_dir;
5670 session_dir = install_dir;
5671 shared_dir = install_dir;
5672 }
5673
5674 myfree (resolved_install_folder);
5675 myfree (resolved_exec_path);
5676
5677 #else
5678
5679 char *install_dir = get_install_dir (exec_path);
5680 char *profile_dir = install_dir;
5681 char *session_dir = install_dir;
5682 char *shared_dir = install_dir;
5683
5684 #endif
5685
5686 data.install_dir = install_dir;
5687 data.profile_dir = profile_dir;
5688 data.session_dir = session_dir;
5689 data.shared_dir = shared_dir;
5690
5691 myfree (exec_path);
5692
5693 /**
5694 * kernel cache, we need to make sure folder exist
5695 */
5696
5697 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5698
5699 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5700
5701 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5702
5703 mkdir (kernels_folder, 0700);
5704
5705 myfree (kernels_folder);
5706
5707 /**
5708 * session
5709 */
5710
5711 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5712
5713 data.session = session;
5714
5715 char *eff_restore_file = (char *) mymalloc (session_size);
5716 char *new_restore_file = (char *) mymalloc (session_size);
5717
5718 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5719 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5720
5721 data.eff_restore_file = eff_restore_file;
5722 data.new_restore_file = new_restore_file;
5723
5724 if (((show == 1) || (left == 1)) && (restore == 1))
5725 {
5726 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5727 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5728
5729 return (-1);
5730 }
5731
5732 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5733 if ((show == 1) || (left == 1))
5734 {
5735 restore_disable = 1;
5736
5737 restore = 0;
5738 }
5739
5740 data.restore_disable = restore_disable;
5741
5742 restore_data_t *rd = init_restore (argc, argv);
5743
5744 data.rd = rd;
5745
5746 /**
5747 * restore file
5748 */
5749
5750 if (restore == 1)
5751 {
5752 read_restore (eff_restore_file, rd);
5753
5754 if (rd->version_bin < RESTORE_MIN)
5755 {
5756 log_error ("ERROR: Incompatible restore-file version");
5757
5758 return (-1);
5759 }
5760
5761 myargc = rd->argc;
5762 myargv = rd->argv;
5763
5764 #ifdef _POSIX
5765 rd->pid = getpid ();
5766 #elif _WIN
5767 rd->pid = GetCurrentProcessId ();
5768 #endif
5769 }
5770
5771 uint hash_mode_chgd = 0;
5772 uint runtime_chgd = 0;
5773 uint kernel_loops_chgd = 0;
5774 uint kernel_accel_chgd = 0;
5775 uint attack_mode_chgd = 0;
5776 uint outfile_format_chgd = 0;
5777 uint rp_gen_seed_chgd = 0;
5778 uint remove_timer_chgd = 0;
5779 uint increment_min_chgd = 0;
5780 uint increment_max_chgd = 0;
5781 uint workload_profile_chgd = 0;
5782 uint opencl_vector_width_chgd = 0;
5783
5784 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5785 uint gpu_temp_retain_chgd = 0;
5786 uint gpu_temp_abort_chgd = 0;
5787 #endif
5788
5789 optind = 1;
5790 optopt = 0;
5791 option_index = 0;
5792
5793 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5794 {
5795 switch (c)
5796 {
5797 //case IDX_HELP: usage = 1; break;
5798 //case IDX_VERSION: version = 1; break;
5799 //case IDX_RESTORE: restore = 1; break;
5800 case IDX_QUIET: quiet = 1; break;
5801 //case IDX_SHOW: show = 1; break;
5802 case IDX_SHOW: break;
5803 //case IDX_LEFT: left = 1; break;
5804 case IDX_LEFT: break;
5805 case IDX_USERNAME: username = 1; break;
5806 case IDX_REMOVE: remove = 1; break;
5807 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5808 remove_timer_chgd = 1; break;
5809 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5810 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5811 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5812 case IDX_DEBUG_FILE: debug_file = optarg; break;
5813 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5814 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5815 case IDX_FORCE: force = 1; break;
5816 case IDX_SKIP: skip = atoll (optarg); break;
5817 case IDX_LIMIT: limit = atoll (optarg); break;
5818 case IDX_KEYSPACE: keyspace = 1; break;
5819 case IDX_BENCHMARK: benchmark = 1; break;
5820 case IDX_BENCHMARK_REPEATS: benchmark_repeats = atoi (optarg); break;
5821 case IDX_RESTORE: break;
5822 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5823 case IDX_STATUS: status = 1; break;
5824 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5825 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5826 case IDX_LOOPBACK: loopback = 1; break;
5827 case IDX_WEAK_HASH_THRESHOLD:
5828 weak_hash_threshold = atoi (optarg); break;
5829 //case IDX_SESSION: session = optarg; break;
5830 case IDX_SESSION: break;
5831 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5832 hash_mode_chgd = 1; break;
5833 case IDX_RUNTIME: runtime = atoi (optarg);
5834 runtime_chgd = 1; break;
5835 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5836 attack_mode_chgd = 1; break;
5837 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5838 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5839 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5840 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5841 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5842 rp_gen_seed_chgd = 1; break;
5843 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5844 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5845 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5846 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5847 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5848 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5849 case IDX_OUTFILE: outfile = optarg; break;
5850 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5851 outfile_format_chgd = 1; break;
5852 case IDX_OUTFILE_AUTOHEX_DISABLE:
5853 outfile_autohex = 0; break;
5854 case IDX_OUTFILE_CHECK_TIMER:
5855 outfile_check_timer = atoi (optarg); break;
5856 case IDX_HEX_CHARSET: hex_charset = 1; break;
5857 case IDX_HEX_SALT: hex_salt = 1; break;
5858 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5859 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5860 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5861 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5862 case IDX_OPENCL_DEVICE_TYPES:
5863 opencl_device_types = optarg; break;
5864 case IDX_OPENCL_VECTOR_WIDTH:
5865 opencl_vector_width = atoi (optarg);
5866 opencl_vector_width_chgd = 1; break;
5867 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5868 workload_profile_chgd = 1; break;
5869 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5870 kernel_accel_chgd = 1; break;
5871 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5872 kernel_loops_chgd = 1; break;
5873 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5874 #ifdef HAVE_HWMON
5875 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5876 #ifdef HAVE_ADL
5877 gpu_temp_abort_chgd = 1;
5878 #endif
5879 break;
5880 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5881 #ifdef HAVE_ADL
5882 gpu_temp_retain_chgd = 1;
5883 #endif
5884 break;
5885 #ifdef HAVE_ADL
5886 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5887 #endif
5888 #endif // HAVE_HWMON
5889 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5890 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5891 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5892 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5893 case IDX_SEPARATOR: separator = optarg[0]; break;
5894 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5895 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5896 case IDX_INCREMENT: increment = 1; break;
5897 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5898 increment_min_chgd = 1; break;
5899 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5900 increment_max_chgd = 1; break;
5901 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5902 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5903 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5904 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5905
5906 default:
5907 log_error ("ERROR: Invalid argument specified");
5908 return (-1);
5909 }
5910 }
5911
5912 if (optopt != 0)
5913 {
5914 log_error ("ERROR: Invalid argument specified");
5915
5916 return (-1);
5917 }
5918
5919 /**
5920 * Inform user things getting started,
5921 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5922 * - we do not need to check algorithm_pos
5923 */
5924
5925 if (quiet == 0)
5926 {
5927 if (benchmark == 1)
5928 {
5929 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5930
5931 log_info ("");
5932 }
5933 else if (restore == 1)
5934 {
5935 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5936
5937 log_info ("");
5938 }
5939 else
5940 {
5941 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5942
5943 log_info ("");
5944 }
5945 }
5946
5947 /**
5948 * sanity check
5949 */
5950
5951 if (attack_mode > 7)
5952 {
5953 log_error ("ERROR: Invalid attack-mode specified");
5954
5955 return (-1);
5956 }
5957
5958 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5959 {
5960 log_error ("ERROR: Invalid runtime specified");
5961
5962 return (-1);
5963 }
5964
5965 if (hash_mode_chgd && hash_mode > 13400) // just added to remove compiler warnings for hash_mode_chgd
5966 {
5967 log_error ("ERROR: Invalid hash-type specified");
5968
5969 return (-1);
5970 }
5971
5972 // renamed hash modes
5973
5974 if (hash_mode_chgd)
5975 {
5976 int n = -1;
5977
5978 switch (hash_mode)
5979 {
5980 case 123: n = 124;
5981 break;
5982 }
5983
5984 if (n >= 0)
5985 {
5986 log_error ("Old -m specified, use -m %d instead", n);
5987
5988 return (-1);
5989 }
5990 }
5991
5992 if (username == 1)
5993 {
5994 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5995 {
5996 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5997
5998 return (-1);
5999 }
6000 }
6001
6002 if (outfile_format > 16)
6003 {
6004 log_error ("ERROR: Invalid outfile-format specified");
6005
6006 return (-1);
6007 }
6008
6009 if (left == 1)
6010 {
6011 if (outfile_format_chgd == 1)
6012 {
6013 if (outfile_format > 1)
6014 {
6015 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6016
6017 return (-1);
6018 }
6019 }
6020 else
6021 {
6022 outfile_format = OUTFILE_FMT_HASH;
6023 }
6024 }
6025
6026 if (show == 1)
6027 {
6028 if (outfile_format_chgd == 1)
6029 {
6030 if ((outfile_format > 7) && (outfile_format < 16))
6031 {
6032 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6033
6034 return (-1);
6035 }
6036 }
6037 }
6038
6039 if (increment_min < INCREMENT_MIN)
6040 {
6041 log_error ("ERROR: Invalid increment-min specified");
6042
6043 return (-1);
6044 }
6045
6046 if (increment_max > INCREMENT_MAX)
6047 {
6048 log_error ("ERROR: Invalid increment-max specified");
6049
6050 return (-1);
6051 }
6052
6053 if (increment_min > increment_max)
6054 {
6055 log_error ("ERROR: Invalid increment-min specified");
6056
6057 return (-1);
6058 }
6059
6060 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6061 {
6062 log_error ("ERROR: increment is not allowed in attack-mode 0");
6063
6064 return (-1);
6065 }
6066
6067 if ((increment == 0) && (increment_min_chgd == 1))
6068 {
6069 log_error ("ERROR: increment-min is only supported together with increment switch");
6070
6071 return (-1);
6072 }
6073
6074 if ((increment == 0) && (increment_max_chgd == 1))
6075 {
6076 log_error ("ERROR: increment-max is only supported together with increment switch");
6077
6078 return (-1);
6079 }
6080
6081 if (rp_files_cnt && rp_gen)
6082 {
6083 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6084
6085 return (-1);
6086 }
6087
6088 if (rp_files_cnt || rp_gen)
6089 {
6090 if (attack_mode != ATTACK_MODE_STRAIGHT)
6091 {
6092 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6093
6094 return (-1);
6095 }
6096 }
6097
6098 if (rp_gen_func_min > rp_gen_func_max)
6099 {
6100 log_error ("ERROR: Invalid rp-gen-func-min specified");
6101
6102 return (-1);
6103 }
6104
6105 if (kernel_accel_chgd == 1)
6106 {
6107 if (kernel_accel < 1)
6108 {
6109 log_error ("ERROR: Invalid kernel-accel specified");
6110
6111 return (-1);
6112 }
6113
6114 if (kernel_accel > 1024)
6115 {
6116 log_error ("ERROR: Invalid kernel-accel specified");
6117
6118 return (-1);
6119 }
6120 }
6121
6122 if (kernel_loops_chgd == 1)
6123 {
6124 if (kernel_loops < 1)
6125 {
6126 log_error ("ERROR: Invalid kernel-loops specified");
6127
6128 return (-1);
6129 }
6130
6131 if (kernel_loops > 1024)
6132 {
6133 log_error ("ERROR: Invalid kernel-loops specified");
6134
6135 return (-1);
6136 }
6137 }
6138
6139 if ((workload_profile < 1) || (workload_profile > 3))
6140 {
6141 log_error ("ERROR: workload-profile %i not available", workload_profile);
6142
6143 return (-1);
6144 }
6145
6146 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6147 {
6148 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6149
6150 return (-1);
6151 }
6152
6153 if (show == 1 || left == 1)
6154 {
6155 attack_mode = ATTACK_MODE_NONE;
6156
6157 if (remove == 1)
6158 {
6159 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6160
6161 return (-1);
6162 }
6163
6164 if (potfile_disable == 1)
6165 {
6166 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6167
6168 return (-1);
6169 }
6170 }
6171
6172 uint attack_kern = ATTACK_KERN_NONE;
6173
6174 switch (attack_mode)
6175 {
6176 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6177 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6178 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6179 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6180 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6181 }
6182
6183 if (benchmark == 0)
6184 {
6185 if (keyspace == 1)
6186 {
6187 int num_additional_params = 1;
6188
6189 if (attack_kern == ATTACK_KERN_COMBI)
6190 {
6191 num_additional_params = 2;
6192 }
6193
6194 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6195
6196 if (keyspace_wordlist_specified == 0) optind--;
6197 }
6198
6199 if (attack_kern == ATTACK_KERN_NONE)
6200 {
6201 if ((optind + 1) != myargc)
6202 {
6203 usage_mini_print (myargv[0]);
6204
6205 return (-1);
6206 }
6207 }
6208 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6209 {
6210 if ((optind + 1) > myargc)
6211 {
6212 usage_mini_print (myargv[0]);
6213
6214 return (-1);
6215 }
6216 }
6217 else if (attack_kern == ATTACK_KERN_COMBI)
6218 {
6219 if ((optind + 3) != myargc)
6220 {
6221 usage_mini_print (myargv[0]);
6222
6223 return (-1);
6224 }
6225 }
6226 else if (attack_kern == ATTACK_KERN_BF)
6227 {
6228 if ((optind + 1) > myargc)
6229 {
6230 usage_mini_print (myargv[0]);
6231
6232 return (-1);
6233 }
6234 }
6235 else
6236 {
6237 usage_mini_print (myargv[0]);
6238
6239 return (-1);
6240 }
6241 }
6242 else
6243 {
6244 if (myargv[optind] != 0)
6245 {
6246 log_error ("ERROR: Invalid argument for benchmark mode specified");
6247
6248 return (-1);
6249 }
6250
6251 if (attack_mode_chgd == 1)
6252 {
6253 if (attack_mode != ATTACK_MODE_BF)
6254 {
6255 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6256
6257 return (-1);
6258 }
6259 }
6260 }
6261
6262 if (skip != 0 && limit != 0)
6263 {
6264 limit += skip;
6265 }
6266
6267 if (keyspace == 1)
6268 {
6269 if (show == 1)
6270 {
6271 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6272
6273 return (-1);
6274 }
6275 else if (left == 1)
6276 {
6277 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6278
6279 return (-1);
6280 }
6281
6282 potfile_disable = 1;
6283
6284 restore_disable = 1;
6285
6286 restore = 0;
6287
6288 weak_hash_threshold = 0;
6289
6290 quiet = 1;
6291 }
6292
6293 if (remove_timer_chgd == 1)
6294 {
6295 if (remove == 0)
6296 {
6297 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6298
6299 return (-1);
6300 }
6301
6302 if (remove_timer < 1)
6303 {
6304 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6305
6306 return (-1);
6307 }
6308 }
6309
6310 if (loopback == 1)
6311 {
6312 if (attack_mode == ATTACK_MODE_BF)
6313 {
6314 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6315
6316 return (-1);
6317 }
6318 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6319 {
6320 if ((rp_files_cnt == 0) && (rp_gen == 0))
6321 {
6322 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6323
6324 return (-1);
6325 }
6326 }
6327 }
6328
6329 if (debug_mode > 0)
6330 {
6331 if (attack_mode != ATTACK_MODE_STRAIGHT)
6332 {
6333 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6334
6335 return (-1);
6336 }
6337
6338 if ((rp_files_cnt == 0) && (rp_gen == 0))
6339 {
6340 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6341
6342 return (-1);
6343 }
6344 }
6345
6346 if (debug_mode > 4)
6347 {
6348 log_error ("ERROR: Invalid debug-mode specified");
6349
6350 return (-1);
6351 }
6352
6353 if (debug_file != NULL)
6354 {
6355 if (debug_mode < 1)
6356 {
6357 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6358
6359 return (-1);
6360 }
6361 }
6362
6363 if (induction_dir != NULL)
6364 {
6365 if (attack_mode == ATTACK_MODE_BF)
6366 {
6367 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6368
6369 return (-1);
6370 }
6371 }
6372
6373 if (attack_mode != ATTACK_MODE_STRAIGHT)
6374 {
6375 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6376 {
6377 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6378
6379 return (-1);
6380 }
6381
6382 weak_hash_threshold = 0;
6383 }
6384
6385 /**
6386 * induction directory
6387 */
6388
6389 char *induction_directory = NULL;
6390
6391 if (attack_mode != ATTACK_MODE_BF)
6392 {
6393 if (induction_dir == NULL)
6394 {
6395 induction_directory = (char *) mymalloc (session_size);
6396
6397 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6398
6399 // create induction folder if it does not already exist
6400
6401 if (keyspace == 0)
6402 {
6403 if (rmdir (induction_directory) == -1)
6404 {
6405 if (errno == ENOENT)
6406 {
6407 // good, we can ignore
6408 }
6409 else if (errno == ENOTEMPTY)
6410 {
6411 char *induction_directory_mv = (char *) mymalloc (session_size);
6412
6413 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6414
6415 if (rename (induction_directory, induction_directory_mv) != 0)
6416 {
6417 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6418
6419 return (-1);
6420 }
6421 }
6422 else
6423 {
6424 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6425
6426 return (-1);
6427 }
6428 }
6429
6430 if (mkdir (induction_directory, 0700) == -1)
6431 {
6432 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6433
6434 return (-1);
6435 }
6436 }
6437 }
6438 else
6439 {
6440 induction_directory = induction_dir;
6441 }
6442 }
6443
6444 data.induction_directory = induction_directory;
6445
6446 /**
6447 * loopback
6448 */
6449
6450 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6451
6452 char *loopback_file = (char *) mymalloc (loopback_size);
6453
6454 /**
6455 * tuning db
6456 */
6457
6458 char tuning_db_file[256] = { 0 };
6459
6460 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6461
6462 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6463
6464 /**
6465 * outfile-check directory
6466 */
6467
6468 char *outfile_check_directory = NULL;
6469
6470 if (outfile_check_dir == NULL)
6471 {
6472 outfile_check_directory = (char *) mymalloc (session_size);
6473
6474 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6475 }
6476 else
6477 {
6478 outfile_check_directory = outfile_check_dir;
6479 }
6480
6481 data.outfile_check_directory = outfile_check_directory;
6482
6483 if (keyspace == 0)
6484 {
6485 struct stat outfile_check_stat;
6486
6487 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6488 {
6489 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6490
6491 if (is_dir == 0)
6492 {
6493 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6494
6495 return (-1);
6496 }
6497 }
6498 else if (outfile_check_dir == NULL)
6499 {
6500 if (mkdir (outfile_check_directory, 0700) == -1)
6501 {
6502 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6503
6504 return (-1);
6505 }
6506 }
6507 }
6508
6509 /**
6510 * special other stuff
6511 */
6512
6513 if (hash_mode == 9710)
6514 {
6515 outfile_format = 5;
6516 outfile_format_chgd = 1;
6517 }
6518
6519 if (hash_mode == 9810)
6520 {
6521 outfile_format = 5;
6522 outfile_format_chgd = 1;
6523 }
6524
6525 if (hash_mode == 10410)
6526 {
6527 outfile_format = 5;
6528 outfile_format_chgd = 1;
6529 }
6530
6531 /**
6532 * store stuff
6533 */
6534
6535 data.hash_mode = hash_mode;
6536 data.restore = restore;
6537 data.restore_timer = restore_timer;
6538 data.restore_disable = restore_disable;
6539 data.status = status;
6540 data.status_timer = status_timer;
6541 data.status_automat = status_automat;
6542 data.loopback = loopback;
6543 data.runtime = runtime;
6544 data.remove = remove;
6545 data.remove_timer = remove_timer;
6546 data.debug_mode = debug_mode;
6547 data.debug_file = debug_file;
6548 data.username = username;
6549 data.quiet = quiet;
6550 data.outfile = outfile;
6551 data.outfile_format = outfile_format;
6552 data.outfile_autohex = outfile_autohex;
6553 data.hex_charset = hex_charset;
6554 data.hex_salt = hex_salt;
6555 data.hex_wordlist = hex_wordlist;
6556 data.separator = separator;
6557 data.rp_files = rp_files;
6558 data.rp_files_cnt = rp_files_cnt;
6559 data.rp_gen = rp_gen;
6560 data.rp_gen_seed = rp_gen_seed;
6561 data.force = force;
6562 data.benchmark = benchmark;
6563 data.benchmark_repeats = benchmark_repeats;
6564 data.skip = skip;
6565 data.limit = limit;
6566 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6567 data.powertune_enable = powertune_enable;
6568 #endif
6569 data.logfile_disable = logfile_disable;
6570 data.truecrypt_keyfiles = truecrypt_keyfiles;
6571 data.scrypt_tmto = scrypt_tmto;
6572 data.workload_profile = workload_profile;
6573
6574 /**
6575 * cpu affinity
6576 */
6577
6578 if (cpu_affinity)
6579 {
6580 set_cpu_affinity (cpu_affinity);
6581 }
6582
6583 if (rp_gen_seed_chgd == 0)
6584 {
6585 srand (proc_start);
6586 }
6587 else
6588 {
6589 srand (rp_gen_seed);
6590 }
6591
6592 /**
6593 * logfile init
6594 */
6595
6596 if (logfile_disable == 0)
6597 {
6598 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6599
6600 char *logfile = (char *) mymalloc (logfile_size);
6601
6602 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6603
6604 data.logfile = logfile;
6605
6606 char *topid = logfile_generate_topid ();
6607
6608 data.topid = topid;
6609 }
6610
6611 // logfile_append() checks for logfile_disable internally to make it easier from here
6612
6613 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6614 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6615 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6616 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6617 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6618 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6619 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6620 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6621 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6622 #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));
6623
6624 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6625 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6626 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6627 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6628 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6629 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6630 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6631 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6632
6633 logfile_top_msg ("START");
6634
6635 logfile_top_uint (attack_mode);
6636 logfile_top_uint (attack_kern);
6637 logfile_top_uint (benchmark);
6638 logfile_top_uint (benchmark_repeats);
6639 logfile_top_uint (bitmap_min);
6640 logfile_top_uint (bitmap_max);
6641 logfile_top_uint (debug_mode);
6642 logfile_top_uint (force);
6643 logfile_top_uint (kernel_accel);
6644 logfile_top_uint (kernel_loops);
6645 logfile_top_uint (gpu_temp_disable);
6646 #ifdef HAVE_HWMON
6647 logfile_top_uint (gpu_temp_abort);
6648 logfile_top_uint (gpu_temp_retain);
6649 #endif
6650 logfile_top_uint (hash_mode);
6651 logfile_top_uint (hex_charset);
6652 logfile_top_uint (hex_salt);
6653 logfile_top_uint (hex_wordlist);
6654 logfile_top_uint (increment);
6655 logfile_top_uint (increment_max);
6656 logfile_top_uint (increment_min);
6657 logfile_top_uint (keyspace);
6658 logfile_top_uint (left);
6659 logfile_top_uint (logfile_disable);
6660 logfile_top_uint (loopback);
6661 logfile_top_uint (markov_classic);
6662 logfile_top_uint (markov_disable);
6663 logfile_top_uint (markov_threshold);
6664 logfile_top_uint (outfile_autohex);
6665 logfile_top_uint (outfile_check_timer);
6666 logfile_top_uint (outfile_format);
6667 logfile_top_uint (potfile_disable);
6668 logfile_top_string (potfile_path);
6669 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6670 logfile_top_uint (powertune_enable);
6671 #endif
6672 logfile_top_uint (scrypt_tmto);
6673 logfile_top_uint (quiet);
6674 logfile_top_uint (remove);
6675 logfile_top_uint (remove_timer);
6676 logfile_top_uint (restore);
6677 logfile_top_uint (restore_disable);
6678 logfile_top_uint (restore_timer);
6679 logfile_top_uint (rp_gen);
6680 logfile_top_uint (rp_gen_func_max);
6681 logfile_top_uint (rp_gen_func_min);
6682 logfile_top_uint (rp_gen_seed);
6683 logfile_top_uint (runtime);
6684 logfile_top_uint (segment_size);
6685 logfile_top_uint (show);
6686 logfile_top_uint (status);
6687 logfile_top_uint (status_automat);
6688 logfile_top_uint (status_timer);
6689 logfile_top_uint (usage);
6690 logfile_top_uint (username);
6691 logfile_top_uint (version);
6692 logfile_top_uint (weak_hash_threshold);
6693 logfile_top_uint (workload_profile);
6694 logfile_top_uint64 (limit);
6695 logfile_top_uint64 (skip);
6696 logfile_top_char (separator);
6697 logfile_top_string (cpu_affinity);
6698 logfile_top_string (custom_charset_1);
6699 logfile_top_string (custom_charset_2);
6700 logfile_top_string (custom_charset_3);
6701 logfile_top_string (custom_charset_4);
6702 logfile_top_string (debug_file);
6703 logfile_top_string (opencl_devices);
6704 logfile_top_string (opencl_platforms);
6705 logfile_top_string (opencl_device_types);
6706 logfile_top_uint (opencl_vector_width);
6707 logfile_top_string (induction_dir);
6708 logfile_top_string (markov_hcstat);
6709 logfile_top_string (outfile);
6710 logfile_top_string (outfile_check_dir);
6711 logfile_top_string (rule_buf_l);
6712 logfile_top_string (rule_buf_r);
6713 logfile_top_string (session);
6714 logfile_top_string (truecrypt_keyfiles);
6715
6716 /**
6717 * Init OpenCL library loader
6718 */
6719
6720 if (keyspace == 0)
6721 {
6722 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6723
6724 ocl_init (ocl);
6725
6726 data.ocl = ocl;
6727 }
6728
6729 /**
6730 * OpenCL platform selection
6731 */
6732
6733 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6734
6735 /**
6736 * OpenCL device selection
6737 */
6738
6739 u32 devices_filter = setup_devices_filter (opencl_devices);
6740
6741 /**
6742 * OpenCL device type selection
6743 */
6744
6745 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6746
6747 /**
6748 * benchmark
6749 */
6750
6751 if (benchmark == 1)
6752 {
6753 /**
6754 * disable useless stuff for benchmark
6755 */
6756
6757 status_timer = 0;
6758 restore_timer = 0;
6759 restore_disable = 1;
6760 potfile_disable = 1;
6761 weak_hash_threshold = 0;
6762 gpu_temp_disable = 1;
6763
6764 data.status_timer = status_timer;
6765 data.restore_timer = restore_timer;
6766 data.restore_disable = restore_disable;
6767
6768 /**
6769 * force attack mode to be bruteforce
6770 */
6771
6772 attack_mode = ATTACK_MODE_BF;
6773 attack_kern = ATTACK_KERN_BF;
6774
6775 if (workload_profile_chgd == 0)
6776 {
6777 workload_profile = 3;
6778
6779 data.workload_profile = workload_profile;
6780 }
6781 }
6782
6783 /**
6784 * config
6785 */
6786
6787 uint hash_type = 0;
6788 uint salt_type = 0;
6789 uint attack_exec = 0;
6790 uint opts_type = 0;
6791 uint kern_type = 0;
6792 uint dgst_size = 0;
6793 uint esalt_size = 0;
6794 uint opti_type = 0;
6795 uint dgst_pos0 = -1;
6796 uint dgst_pos1 = -1;
6797 uint dgst_pos2 = -1;
6798 uint dgst_pos3 = -1;
6799
6800 int (*parse_func) (char *, uint, hash_t *);
6801 int (*sort_by_digest) (const void *, const void *);
6802
6803 uint algorithm_pos = 0;
6804 uint algorithm_max = 1;
6805
6806 uint *algorithms = default_benchmark_algorithms;
6807
6808 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6809
6810 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6811 {
6812 /*
6813 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6814 * the following algos are skipped entirely
6815 */
6816
6817 if (algorithm_pos > 0)
6818 {
6819 local_free (rd);
6820
6821 rd = init_restore (argc, argv);
6822
6823 data.rd = rd;
6824 }
6825
6826 /**
6827 * update hash_mode in case of multihash benchmark
6828 */
6829
6830 if (benchmark == 1)
6831 {
6832 if (hash_mode_chgd == 0)
6833 {
6834 hash_mode = algorithms[algorithm_pos];
6835
6836 data.hash_mode = hash_mode;
6837 }
6838
6839 quiet = 1;
6840
6841 data.quiet = quiet;
6842 }
6843
6844 switch (hash_mode)
6845 {
6846 case 0: hash_type = HASH_TYPE_MD5;
6847 salt_type = SALT_TYPE_NONE;
6848 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6849 opts_type = OPTS_TYPE_PT_GENERATE_LE
6850 | OPTS_TYPE_PT_ADD80
6851 | OPTS_TYPE_PT_ADDBITS14;
6852 kern_type = KERN_TYPE_MD5;
6853 dgst_size = DGST_SIZE_4_4;
6854 parse_func = md5_parse_hash;
6855 sort_by_digest = sort_by_digest_4_4;
6856 opti_type = OPTI_TYPE_ZERO_BYTE
6857 | OPTI_TYPE_PRECOMPUTE_INIT
6858 | OPTI_TYPE_PRECOMPUTE_MERKLE
6859 | OPTI_TYPE_MEET_IN_MIDDLE
6860 | OPTI_TYPE_EARLY_SKIP
6861 | OPTI_TYPE_NOT_ITERATED
6862 | OPTI_TYPE_NOT_SALTED
6863 | OPTI_TYPE_RAW_HASH;
6864 dgst_pos0 = 0;
6865 dgst_pos1 = 3;
6866 dgst_pos2 = 2;
6867 dgst_pos3 = 1;
6868 break;
6869
6870 case 10: hash_type = HASH_TYPE_MD5;
6871 salt_type = SALT_TYPE_INTERN;
6872 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6873 opts_type = OPTS_TYPE_PT_GENERATE_LE
6874 | OPTS_TYPE_ST_ADD80
6875 | OPTS_TYPE_ST_ADDBITS14;
6876 kern_type = KERN_TYPE_MD5_PWSLT;
6877 dgst_size = DGST_SIZE_4_4;
6878 parse_func = md5s_parse_hash;
6879 sort_by_digest = sort_by_digest_4_4;
6880 opti_type = OPTI_TYPE_ZERO_BYTE
6881 | OPTI_TYPE_PRECOMPUTE_INIT
6882 | OPTI_TYPE_PRECOMPUTE_MERKLE
6883 | OPTI_TYPE_MEET_IN_MIDDLE
6884 | OPTI_TYPE_EARLY_SKIP
6885 | OPTI_TYPE_NOT_ITERATED
6886 | OPTI_TYPE_APPENDED_SALT
6887 | OPTI_TYPE_RAW_HASH;
6888 dgst_pos0 = 0;
6889 dgst_pos1 = 3;
6890 dgst_pos2 = 2;
6891 dgst_pos3 = 1;
6892 break;
6893
6894 case 11: hash_type = HASH_TYPE_MD5;
6895 salt_type = SALT_TYPE_INTERN;
6896 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6897 opts_type = OPTS_TYPE_PT_GENERATE_LE
6898 | OPTS_TYPE_ST_ADD80
6899 | OPTS_TYPE_ST_ADDBITS14;
6900 kern_type = KERN_TYPE_MD5_PWSLT;
6901 dgst_size = DGST_SIZE_4_4;
6902 parse_func = joomla_parse_hash;
6903 sort_by_digest = sort_by_digest_4_4;
6904 opti_type = OPTI_TYPE_ZERO_BYTE
6905 | OPTI_TYPE_PRECOMPUTE_INIT
6906 | OPTI_TYPE_PRECOMPUTE_MERKLE
6907 | OPTI_TYPE_MEET_IN_MIDDLE
6908 | OPTI_TYPE_EARLY_SKIP
6909 | OPTI_TYPE_NOT_ITERATED
6910 | OPTI_TYPE_APPENDED_SALT
6911 | OPTI_TYPE_RAW_HASH;
6912 dgst_pos0 = 0;
6913 dgst_pos1 = 3;
6914 dgst_pos2 = 2;
6915 dgst_pos3 = 1;
6916 break;
6917
6918 case 12: hash_type = HASH_TYPE_MD5;
6919 salt_type = SALT_TYPE_INTERN;
6920 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6921 opts_type = OPTS_TYPE_PT_GENERATE_LE
6922 | OPTS_TYPE_ST_ADD80
6923 | OPTS_TYPE_ST_ADDBITS14;
6924 kern_type = KERN_TYPE_MD5_PWSLT;
6925 dgst_size = DGST_SIZE_4_4;
6926 parse_func = postgresql_parse_hash;
6927 sort_by_digest = sort_by_digest_4_4;
6928 opti_type = OPTI_TYPE_ZERO_BYTE
6929 | OPTI_TYPE_PRECOMPUTE_INIT
6930 | OPTI_TYPE_PRECOMPUTE_MERKLE
6931 | OPTI_TYPE_MEET_IN_MIDDLE
6932 | OPTI_TYPE_EARLY_SKIP
6933 | OPTI_TYPE_NOT_ITERATED
6934 | OPTI_TYPE_APPENDED_SALT
6935 | OPTI_TYPE_RAW_HASH;
6936 dgst_pos0 = 0;
6937 dgst_pos1 = 3;
6938 dgst_pos2 = 2;
6939 dgst_pos3 = 1;
6940 break;
6941
6942 case 20: hash_type = HASH_TYPE_MD5;
6943 salt_type = SALT_TYPE_INTERN;
6944 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6945 opts_type = OPTS_TYPE_PT_GENERATE_LE
6946 | OPTS_TYPE_PT_ADD80
6947 | OPTS_TYPE_PT_ADDBITS14;
6948 kern_type = KERN_TYPE_MD5_SLTPW;
6949 dgst_size = DGST_SIZE_4_4;
6950 parse_func = md5s_parse_hash;
6951 sort_by_digest = sort_by_digest_4_4;
6952 opti_type = OPTI_TYPE_ZERO_BYTE
6953 | OPTI_TYPE_PRECOMPUTE_INIT
6954 | OPTI_TYPE_PRECOMPUTE_MERKLE
6955 | OPTI_TYPE_EARLY_SKIP
6956 | OPTI_TYPE_NOT_ITERATED
6957 | OPTI_TYPE_PREPENDED_SALT
6958 | OPTI_TYPE_RAW_HASH;
6959 dgst_pos0 = 0;
6960 dgst_pos1 = 3;
6961 dgst_pos2 = 2;
6962 dgst_pos3 = 1;
6963 break;
6964
6965 case 21: hash_type = HASH_TYPE_MD5;
6966 salt_type = SALT_TYPE_INTERN;
6967 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6968 opts_type = OPTS_TYPE_PT_GENERATE_LE
6969 | OPTS_TYPE_PT_ADD80
6970 | OPTS_TYPE_PT_ADDBITS14;
6971 kern_type = KERN_TYPE_MD5_SLTPW;
6972 dgst_size = DGST_SIZE_4_4;
6973 parse_func = osc_parse_hash;
6974 sort_by_digest = sort_by_digest_4_4;
6975 opti_type = OPTI_TYPE_ZERO_BYTE
6976 | OPTI_TYPE_PRECOMPUTE_INIT
6977 | OPTI_TYPE_PRECOMPUTE_MERKLE
6978 | OPTI_TYPE_EARLY_SKIP
6979 | OPTI_TYPE_NOT_ITERATED
6980 | OPTI_TYPE_PREPENDED_SALT
6981 | OPTI_TYPE_RAW_HASH;
6982 dgst_pos0 = 0;
6983 dgst_pos1 = 3;
6984 dgst_pos2 = 2;
6985 dgst_pos3 = 1;
6986 break;
6987
6988 case 22: hash_type = HASH_TYPE_MD5;
6989 salt_type = SALT_TYPE_EMBEDDED;
6990 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6991 opts_type = OPTS_TYPE_PT_GENERATE_LE
6992 | OPTS_TYPE_PT_ADD80
6993 | OPTS_TYPE_PT_ADDBITS14;
6994 kern_type = KERN_TYPE_MD5_SLTPW;
6995 dgst_size = DGST_SIZE_4_4;
6996 parse_func = netscreen_parse_hash;
6997 sort_by_digest = sort_by_digest_4_4;
6998 opti_type = OPTI_TYPE_ZERO_BYTE
6999 | OPTI_TYPE_PRECOMPUTE_INIT
7000 | OPTI_TYPE_PRECOMPUTE_MERKLE
7001 | OPTI_TYPE_EARLY_SKIP
7002 | OPTI_TYPE_NOT_ITERATED
7003 | OPTI_TYPE_PREPENDED_SALT
7004 | OPTI_TYPE_RAW_HASH;
7005 dgst_pos0 = 0;
7006 dgst_pos1 = 3;
7007 dgst_pos2 = 2;
7008 dgst_pos3 = 1;
7009 break;
7010
7011 case 23: hash_type = HASH_TYPE_MD5;
7012 salt_type = SALT_TYPE_EMBEDDED;
7013 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7014 opts_type = OPTS_TYPE_PT_GENERATE_LE
7015 | OPTS_TYPE_PT_ADD80
7016 | OPTS_TYPE_PT_ADDBITS14;
7017 kern_type = KERN_TYPE_MD5_SLTPW;
7018 dgst_size = DGST_SIZE_4_4;
7019 parse_func = skype_parse_hash;
7020 sort_by_digest = sort_by_digest_4_4;
7021 opti_type = OPTI_TYPE_ZERO_BYTE
7022 | OPTI_TYPE_PRECOMPUTE_INIT
7023 | OPTI_TYPE_PRECOMPUTE_MERKLE
7024 | OPTI_TYPE_EARLY_SKIP
7025 | OPTI_TYPE_NOT_ITERATED
7026 | OPTI_TYPE_PREPENDED_SALT
7027 | OPTI_TYPE_RAW_HASH;
7028 dgst_pos0 = 0;
7029 dgst_pos1 = 3;
7030 dgst_pos2 = 2;
7031 dgst_pos3 = 1;
7032 break;
7033
7034 case 30: hash_type = HASH_TYPE_MD5;
7035 salt_type = SALT_TYPE_INTERN;
7036 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7037 opts_type = OPTS_TYPE_PT_GENERATE_LE
7038 | OPTS_TYPE_PT_UNICODE
7039 | OPTS_TYPE_ST_ADD80
7040 | OPTS_TYPE_ST_ADDBITS14;
7041 kern_type = KERN_TYPE_MD5_PWUSLT;
7042 dgst_size = DGST_SIZE_4_4;
7043 parse_func = md5s_parse_hash;
7044 sort_by_digest = sort_by_digest_4_4;
7045 opti_type = OPTI_TYPE_ZERO_BYTE
7046 | OPTI_TYPE_PRECOMPUTE_INIT
7047 | OPTI_TYPE_PRECOMPUTE_MERKLE
7048 | OPTI_TYPE_MEET_IN_MIDDLE
7049 | OPTI_TYPE_EARLY_SKIP
7050 | OPTI_TYPE_NOT_ITERATED
7051 | OPTI_TYPE_APPENDED_SALT
7052 | OPTI_TYPE_RAW_HASH;
7053 dgst_pos0 = 0;
7054 dgst_pos1 = 3;
7055 dgst_pos2 = 2;
7056 dgst_pos3 = 1;
7057 break;
7058
7059 case 40: hash_type = HASH_TYPE_MD5;
7060 salt_type = SALT_TYPE_INTERN;
7061 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7062 opts_type = OPTS_TYPE_PT_GENERATE_LE
7063 | OPTS_TYPE_PT_ADD80
7064 | OPTS_TYPE_PT_ADDBITS14
7065 | OPTS_TYPE_PT_UNICODE;
7066 kern_type = KERN_TYPE_MD5_SLTPWU;
7067 dgst_size = DGST_SIZE_4_4;
7068 parse_func = md5s_parse_hash;
7069 sort_by_digest = sort_by_digest_4_4;
7070 opti_type = OPTI_TYPE_ZERO_BYTE
7071 | OPTI_TYPE_PRECOMPUTE_INIT
7072 | OPTI_TYPE_PRECOMPUTE_MERKLE
7073 | OPTI_TYPE_EARLY_SKIP
7074 | OPTI_TYPE_NOT_ITERATED
7075 | OPTI_TYPE_PREPENDED_SALT
7076 | OPTI_TYPE_RAW_HASH;
7077 dgst_pos0 = 0;
7078 dgst_pos1 = 3;
7079 dgst_pos2 = 2;
7080 dgst_pos3 = 1;
7081 break;
7082
7083 case 50: hash_type = HASH_TYPE_MD5;
7084 salt_type = SALT_TYPE_INTERN;
7085 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7086 opts_type = OPTS_TYPE_PT_GENERATE_LE
7087 | OPTS_TYPE_ST_ADD80
7088 | OPTS_TYPE_ST_ADDBITS14;
7089 kern_type = KERN_TYPE_HMACMD5_PW;
7090 dgst_size = DGST_SIZE_4_4;
7091 parse_func = hmacmd5_parse_hash;
7092 sort_by_digest = sort_by_digest_4_4;
7093 opti_type = OPTI_TYPE_ZERO_BYTE
7094 | OPTI_TYPE_NOT_ITERATED;
7095 dgst_pos0 = 0;
7096 dgst_pos1 = 3;
7097 dgst_pos2 = 2;
7098 dgst_pos3 = 1;
7099 break;
7100
7101 case 60: hash_type = HASH_TYPE_MD5;
7102 salt_type = SALT_TYPE_INTERN;
7103 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7104 opts_type = OPTS_TYPE_PT_GENERATE_LE
7105 | OPTS_TYPE_PT_ADD80
7106 | OPTS_TYPE_PT_ADDBITS14;
7107 kern_type = KERN_TYPE_HMACMD5_SLT;
7108 dgst_size = DGST_SIZE_4_4;
7109 parse_func = hmacmd5_parse_hash;
7110 sort_by_digest = sort_by_digest_4_4;
7111 opti_type = OPTI_TYPE_ZERO_BYTE
7112 | OPTI_TYPE_NOT_ITERATED;
7113 dgst_pos0 = 0;
7114 dgst_pos1 = 3;
7115 dgst_pos2 = 2;
7116 dgst_pos3 = 1;
7117 break;
7118
7119 case 100: hash_type = HASH_TYPE_SHA1;
7120 salt_type = SALT_TYPE_NONE;
7121 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7122 opts_type = OPTS_TYPE_PT_GENERATE_BE
7123 | OPTS_TYPE_PT_ADD80
7124 | OPTS_TYPE_PT_ADDBITS15;
7125 kern_type = KERN_TYPE_SHA1;
7126 dgst_size = DGST_SIZE_4_5;
7127 parse_func = sha1_parse_hash;
7128 sort_by_digest = sort_by_digest_4_5;
7129 opti_type = OPTI_TYPE_ZERO_BYTE
7130 | OPTI_TYPE_PRECOMPUTE_INIT
7131 | OPTI_TYPE_PRECOMPUTE_MERKLE
7132 | OPTI_TYPE_EARLY_SKIP
7133 | OPTI_TYPE_NOT_ITERATED
7134 | OPTI_TYPE_NOT_SALTED
7135 | OPTI_TYPE_RAW_HASH;
7136 dgst_pos0 = 3;
7137 dgst_pos1 = 4;
7138 dgst_pos2 = 2;
7139 dgst_pos3 = 1;
7140 break;
7141
7142 case 101: hash_type = HASH_TYPE_SHA1;
7143 salt_type = SALT_TYPE_NONE;
7144 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7145 opts_type = OPTS_TYPE_PT_GENERATE_BE
7146 | OPTS_TYPE_PT_ADD80
7147 | OPTS_TYPE_PT_ADDBITS15;
7148 kern_type = KERN_TYPE_SHA1;
7149 dgst_size = DGST_SIZE_4_5;
7150 parse_func = sha1b64_parse_hash;
7151 sort_by_digest = sort_by_digest_4_5;
7152 opti_type = OPTI_TYPE_ZERO_BYTE
7153 | OPTI_TYPE_PRECOMPUTE_INIT
7154 | OPTI_TYPE_PRECOMPUTE_MERKLE
7155 | OPTI_TYPE_EARLY_SKIP
7156 | OPTI_TYPE_NOT_ITERATED
7157 | OPTI_TYPE_NOT_SALTED
7158 | OPTI_TYPE_RAW_HASH;
7159 dgst_pos0 = 3;
7160 dgst_pos1 = 4;
7161 dgst_pos2 = 2;
7162 dgst_pos3 = 1;
7163 break;
7164
7165 case 110: hash_type = HASH_TYPE_SHA1;
7166 salt_type = SALT_TYPE_INTERN;
7167 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7168 opts_type = OPTS_TYPE_PT_GENERATE_BE
7169 | OPTS_TYPE_ST_ADD80
7170 | OPTS_TYPE_ST_ADDBITS15;
7171 kern_type = KERN_TYPE_SHA1_PWSLT;
7172 dgst_size = DGST_SIZE_4_5;
7173 parse_func = sha1s_parse_hash;
7174 sort_by_digest = sort_by_digest_4_5;
7175 opti_type = OPTI_TYPE_ZERO_BYTE
7176 | OPTI_TYPE_PRECOMPUTE_INIT
7177 | OPTI_TYPE_PRECOMPUTE_MERKLE
7178 | OPTI_TYPE_EARLY_SKIP
7179 | OPTI_TYPE_NOT_ITERATED
7180 | OPTI_TYPE_APPENDED_SALT
7181 | OPTI_TYPE_RAW_HASH;
7182 dgst_pos0 = 3;
7183 dgst_pos1 = 4;
7184 dgst_pos2 = 2;
7185 dgst_pos3 = 1;
7186 break;
7187
7188 case 111: hash_type = HASH_TYPE_SHA1;
7189 salt_type = SALT_TYPE_EMBEDDED;
7190 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7191 opts_type = OPTS_TYPE_PT_GENERATE_BE
7192 | OPTS_TYPE_ST_ADD80
7193 | OPTS_TYPE_ST_ADDBITS15;
7194 kern_type = KERN_TYPE_SHA1_PWSLT;
7195 dgst_size = DGST_SIZE_4_5;
7196 parse_func = sha1b64s_parse_hash;
7197 sort_by_digest = sort_by_digest_4_5;
7198 opti_type = OPTI_TYPE_ZERO_BYTE
7199 | OPTI_TYPE_PRECOMPUTE_INIT
7200 | OPTI_TYPE_PRECOMPUTE_MERKLE
7201 | OPTI_TYPE_EARLY_SKIP
7202 | OPTI_TYPE_NOT_ITERATED
7203 | OPTI_TYPE_APPENDED_SALT
7204 | OPTI_TYPE_RAW_HASH;
7205 dgst_pos0 = 3;
7206 dgst_pos1 = 4;
7207 dgst_pos2 = 2;
7208 dgst_pos3 = 1;
7209 break;
7210
7211 case 112: hash_type = HASH_TYPE_SHA1;
7212 salt_type = SALT_TYPE_INTERN;
7213 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7214 opts_type = OPTS_TYPE_PT_GENERATE_BE
7215 | OPTS_TYPE_ST_ADD80
7216 | OPTS_TYPE_ST_ADDBITS15
7217 | OPTS_TYPE_ST_HEX;
7218 kern_type = KERN_TYPE_SHA1_PWSLT;
7219 dgst_size = DGST_SIZE_4_5;
7220 parse_func = oracles_parse_hash;
7221 sort_by_digest = sort_by_digest_4_5;
7222 opti_type = OPTI_TYPE_ZERO_BYTE
7223 | OPTI_TYPE_PRECOMPUTE_INIT
7224 | OPTI_TYPE_PRECOMPUTE_MERKLE
7225 | OPTI_TYPE_EARLY_SKIP
7226 | OPTI_TYPE_NOT_ITERATED
7227 | OPTI_TYPE_APPENDED_SALT
7228 | OPTI_TYPE_RAW_HASH;
7229 dgst_pos0 = 3;
7230 dgst_pos1 = 4;
7231 dgst_pos2 = 2;
7232 dgst_pos3 = 1;
7233 break;
7234
7235 case 120: hash_type = HASH_TYPE_SHA1;
7236 salt_type = SALT_TYPE_INTERN;
7237 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7238 opts_type = OPTS_TYPE_PT_GENERATE_BE
7239 | OPTS_TYPE_PT_ADD80
7240 | OPTS_TYPE_PT_ADDBITS15;
7241 kern_type = KERN_TYPE_SHA1_SLTPW;
7242 dgst_size = DGST_SIZE_4_5;
7243 parse_func = sha1s_parse_hash;
7244 sort_by_digest = sort_by_digest_4_5;
7245 opti_type = OPTI_TYPE_ZERO_BYTE
7246 | OPTI_TYPE_PRECOMPUTE_INIT
7247 | OPTI_TYPE_PRECOMPUTE_MERKLE
7248 | OPTI_TYPE_EARLY_SKIP
7249 | OPTI_TYPE_NOT_ITERATED
7250 | OPTI_TYPE_PREPENDED_SALT
7251 | OPTI_TYPE_RAW_HASH;
7252 dgst_pos0 = 3;
7253 dgst_pos1 = 4;
7254 dgst_pos2 = 2;
7255 dgst_pos3 = 1;
7256 break;
7257
7258 case 121: hash_type = HASH_TYPE_SHA1;
7259 salt_type = SALT_TYPE_INTERN;
7260 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7261 opts_type = OPTS_TYPE_PT_GENERATE_BE
7262 | OPTS_TYPE_PT_ADD80
7263 | OPTS_TYPE_PT_ADDBITS15
7264 | OPTS_TYPE_ST_LOWER;
7265 kern_type = KERN_TYPE_SHA1_SLTPW;
7266 dgst_size = DGST_SIZE_4_5;
7267 parse_func = smf_parse_hash;
7268 sort_by_digest = sort_by_digest_4_5;
7269 opti_type = OPTI_TYPE_ZERO_BYTE
7270 | OPTI_TYPE_PRECOMPUTE_INIT
7271 | OPTI_TYPE_PRECOMPUTE_MERKLE
7272 | OPTI_TYPE_EARLY_SKIP
7273 | OPTI_TYPE_NOT_ITERATED
7274 | OPTI_TYPE_PREPENDED_SALT
7275 | OPTI_TYPE_RAW_HASH;
7276 dgst_pos0 = 3;
7277 dgst_pos1 = 4;
7278 dgst_pos2 = 2;
7279 dgst_pos3 = 1;
7280 break;
7281
7282 case 122: hash_type = HASH_TYPE_SHA1;
7283 salt_type = SALT_TYPE_EMBEDDED;
7284 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7285 opts_type = OPTS_TYPE_PT_GENERATE_BE
7286 | OPTS_TYPE_PT_ADD80
7287 | OPTS_TYPE_PT_ADDBITS15
7288 | OPTS_TYPE_ST_HEX;
7289 kern_type = KERN_TYPE_SHA1_SLTPW;
7290 dgst_size = DGST_SIZE_4_5;
7291 parse_func = osx1_parse_hash;
7292 sort_by_digest = sort_by_digest_4_5;
7293 opti_type = OPTI_TYPE_ZERO_BYTE
7294 | OPTI_TYPE_PRECOMPUTE_INIT
7295 | OPTI_TYPE_PRECOMPUTE_MERKLE
7296 | OPTI_TYPE_EARLY_SKIP
7297 | OPTI_TYPE_NOT_ITERATED
7298 | OPTI_TYPE_PREPENDED_SALT
7299 | OPTI_TYPE_RAW_HASH;
7300 dgst_pos0 = 3;
7301 dgst_pos1 = 4;
7302 dgst_pos2 = 2;
7303 dgst_pos3 = 1;
7304 break;
7305
7306 case 124: hash_type = HASH_TYPE_SHA1;
7307 salt_type = SALT_TYPE_EMBEDDED;
7308 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7309 opts_type = OPTS_TYPE_PT_GENERATE_BE
7310 | OPTS_TYPE_PT_ADD80
7311 | OPTS_TYPE_PT_ADDBITS15;
7312 kern_type = KERN_TYPE_SHA1_SLTPW;
7313 dgst_size = DGST_SIZE_4_5;
7314 parse_func = djangosha1_parse_hash;
7315 sort_by_digest = sort_by_digest_4_5;
7316 opti_type = OPTI_TYPE_ZERO_BYTE
7317 | OPTI_TYPE_PRECOMPUTE_INIT
7318 | OPTI_TYPE_PRECOMPUTE_MERKLE
7319 | OPTI_TYPE_EARLY_SKIP
7320 | OPTI_TYPE_NOT_ITERATED
7321 | OPTI_TYPE_PREPENDED_SALT
7322 | OPTI_TYPE_RAW_HASH;
7323 dgst_pos0 = 3;
7324 dgst_pos1 = 4;
7325 dgst_pos2 = 2;
7326 dgst_pos3 = 1;
7327 break;
7328
7329 case 125: hash_type = HASH_TYPE_SHA1;
7330 salt_type = SALT_TYPE_EMBEDDED;
7331 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7332 opts_type = OPTS_TYPE_PT_GENERATE_BE
7333 | OPTS_TYPE_PT_ADD80
7334 | OPTS_TYPE_PT_ADDBITS15
7335 | OPTS_TYPE_ST_HEX;
7336 kern_type = KERN_TYPE_SHA1_SLTPW;
7337 dgst_size = DGST_SIZE_4_5;
7338 parse_func = arubaos_parse_hash;
7339 sort_by_digest = sort_by_digest_4_5;
7340 opti_type = OPTI_TYPE_ZERO_BYTE
7341 | OPTI_TYPE_PRECOMPUTE_INIT
7342 | OPTI_TYPE_PRECOMPUTE_MERKLE
7343 | OPTI_TYPE_EARLY_SKIP
7344 | OPTI_TYPE_NOT_ITERATED
7345 | OPTI_TYPE_PREPENDED_SALT
7346 | OPTI_TYPE_RAW_HASH;
7347 dgst_pos0 = 3;
7348 dgst_pos1 = 4;
7349 dgst_pos2 = 2;
7350 dgst_pos3 = 1;
7351 break;
7352
7353 case 130: hash_type = HASH_TYPE_SHA1;
7354 salt_type = SALT_TYPE_INTERN;
7355 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7356 opts_type = OPTS_TYPE_PT_GENERATE_BE
7357 | OPTS_TYPE_PT_UNICODE
7358 | OPTS_TYPE_ST_ADD80
7359 | OPTS_TYPE_ST_ADDBITS15;
7360 kern_type = KERN_TYPE_SHA1_PWUSLT;
7361 dgst_size = DGST_SIZE_4_5;
7362 parse_func = sha1s_parse_hash;
7363 sort_by_digest = sort_by_digest_4_5;
7364 opti_type = OPTI_TYPE_ZERO_BYTE
7365 | OPTI_TYPE_PRECOMPUTE_INIT
7366 | OPTI_TYPE_PRECOMPUTE_MERKLE
7367 | OPTI_TYPE_EARLY_SKIP
7368 | OPTI_TYPE_NOT_ITERATED
7369 | OPTI_TYPE_APPENDED_SALT
7370 | OPTI_TYPE_RAW_HASH;
7371 dgst_pos0 = 3;
7372 dgst_pos1 = 4;
7373 dgst_pos2 = 2;
7374 dgst_pos3 = 1;
7375 break;
7376
7377 case 131: hash_type = HASH_TYPE_SHA1;
7378 salt_type = SALT_TYPE_EMBEDDED;
7379 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7380 opts_type = OPTS_TYPE_PT_GENERATE_BE
7381 | OPTS_TYPE_PT_UNICODE
7382 | OPTS_TYPE_PT_UPPER
7383 | OPTS_TYPE_ST_ADD80
7384 | OPTS_TYPE_ST_ADDBITS15
7385 | OPTS_TYPE_ST_HEX;
7386 kern_type = KERN_TYPE_SHA1_PWUSLT;
7387 dgst_size = DGST_SIZE_4_5;
7388 parse_func = mssql2000_parse_hash;
7389 sort_by_digest = sort_by_digest_4_5;
7390 opti_type = OPTI_TYPE_ZERO_BYTE
7391 | OPTI_TYPE_PRECOMPUTE_INIT
7392 | OPTI_TYPE_PRECOMPUTE_MERKLE
7393 | OPTI_TYPE_EARLY_SKIP
7394 | OPTI_TYPE_NOT_ITERATED
7395 | OPTI_TYPE_APPENDED_SALT
7396 | OPTI_TYPE_RAW_HASH;
7397 dgst_pos0 = 3;
7398 dgst_pos1 = 4;
7399 dgst_pos2 = 2;
7400 dgst_pos3 = 1;
7401 break;
7402
7403 case 132: hash_type = HASH_TYPE_SHA1;
7404 salt_type = SALT_TYPE_EMBEDDED;
7405 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7406 opts_type = OPTS_TYPE_PT_GENERATE_BE
7407 | OPTS_TYPE_PT_UNICODE
7408 | OPTS_TYPE_ST_ADD80
7409 | OPTS_TYPE_ST_ADDBITS15
7410 | OPTS_TYPE_ST_HEX;
7411 kern_type = KERN_TYPE_SHA1_PWUSLT;
7412 dgst_size = DGST_SIZE_4_5;
7413 parse_func = mssql2005_parse_hash;
7414 sort_by_digest = sort_by_digest_4_5;
7415 opti_type = OPTI_TYPE_ZERO_BYTE
7416 | OPTI_TYPE_PRECOMPUTE_INIT
7417 | OPTI_TYPE_PRECOMPUTE_MERKLE
7418 | OPTI_TYPE_EARLY_SKIP
7419 | OPTI_TYPE_NOT_ITERATED
7420 | OPTI_TYPE_APPENDED_SALT
7421 | OPTI_TYPE_RAW_HASH;
7422 dgst_pos0 = 3;
7423 dgst_pos1 = 4;
7424 dgst_pos2 = 2;
7425 dgst_pos3 = 1;
7426 break;
7427
7428 case 133: hash_type = HASH_TYPE_SHA1;
7429 salt_type = SALT_TYPE_EMBEDDED;
7430 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7431 opts_type = OPTS_TYPE_PT_GENERATE_BE
7432 | OPTS_TYPE_PT_UNICODE
7433 | OPTS_TYPE_ST_ADD80
7434 | OPTS_TYPE_ST_ADDBITS15;
7435 kern_type = KERN_TYPE_SHA1_PWUSLT;
7436 dgst_size = DGST_SIZE_4_5;
7437 parse_func = peoplesoft_parse_hash;
7438 sort_by_digest = sort_by_digest_4_5;
7439 opti_type = OPTI_TYPE_ZERO_BYTE
7440 | OPTI_TYPE_PRECOMPUTE_INIT
7441 | OPTI_TYPE_PRECOMPUTE_MERKLE
7442 | OPTI_TYPE_EARLY_SKIP
7443 | OPTI_TYPE_NOT_ITERATED
7444 | OPTI_TYPE_APPENDED_SALT
7445 | OPTI_TYPE_RAW_HASH;
7446 dgst_pos0 = 3;
7447 dgst_pos1 = 4;
7448 dgst_pos2 = 2;
7449 dgst_pos3 = 1;
7450 break;
7451
7452 case 140: hash_type = HASH_TYPE_SHA1;
7453 salt_type = SALT_TYPE_INTERN;
7454 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7455 opts_type = OPTS_TYPE_PT_GENERATE_BE
7456 | OPTS_TYPE_PT_ADD80
7457 | OPTS_TYPE_PT_ADDBITS15
7458 | OPTS_TYPE_PT_UNICODE;
7459 kern_type = KERN_TYPE_SHA1_SLTPWU;
7460 dgst_size = DGST_SIZE_4_5;
7461 parse_func = sha1s_parse_hash;
7462 sort_by_digest = sort_by_digest_4_5;
7463 opti_type = OPTI_TYPE_ZERO_BYTE
7464 | OPTI_TYPE_PRECOMPUTE_INIT
7465 | OPTI_TYPE_PRECOMPUTE_MERKLE
7466 | OPTI_TYPE_EARLY_SKIP
7467 | OPTI_TYPE_NOT_ITERATED
7468 | OPTI_TYPE_PREPENDED_SALT
7469 | OPTI_TYPE_RAW_HASH;
7470 dgst_pos0 = 3;
7471 dgst_pos1 = 4;
7472 dgst_pos2 = 2;
7473 dgst_pos3 = 1;
7474 break;
7475
7476 case 141: hash_type = HASH_TYPE_SHA1;
7477 salt_type = SALT_TYPE_EMBEDDED;
7478 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7479 opts_type = OPTS_TYPE_PT_GENERATE_BE
7480 | OPTS_TYPE_PT_ADD80
7481 | OPTS_TYPE_PT_ADDBITS15
7482 | OPTS_TYPE_PT_UNICODE
7483 | OPTS_TYPE_ST_BASE64;
7484 kern_type = KERN_TYPE_SHA1_SLTPWU;
7485 dgst_size = DGST_SIZE_4_5;
7486 parse_func = episerver_parse_hash;
7487 sort_by_digest = sort_by_digest_4_5;
7488 opti_type = OPTI_TYPE_ZERO_BYTE
7489 | OPTI_TYPE_PRECOMPUTE_INIT
7490 | OPTI_TYPE_PRECOMPUTE_MERKLE
7491 | OPTI_TYPE_EARLY_SKIP
7492 | OPTI_TYPE_NOT_ITERATED
7493 | OPTI_TYPE_PREPENDED_SALT
7494 | OPTI_TYPE_RAW_HASH;
7495 dgst_pos0 = 3;
7496 dgst_pos1 = 4;
7497 dgst_pos2 = 2;
7498 dgst_pos3 = 1;
7499 break;
7500
7501 case 150: hash_type = HASH_TYPE_SHA1;
7502 salt_type = SALT_TYPE_INTERN;
7503 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7504 opts_type = OPTS_TYPE_PT_GENERATE_BE
7505 | OPTS_TYPE_ST_ADD80
7506 | OPTS_TYPE_ST_ADDBITS15;
7507 kern_type = KERN_TYPE_HMACSHA1_PW;
7508 dgst_size = DGST_SIZE_4_5;
7509 parse_func = hmacsha1_parse_hash;
7510 sort_by_digest = sort_by_digest_4_5;
7511 opti_type = OPTI_TYPE_ZERO_BYTE
7512 | OPTI_TYPE_NOT_ITERATED;
7513 dgst_pos0 = 3;
7514 dgst_pos1 = 4;
7515 dgst_pos2 = 2;
7516 dgst_pos3 = 1;
7517 break;
7518
7519 case 160: hash_type = HASH_TYPE_SHA1;
7520 salt_type = SALT_TYPE_INTERN;
7521 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7522 opts_type = OPTS_TYPE_PT_GENERATE_BE
7523 | OPTS_TYPE_PT_ADD80
7524 | OPTS_TYPE_PT_ADDBITS15;
7525 kern_type = KERN_TYPE_HMACSHA1_SLT;
7526 dgst_size = DGST_SIZE_4_5;
7527 parse_func = hmacsha1_parse_hash;
7528 sort_by_digest = sort_by_digest_4_5;
7529 opti_type = OPTI_TYPE_ZERO_BYTE
7530 | OPTI_TYPE_NOT_ITERATED;
7531 dgst_pos0 = 3;
7532 dgst_pos1 = 4;
7533 dgst_pos2 = 2;
7534 dgst_pos3 = 1;
7535 break;
7536
7537 case 190: hash_type = HASH_TYPE_SHA1;
7538 salt_type = SALT_TYPE_NONE;
7539 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7540 opts_type = OPTS_TYPE_PT_GENERATE_BE
7541 | OPTS_TYPE_PT_ADD80
7542 | OPTS_TYPE_PT_ADDBITS15;
7543 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7544 dgst_size = DGST_SIZE_4_5;
7545 parse_func = sha1linkedin_parse_hash;
7546 sort_by_digest = sort_by_digest_4_5;
7547 opti_type = OPTI_TYPE_ZERO_BYTE
7548 | OPTI_TYPE_PRECOMPUTE_INIT
7549 | OPTI_TYPE_EARLY_SKIP
7550 | OPTI_TYPE_NOT_ITERATED
7551 | OPTI_TYPE_NOT_SALTED;
7552 dgst_pos0 = 0;
7553 dgst_pos1 = 4;
7554 dgst_pos2 = 3;
7555 dgst_pos3 = 2;
7556 break;
7557
7558 case 200: hash_type = HASH_TYPE_MYSQL;
7559 salt_type = SALT_TYPE_NONE;
7560 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7561 opts_type = 0;
7562 kern_type = KERN_TYPE_MYSQL;
7563 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7564 parse_func = mysql323_parse_hash;
7565 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7566 opti_type = OPTI_TYPE_ZERO_BYTE;
7567 dgst_pos0 = 0;
7568 dgst_pos1 = 1;
7569 dgst_pos2 = 2;
7570 dgst_pos3 = 3;
7571 break;
7572
7573 case 300: hash_type = HASH_TYPE_SHA1;
7574 salt_type = SALT_TYPE_NONE;
7575 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7576 opts_type = OPTS_TYPE_PT_GENERATE_BE
7577 | OPTS_TYPE_PT_ADD80
7578 | OPTS_TYPE_PT_ADDBITS15;
7579 kern_type = KERN_TYPE_MYSQL41;
7580 dgst_size = DGST_SIZE_4_5;
7581 parse_func = sha1_parse_hash;
7582 sort_by_digest = sort_by_digest_4_5;
7583 opti_type = OPTI_TYPE_ZERO_BYTE
7584 | OPTI_TYPE_PRECOMPUTE_INIT
7585 | OPTI_TYPE_PRECOMPUTE_MERKLE
7586 | OPTI_TYPE_EARLY_SKIP
7587 | OPTI_TYPE_NOT_ITERATED
7588 | OPTI_TYPE_NOT_SALTED;
7589 dgst_pos0 = 3;
7590 dgst_pos1 = 4;
7591 dgst_pos2 = 2;
7592 dgst_pos3 = 1;
7593 break;
7594
7595 case 400: hash_type = HASH_TYPE_MD5;
7596 salt_type = SALT_TYPE_EMBEDDED;
7597 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7598 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7599 kern_type = KERN_TYPE_PHPASS;
7600 dgst_size = DGST_SIZE_4_4;
7601 parse_func = phpass_parse_hash;
7602 sort_by_digest = sort_by_digest_4_4;
7603 opti_type = OPTI_TYPE_ZERO_BYTE;
7604 dgst_pos0 = 0;
7605 dgst_pos1 = 1;
7606 dgst_pos2 = 2;
7607 dgst_pos3 = 3;
7608 break;
7609
7610 case 500: hash_type = HASH_TYPE_MD5;
7611 salt_type = SALT_TYPE_EMBEDDED;
7612 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7613 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7614 kern_type = KERN_TYPE_MD5CRYPT;
7615 dgst_size = DGST_SIZE_4_4;
7616 parse_func = md5crypt_parse_hash;
7617 sort_by_digest = sort_by_digest_4_4;
7618 opti_type = OPTI_TYPE_ZERO_BYTE;
7619 dgst_pos0 = 0;
7620 dgst_pos1 = 1;
7621 dgst_pos2 = 2;
7622 dgst_pos3 = 3;
7623 break;
7624
7625 case 501: hash_type = HASH_TYPE_MD5;
7626 salt_type = SALT_TYPE_EMBEDDED;
7627 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7628 opts_type = OPTS_TYPE_PT_GENERATE_LE
7629 | OPTS_TYPE_HASH_COPY;
7630 kern_type = KERN_TYPE_MD5CRYPT;
7631 dgst_size = DGST_SIZE_4_4;
7632 parse_func = juniper_parse_hash;
7633 sort_by_digest = sort_by_digest_4_4;
7634 opti_type = OPTI_TYPE_ZERO_BYTE;
7635 dgst_pos0 = 0;
7636 dgst_pos1 = 1;
7637 dgst_pos2 = 2;
7638 dgst_pos3 = 3;
7639 break;
7640
7641 case 900: hash_type = HASH_TYPE_MD4;
7642 salt_type = SALT_TYPE_NONE;
7643 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7644 opts_type = OPTS_TYPE_PT_GENERATE_LE
7645 | OPTS_TYPE_PT_ADD80
7646 | OPTS_TYPE_PT_ADDBITS14;
7647 kern_type = KERN_TYPE_MD4;
7648 dgst_size = DGST_SIZE_4_4;
7649 parse_func = md4_parse_hash;
7650 sort_by_digest = sort_by_digest_4_4;
7651 opti_type = OPTI_TYPE_ZERO_BYTE
7652 | OPTI_TYPE_PRECOMPUTE_INIT
7653 | OPTI_TYPE_PRECOMPUTE_MERKLE
7654 | OPTI_TYPE_MEET_IN_MIDDLE
7655 | OPTI_TYPE_EARLY_SKIP
7656 | OPTI_TYPE_NOT_ITERATED
7657 | OPTI_TYPE_NOT_SALTED
7658 | OPTI_TYPE_RAW_HASH;
7659 dgst_pos0 = 0;
7660 dgst_pos1 = 3;
7661 dgst_pos2 = 2;
7662 dgst_pos3 = 1;
7663 break;
7664
7665 case 1000: hash_type = HASH_TYPE_MD4;
7666 salt_type = SALT_TYPE_NONE;
7667 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7668 opts_type = OPTS_TYPE_PT_GENERATE_LE
7669 | OPTS_TYPE_PT_ADD80
7670 | OPTS_TYPE_PT_ADDBITS14
7671 | OPTS_TYPE_PT_UNICODE;
7672 kern_type = KERN_TYPE_MD4_PWU;
7673 dgst_size = DGST_SIZE_4_4;
7674 parse_func = md4_parse_hash;
7675 sort_by_digest = sort_by_digest_4_4;
7676 opti_type = OPTI_TYPE_ZERO_BYTE
7677 | OPTI_TYPE_PRECOMPUTE_INIT
7678 | OPTI_TYPE_PRECOMPUTE_MERKLE
7679 | OPTI_TYPE_MEET_IN_MIDDLE
7680 | OPTI_TYPE_EARLY_SKIP
7681 | OPTI_TYPE_NOT_ITERATED
7682 | OPTI_TYPE_NOT_SALTED
7683 | OPTI_TYPE_RAW_HASH;
7684 dgst_pos0 = 0;
7685 dgst_pos1 = 3;
7686 dgst_pos2 = 2;
7687 dgst_pos3 = 1;
7688 break;
7689
7690 case 1100: hash_type = HASH_TYPE_MD4;
7691 salt_type = SALT_TYPE_INTERN;
7692 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7693 opts_type = OPTS_TYPE_PT_GENERATE_LE
7694 | OPTS_TYPE_PT_ADD80
7695 | OPTS_TYPE_PT_ADDBITS14
7696 | OPTS_TYPE_PT_UNICODE
7697 | OPTS_TYPE_ST_ADD80
7698 | OPTS_TYPE_ST_UNICODE
7699 | OPTS_TYPE_ST_LOWER;
7700 kern_type = KERN_TYPE_MD44_PWUSLT;
7701 dgst_size = DGST_SIZE_4_4;
7702 parse_func = dcc_parse_hash;
7703 sort_by_digest = sort_by_digest_4_4;
7704 opti_type = OPTI_TYPE_ZERO_BYTE
7705 | OPTI_TYPE_PRECOMPUTE_INIT
7706 | OPTI_TYPE_PRECOMPUTE_MERKLE
7707 | OPTI_TYPE_EARLY_SKIP
7708 | OPTI_TYPE_NOT_ITERATED;
7709 dgst_pos0 = 0;
7710 dgst_pos1 = 3;
7711 dgst_pos2 = 2;
7712 dgst_pos3 = 1;
7713 break;
7714
7715 case 1400: hash_type = HASH_TYPE_SHA256;
7716 salt_type = SALT_TYPE_NONE;
7717 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7718 opts_type = OPTS_TYPE_PT_GENERATE_BE
7719 | OPTS_TYPE_PT_ADD80
7720 | OPTS_TYPE_PT_ADDBITS15;
7721 kern_type = KERN_TYPE_SHA256;
7722 dgst_size = DGST_SIZE_4_8;
7723 parse_func = sha256_parse_hash;
7724 sort_by_digest = sort_by_digest_4_8;
7725 opti_type = OPTI_TYPE_ZERO_BYTE
7726 | OPTI_TYPE_PRECOMPUTE_INIT
7727 | OPTI_TYPE_PRECOMPUTE_MERKLE
7728 | OPTI_TYPE_EARLY_SKIP
7729 | OPTI_TYPE_NOT_ITERATED
7730 | OPTI_TYPE_NOT_SALTED
7731 | OPTI_TYPE_RAW_HASH;
7732 dgst_pos0 = 3;
7733 dgst_pos1 = 7;
7734 dgst_pos2 = 2;
7735 dgst_pos3 = 6;
7736 break;
7737
7738 case 1410: hash_type = HASH_TYPE_SHA256;
7739 salt_type = SALT_TYPE_INTERN;
7740 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7741 opts_type = OPTS_TYPE_PT_GENERATE_BE
7742 | OPTS_TYPE_ST_ADD80
7743 | OPTS_TYPE_ST_ADDBITS15;
7744 kern_type = KERN_TYPE_SHA256_PWSLT;
7745 dgst_size = DGST_SIZE_4_8;
7746 parse_func = sha256s_parse_hash;
7747 sort_by_digest = sort_by_digest_4_8;
7748 opti_type = OPTI_TYPE_ZERO_BYTE
7749 | OPTI_TYPE_PRECOMPUTE_INIT
7750 | OPTI_TYPE_PRECOMPUTE_MERKLE
7751 | OPTI_TYPE_EARLY_SKIP
7752 | OPTI_TYPE_NOT_ITERATED
7753 | OPTI_TYPE_APPENDED_SALT
7754 | OPTI_TYPE_RAW_HASH;
7755 dgst_pos0 = 3;
7756 dgst_pos1 = 7;
7757 dgst_pos2 = 2;
7758 dgst_pos3 = 6;
7759 break;
7760
7761 case 1420: hash_type = HASH_TYPE_SHA256;
7762 salt_type = SALT_TYPE_INTERN;
7763 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7764 opts_type = OPTS_TYPE_PT_GENERATE_BE
7765 | OPTS_TYPE_PT_ADD80
7766 | OPTS_TYPE_PT_ADDBITS15;
7767 kern_type = KERN_TYPE_SHA256_SLTPW;
7768 dgst_size = DGST_SIZE_4_8;
7769 parse_func = sha256s_parse_hash;
7770 sort_by_digest = sort_by_digest_4_8;
7771 opti_type = OPTI_TYPE_ZERO_BYTE
7772 | OPTI_TYPE_PRECOMPUTE_INIT
7773 | OPTI_TYPE_PRECOMPUTE_MERKLE
7774 | OPTI_TYPE_EARLY_SKIP
7775 | OPTI_TYPE_NOT_ITERATED
7776 | OPTI_TYPE_PREPENDED_SALT
7777 | OPTI_TYPE_RAW_HASH;
7778 dgst_pos0 = 3;
7779 dgst_pos1 = 7;
7780 dgst_pos2 = 2;
7781 dgst_pos3 = 6;
7782 break;
7783
7784 case 1421: hash_type = HASH_TYPE_SHA256;
7785 salt_type = SALT_TYPE_EMBEDDED;
7786 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7787 opts_type = OPTS_TYPE_PT_GENERATE_BE
7788 | OPTS_TYPE_PT_ADD80
7789 | OPTS_TYPE_PT_ADDBITS15;
7790 kern_type = KERN_TYPE_SHA256_SLTPW;
7791 dgst_size = DGST_SIZE_4_8;
7792 parse_func = hmailserver_parse_hash;
7793 sort_by_digest = sort_by_digest_4_8;
7794 opti_type = OPTI_TYPE_ZERO_BYTE
7795 | OPTI_TYPE_PRECOMPUTE_INIT
7796 | OPTI_TYPE_PRECOMPUTE_MERKLE
7797 | OPTI_TYPE_EARLY_SKIP
7798 | OPTI_TYPE_NOT_ITERATED
7799 | OPTI_TYPE_PREPENDED_SALT
7800 | OPTI_TYPE_RAW_HASH;
7801 dgst_pos0 = 3;
7802 dgst_pos1 = 7;
7803 dgst_pos2 = 2;
7804 dgst_pos3 = 6;
7805 break;
7806
7807 case 1430: hash_type = HASH_TYPE_SHA256;
7808 salt_type = SALT_TYPE_INTERN;
7809 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7810 opts_type = OPTS_TYPE_PT_GENERATE_BE
7811 | OPTS_TYPE_PT_UNICODE
7812 | OPTS_TYPE_ST_ADD80
7813 | OPTS_TYPE_ST_ADDBITS15;
7814 kern_type = KERN_TYPE_SHA256_PWUSLT;
7815 dgst_size = DGST_SIZE_4_8;
7816 parse_func = sha256s_parse_hash;
7817 sort_by_digest = sort_by_digest_4_8;
7818 opti_type = OPTI_TYPE_ZERO_BYTE
7819 | OPTI_TYPE_PRECOMPUTE_INIT
7820 | OPTI_TYPE_PRECOMPUTE_MERKLE
7821 | OPTI_TYPE_EARLY_SKIP
7822 | OPTI_TYPE_NOT_ITERATED
7823 | OPTI_TYPE_APPENDED_SALT
7824 | OPTI_TYPE_RAW_HASH;
7825 dgst_pos0 = 3;
7826 dgst_pos1 = 7;
7827 dgst_pos2 = 2;
7828 dgst_pos3 = 6;
7829 break;
7830
7831 case 1440: hash_type = HASH_TYPE_SHA256;
7832 salt_type = SALT_TYPE_INTERN;
7833 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7834 opts_type = OPTS_TYPE_PT_GENERATE_BE
7835 | OPTS_TYPE_PT_ADD80
7836 | OPTS_TYPE_PT_ADDBITS15
7837 | OPTS_TYPE_PT_UNICODE;
7838 kern_type = KERN_TYPE_SHA256_SLTPWU;
7839 dgst_size = DGST_SIZE_4_8;
7840 parse_func = sha256s_parse_hash;
7841 sort_by_digest = sort_by_digest_4_8;
7842 opti_type = OPTI_TYPE_ZERO_BYTE
7843 | OPTI_TYPE_PRECOMPUTE_INIT
7844 | OPTI_TYPE_PRECOMPUTE_MERKLE
7845 | OPTI_TYPE_EARLY_SKIP
7846 | OPTI_TYPE_NOT_ITERATED
7847 | OPTI_TYPE_PREPENDED_SALT
7848 | OPTI_TYPE_RAW_HASH;
7849 dgst_pos0 = 3;
7850 dgst_pos1 = 7;
7851 dgst_pos2 = 2;
7852 dgst_pos3 = 6;
7853 break;
7854
7855 case 1441: hash_type = HASH_TYPE_SHA256;
7856 salt_type = SALT_TYPE_EMBEDDED;
7857 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7858 opts_type = OPTS_TYPE_PT_GENERATE_BE
7859 | OPTS_TYPE_PT_ADD80
7860 | OPTS_TYPE_PT_ADDBITS15
7861 | OPTS_TYPE_PT_UNICODE
7862 | OPTS_TYPE_ST_BASE64;
7863 kern_type = KERN_TYPE_SHA256_SLTPWU;
7864 dgst_size = DGST_SIZE_4_8;
7865 parse_func = episerver4_parse_hash;
7866 sort_by_digest = sort_by_digest_4_8;
7867 opti_type = OPTI_TYPE_ZERO_BYTE
7868 | OPTI_TYPE_PRECOMPUTE_INIT
7869 | OPTI_TYPE_PRECOMPUTE_MERKLE
7870 | OPTI_TYPE_EARLY_SKIP
7871 | OPTI_TYPE_NOT_ITERATED
7872 | OPTI_TYPE_PREPENDED_SALT
7873 | OPTI_TYPE_RAW_HASH;
7874 dgst_pos0 = 3;
7875 dgst_pos1 = 7;
7876 dgst_pos2 = 2;
7877 dgst_pos3 = 6;
7878 break;
7879
7880 case 1450: hash_type = HASH_TYPE_SHA256;
7881 salt_type = SALT_TYPE_INTERN;
7882 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7883 opts_type = OPTS_TYPE_PT_GENERATE_BE
7884 | OPTS_TYPE_ST_ADD80;
7885 kern_type = KERN_TYPE_HMACSHA256_PW;
7886 dgst_size = DGST_SIZE_4_8;
7887 parse_func = hmacsha256_parse_hash;
7888 sort_by_digest = sort_by_digest_4_8;
7889 opti_type = OPTI_TYPE_ZERO_BYTE
7890 | OPTI_TYPE_NOT_ITERATED;
7891 dgst_pos0 = 3;
7892 dgst_pos1 = 7;
7893 dgst_pos2 = 2;
7894 dgst_pos3 = 6;
7895 break;
7896
7897 case 1460: hash_type = HASH_TYPE_SHA256;
7898 salt_type = SALT_TYPE_INTERN;
7899 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7900 opts_type = OPTS_TYPE_PT_GENERATE_BE
7901 | OPTS_TYPE_PT_ADD80
7902 | OPTS_TYPE_PT_ADDBITS15;
7903 kern_type = KERN_TYPE_HMACSHA256_SLT;
7904 dgst_size = DGST_SIZE_4_8;
7905 parse_func = hmacsha256_parse_hash;
7906 sort_by_digest = sort_by_digest_4_8;
7907 opti_type = OPTI_TYPE_ZERO_BYTE
7908 | OPTI_TYPE_NOT_ITERATED;
7909 dgst_pos0 = 3;
7910 dgst_pos1 = 7;
7911 dgst_pos2 = 2;
7912 dgst_pos3 = 6;
7913 break;
7914
7915 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7916 salt_type = SALT_TYPE_EMBEDDED;
7917 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7918 opts_type = OPTS_TYPE_PT_GENERATE_LE
7919 | OPTS_TYPE_PT_BITSLICE;
7920 kern_type = KERN_TYPE_DESCRYPT;
7921 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7922 parse_func = descrypt_parse_hash;
7923 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7924 opti_type = OPTI_TYPE_ZERO_BYTE
7925 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7926 dgst_pos0 = 0;
7927 dgst_pos1 = 1;
7928 dgst_pos2 = 2;
7929 dgst_pos3 = 3;
7930 break;
7931
7932 case 1600: hash_type = HASH_TYPE_MD5;
7933 salt_type = SALT_TYPE_EMBEDDED;
7934 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7935 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7936 kern_type = KERN_TYPE_APR1CRYPT;
7937 dgst_size = DGST_SIZE_4_4;
7938 parse_func = md5apr1_parse_hash;
7939 sort_by_digest = sort_by_digest_4_4;
7940 opti_type = OPTI_TYPE_ZERO_BYTE;
7941 dgst_pos0 = 0;
7942 dgst_pos1 = 1;
7943 dgst_pos2 = 2;
7944 dgst_pos3 = 3;
7945 break;
7946
7947 case 1700: hash_type = HASH_TYPE_SHA512;
7948 salt_type = SALT_TYPE_NONE;
7949 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7950 opts_type = OPTS_TYPE_PT_GENERATE_BE
7951 | OPTS_TYPE_PT_ADD80
7952 | OPTS_TYPE_PT_ADDBITS15;
7953 kern_type = KERN_TYPE_SHA512;
7954 dgst_size = DGST_SIZE_8_8;
7955 parse_func = sha512_parse_hash;
7956 sort_by_digest = sort_by_digest_8_8;
7957 opti_type = OPTI_TYPE_ZERO_BYTE
7958 | OPTI_TYPE_PRECOMPUTE_INIT
7959 | OPTI_TYPE_PRECOMPUTE_MERKLE
7960 | OPTI_TYPE_EARLY_SKIP
7961 | OPTI_TYPE_NOT_ITERATED
7962 | OPTI_TYPE_NOT_SALTED
7963 | OPTI_TYPE_USES_BITS_64
7964 | OPTI_TYPE_RAW_HASH;
7965 dgst_pos0 = 14;
7966 dgst_pos1 = 15;
7967 dgst_pos2 = 6;
7968 dgst_pos3 = 7;
7969 break;
7970
7971 case 1710: hash_type = HASH_TYPE_SHA512;
7972 salt_type = SALT_TYPE_INTERN;
7973 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7974 opts_type = OPTS_TYPE_PT_GENERATE_BE
7975 | OPTS_TYPE_ST_ADD80
7976 | OPTS_TYPE_ST_ADDBITS15;
7977 kern_type = KERN_TYPE_SHA512_PWSLT;
7978 dgst_size = DGST_SIZE_8_8;
7979 parse_func = sha512s_parse_hash;
7980 sort_by_digest = sort_by_digest_8_8;
7981 opti_type = OPTI_TYPE_ZERO_BYTE
7982 | OPTI_TYPE_PRECOMPUTE_INIT
7983 | OPTI_TYPE_PRECOMPUTE_MERKLE
7984 | OPTI_TYPE_EARLY_SKIP
7985 | OPTI_TYPE_NOT_ITERATED
7986 | OPTI_TYPE_APPENDED_SALT
7987 | OPTI_TYPE_USES_BITS_64
7988 | OPTI_TYPE_RAW_HASH;
7989 dgst_pos0 = 14;
7990 dgst_pos1 = 15;
7991 dgst_pos2 = 6;
7992 dgst_pos3 = 7;
7993 break;
7994
7995 case 1711: hash_type = HASH_TYPE_SHA512;
7996 salt_type = SALT_TYPE_EMBEDDED;
7997 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7998 opts_type = OPTS_TYPE_PT_GENERATE_BE
7999 | OPTS_TYPE_ST_ADD80
8000 | OPTS_TYPE_ST_ADDBITS15;
8001 kern_type = KERN_TYPE_SHA512_PWSLT;
8002 dgst_size = DGST_SIZE_8_8;
8003 parse_func = sha512b64s_parse_hash;
8004 sort_by_digest = sort_by_digest_8_8;
8005 opti_type = OPTI_TYPE_ZERO_BYTE
8006 | OPTI_TYPE_PRECOMPUTE_INIT
8007 | OPTI_TYPE_PRECOMPUTE_MERKLE
8008 | OPTI_TYPE_EARLY_SKIP
8009 | OPTI_TYPE_NOT_ITERATED
8010 | OPTI_TYPE_APPENDED_SALT
8011 | OPTI_TYPE_USES_BITS_64
8012 | OPTI_TYPE_RAW_HASH;
8013 dgst_pos0 = 14;
8014 dgst_pos1 = 15;
8015 dgst_pos2 = 6;
8016 dgst_pos3 = 7;
8017 break;
8018
8019 case 1720: hash_type = HASH_TYPE_SHA512;
8020 salt_type = SALT_TYPE_INTERN;
8021 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8022 opts_type = OPTS_TYPE_PT_GENERATE_BE
8023 | OPTS_TYPE_PT_ADD80
8024 | OPTS_TYPE_PT_ADDBITS15;
8025 kern_type = KERN_TYPE_SHA512_SLTPW;
8026 dgst_size = DGST_SIZE_8_8;
8027 parse_func = sha512s_parse_hash;
8028 sort_by_digest = sort_by_digest_8_8;
8029 opti_type = OPTI_TYPE_ZERO_BYTE
8030 | OPTI_TYPE_PRECOMPUTE_INIT
8031 | OPTI_TYPE_PRECOMPUTE_MERKLE
8032 | OPTI_TYPE_EARLY_SKIP
8033 | OPTI_TYPE_NOT_ITERATED
8034 | OPTI_TYPE_PREPENDED_SALT
8035 | OPTI_TYPE_USES_BITS_64
8036 | OPTI_TYPE_RAW_HASH;
8037 dgst_pos0 = 14;
8038 dgst_pos1 = 15;
8039 dgst_pos2 = 6;
8040 dgst_pos3 = 7;
8041 break;
8042
8043 case 1722: hash_type = HASH_TYPE_SHA512;
8044 salt_type = SALT_TYPE_EMBEDDED;
8045 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8046 opts_type = OPTS_TYPE_PT_GENERATE_BE
8047 | OPTS_TYPE_PT_ADD80
8048 | OPTS_TYPE_PT_ADDBITS15
8049 | OPTS_TYPE_ST_HEX;
8050 kern_type = KERN_TYPE_SHA512_SLTPW;
8051 dgst_size = DGST_SIZE_8_8;
8052 parse_func = osx512_parse_hash;
8053 sort_by_digest = sort_by_digest_8_8;
8054 opti_type = OPTI_TYPE_ZERO_BYTE
8055 | OPTI_TYPE_PRECOMPUTE_INIT
8056 | OPTI_TYPE_PRECOMPUTE_MERKLE
8057 | OPTI_TYPE_EARLY_SKIP
8058 | OPTI_TYPE_NOT_ITERATED
8059 | OPTI_TYPE_PREPENDED_SALT
8060 | OPTI_TYPE_USES_BITS_64
8061 | OPTI_TYPE_RAW_HASH;
8062 dgst_pos0 = 14;
8063 dgst_pos1 = 15;
8064 dgst_pos2 = 6;
8065 dgst_pos3 = 7;
8066 break;
8067
8068 case 1730: hash_type = HASH_TYPE_SHA512;
8069 salt_type = SALT_TYPE_INTERN;
8070 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8071 opts_type = OPTS_TYPE_PT_GENERATE_BE
8072 | OPTS_TYPE_PT_UNICODE
8073 | OPTS_TYPE_ST_ADD80
8074 | OPTS_TYPE_ST_ADDBITS15;
8075 kern_type = KERN_TYPE_SHA512_PWSLTU;
8076 dgst_size = DGST_SIZE_8_8;
8077 parse_func = sha512s_parse_hash;
8078 sort_by_digest = sort_by_digest_8_8;
8079 opti_type = OPTI_TYPE_ZERO_BYTE
8080 | OPTI_TYPE_PRECOMPUTE_INIT
8081 | OPTI_TYPE_PRECOMPUTE_MERKLE
8082 | OPTI_TYPE_EARLY_SKIP
8083 | OPTI_TYPE_NOT_ITERATED
8084 | OPTI_TYPE_APPENDED_SALT
8085 | OPTI_TYPE_USES_BITS_64
8086 | OPTI_TYPE_RAW_HASH;
8087 dgst_pos0 = 14;
8088 dgst_pos1 = 15;
8089 dgst_pos2 = 6;
8090 dgst_pos3 = 7;
8091 break;
8092
8093 case 1731: hash_type = HASH_TYPE_SHA512;
8094 salt_type = SALT_TYPE_EMBEDDED;
8095 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8096 opts_type = OPTS_TYPE_PT_GENERATE_BE
8097 | OPTS_TYPE_PT_UNICODE
8098 | OPTS_TYPE_ST_ADD80
8099 | OPTS_TYPE_ST_ADDBITS15
8100 | OPTS_TYPE_ST_HEX;
8101 kern_type = KERN_TYPE_SHA512_PWSLTU;
8102 dgst_size = DGST_SIZE_8_8;
8103 parse_func = mssql2012_parse_hash;
8104 sort_by_digest = sort_by_digest_8_8;
8105 opti_type = OPTI_TYPE_ZERO_BYTE
8106 | OPTI_TYPE_PRECOMPUTE_INIT
8107 | OPTI_TYPE_PRECOMPUTE_MERKLE
8108 | OPTI_TYPE_EARLY_SKIP
8109 | OPTI_TYPE_NOT_ITERATED
8110 | OPTI_TYPE_APPENDED_SALT
8111 | OPTI_TYPE_USES_BITS_64
8112 | OPTI_TYPE_RAW_HASH;
8113 dgst_pos0 = 14;
8114 dgst_pos1 = 15;
8115 dgst_pos2 = 6;
8116 dgst_pos3 = 7;
8117 break;
8118
8119 case 1740: hash_type = HASH_TYPE_SHA512;
8120 salt_type = SALT_TYPE_INTERN;
8121 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8122 opts_type = OPTS_TYPE_PT_GENERATE_BE
8123 | OPTS_TYPE_PT_ADD80
8124 | OPTS_TYPE_PT_ADDBITS15
8125 | OPTS_TYPE_PT_UNICODE;
8126 kern_type = KERN_TYPE_SHA512_SLTPWU;
8127 dgst_size = DGST_SIZE_8_8;
8128 parse_func = sha512s_parse_hash;
8129 sort_by_digest = sort_by_digest_8_8;
8130 opti_type = OPTI_TYPE_ZERO_BYTE
8131 | OPTI_TYPE_PRECOMPUTE_INIT
8132 | OPTI_TYPE_PRECOMPUTE_MERKLE
8133 | OPTI_TYPE_EARLY_SKIP
8134 | OPTI_TYPE_NOT_ITERATED
8135 | OPTI_TYPE_PREPENDED_SALT
8136 | OPTI_TYPE_USES_BITS_64
8137 | OPTI_TYPE_RAW_HASH;
8138 dgst_pos0 = 14;
8139 dgst_pos1 = 15;
8140 dgst_pos2 = 6;
8141 dgst_pos3 = 7;
8142 break;
8143
8144 case 1750: hash_type = HASH_TYPE_SHA512;
8145 salt_type = SALT_TYPE_INTERN;
8146 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8147 opts_type = OPTS_TYPE_PT_GENERATE_BE
8148 | OPTS_TYPE_ST_ADD80;
8149 kern_type = KERN_TYPE_HMACSHA512_PW;
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 1760: hash_type = HASH_TYPE_SHA512;
8163 salt_type = SALT_TYPE_INTERN;
8164 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8165 opts_type = OPTS_TYPE_PT_GENERATE_BE
8166 | OPTS_TYPE_PT_ADD80
8167 | OPTS_TYPE_PT_ADDBITS15;
8168 kern_type = KERN_TYPE_HMACSHA512_SLT;
8169 dgst_size = DGST_SIZE_8_8;
8170 parse_func = hmacsha512_parse_hash;
8171 sort_by_digest = sort_by_digest_8_8;
8172 opti_type = OPTI_TYPE_ZERO_BYTE
8173 | OPTI_TYPE_USES_BITS_64
8174 | OPTI_TYPE_NOT_ITERATED;
8175 dgst_pos0 = 14;
8176 dgst_pos1 = 15;
8177 dgst_pos2 = 6;
8178 dgst_pos3 = 7;
8179 break;
8180
8181 case 1800: hash_type = HASH_TYPE_SHA512;
8182 salt_type = SALT_TYPE_EMBEDDED;
8183 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8184 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8185 kern_type = KERN_TYPE_SHA512CRYPT;
8186 dgst_size = DGST_SIZE_8_8;
8187 parse_func = sha512crypt_parse_hash;
8188 sort_by_digest = sort_by_digest_8_8;
8189 opti_type = OPTI_TYPE_ZERO_BYTE
8190 | OPTI_TYPE_USES_BITS_64;
8191 dgst_pos0 = 0;
8192 dgst_pos1 = 1;
8193 dgst_pos2 = 2;
8194 dgst_pos3 = 3;
8195 break;
8196
8197 case 2100: hash_type = HASH_TYPE_DCC2;
8198 salt_type = SALT_TYPE_EMBEDDED;
8199 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8200 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8201 | OPTS_TYPE_ST_LOWER
8202 | OPTS_TYPE_ST_UNICODE;
8203 kern_type = KERN_TYPE_DCC2;
8204 dgst_size = DGST_SIZE_4_4;
8205 parse_func = dcc2_parse_hash;
8206 sort_by_digest = sort_by_digest_4_4;
8207 opti_type = OPTI_TYPE_ZERO_BYTE;
8208 dgst_pos0 = 0;
8209 dgst_pos1 = 1;
8210 dgst_pos2 = 2;
8211 dgst_pos3 = 3;
8212 break;
8213
8214 case 2400: hash_type = HASH_TYPE_MD5;
8215 salt_type = SALT_TYPE_NONE;
8216 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8217 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8218 kern_type = KERN_TYPE_MD5PIX;
8219 dgst_size = DGST_SIZE_4_4;
8220 parse_func = md5pix_parse_hash;
8221 sort_by_digest = sort_by_digest_4_4;
8222 opti_type = OPTI_TYPE_ZERO_BYTE
8223 | OPTI_TYPE_PRECOMPUTE_INIT
8224 | OPTI_TYPE_PRECOMPUTE_MERKLE
8225 | OPTI_TYPE_EARLY_SKIP
8226 | OPTI_TYPE_NOT_ITERATED
8227 | OPTI_TYPE_NOT_SALTED;
8228 dgst_pos0 = 0;
8229 dgst_pos1 = 3;
8230 dgst_pos2 = 2;
8231 dgst_pos3 = 1;
8232 break;
8233
8234 case 2410: hash_type = HASH_TYPE_MD5;
8235 salt_type = SALT_TYPE_INTERN;
8236 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8237 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8238 kern_type = KERN_TYPE_MD5ASA;
8239 dgst_size = DGST_SIZE_4_4;
8240 parse_func = md5asa_parse_hash;
8241 sort_by_digest = sort_by_digest_4_4;
8242 opti_type = OPTI_TYPE_ZERO_BYTE
8243 | OPTI_TYPE_PRECOMPUTE_INIT
8244 | OPTI_TYPE_PRECOMPUTE_MERKLE
8245 | OPTI_TYPE_EARLY_SKIP
8246 | OPTI_TYPE_NOT_ITERATED;
8247 dgst_pos0 = 0;
8248 dgst_pos1 = 3;
8249 dgst_pos2 = 2;
8250 dgst_pos3 = 1;
8251 break;
8252
8253 case 2500: hash_type = HASH_TYPE_WPA;
8254 salt_type = SALT_TYPE_EMBEDDED;
8255 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8256 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8257 kern_type = KERN_TYPE_WPA;
8258 dgst_size = DGST_SIZE_4_4;
8259 parse_func = wpa_parse_hash;
8260 sort_by_digest = sort_by_digest_4_4;
8261 opti_type = OPTI_TYPE_ZERO_BYTE;
8262 dgst_pos0 = 0;
8263 dgst_pos1 = 1;
8264 dgst_pos2 = 2;
8265 dgst_pos3 = 3;
8266 break;
8267
8268 case 2600: hash_type = HASH_TYPE_MD5;
8269 salt_type = SALT_TYPE_VIRTUAL;
8270 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8271 opts_type = OPTS_TYPE_PT_GENERATE_LE
8272 | OPTS_TYPE_PT_ADD80
8273 | OPTS_TYPE_PT_ADDBITS14
8274 | OPTS_TYPE_ST_ADD80;
8275 kern_type = KERN_TYPE_MD55_PWSLT1;
8276 dgst_size = DGST_SIZE_4_4;
8277 parse_func = md5md5_parse_hash;
8278 sort_by_digest = sort_by_digest_4_4;
8279 opti_type = OPTI_TYPE_ZERO_BYTE
8280 | OPTI_TYPE_PRECOMPUTE_INIT
8281 | OPTI_TYPE_PRECOMPUTE_MERKLE
8282 | OPTI_TYPE_EARLY_SKIP;
8283 dgst_pos0 = 0;
8284 dgst_pos1 = 3;
8285 dgst_pos2 = 2;
8286 dgst_pos3 = 1;
8287 break;
8288
8289 case 2611: hash_type = HASH_TYPE_MD5;
8290 salt_type = SALT_TYPE_INTERN;
8291 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8292 opts_type = OPTS_TYPE_PT_GENERATE_LE
8293 | OPTS_TYPE_PT_ADD80
8294 | OPTS_TYPE_PT_ADDBITS14
8295 | OPTS_TYPE_ST_ADD80;
8296 kern_type = KERN_TYPE_MD55_PWSLT1;
8297 dgst_size = DGST_SIZE_4_4;
8298 parse_func = vb3_parse_hash;
8299 sort_by_digest = sort_by_digest_4_4;
8300 opti_type = OPTI_TYPE_ZERO_BYTE
8301 | OPTI_TYPE_PRECOMPUTE_INIT
8302 | OPTI_TYPE_PRECOMPUTE_MERKLE
8303 | OPTI_TYPE_EARLY_SKIP;
8304 dgst_pos0 = 0;
8305 dgst_pos1 = 3;
8306 dgst_pos2 = 2;
8307 dgst_pos3 = 1;
8308 break;
8309
8310 case 2612: hash_type = HASH_TYPE_MD5;
8311 salt_type = SALT_TYPE_EMBEDDED;
8312 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8313 opts_type = OPTS_TYPE_PT_GENERATE_LE
8314 | OPTS_TYPE_PT_ADD80
8315 | OPTS_TYPE_PT_ADDBITS14
8316 | OPTS_TYPE_ST_ADD80
8317 | OPTS_TYPE_ST_HEX;
8318 kern_type = KERN_TYPE_MD55_PWSLT1;
8319 dgst_size = DGST_SIZE_4_4;
8320 parse_func = phps_parse_hash;
8321 sort_by_digest = sort_by_digest_4_4;
8322 opti_type = OPTI_TYPE_ZERO_BYTE
8323 | OPTI_TYPE_PRECOMPUTE_INIT
8324 | OPTI_TYPE_PRECOMPUTE_MERKLE
8325 | OPTI_TYPE_EARLY_SKIP;
8326 dgst_pos0 = 0;
8327 dgst_pos1 = 3;
8328 dgst_pos2 = 2;
8329 dgst_pos3 = 1;
8330 break;
8331
8332 case 2711: hash_type = HASH_TYPE_MD5;
8333 salt_type = SALT_TYPE_INTERN;
8334 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8335 opts_type = OPTS_TYPE_PT_GENERATE_LE
8336 | OPTS_TYPE_PT_ADD80
8337 | OPTS_TYPE_PT_ADDBITS14
8338 | OPTS_TYPE_ST_ADD80;
8339 kern_type = KERN_TYPE_MD55_PWSLT2;
8340 dgst_size = DGST_SIZE_4_4;
8341 parse_func = vb30_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 2811: hash_type = HASH_TYPE_MD5;
8353 salt_type = SALT_TYPE_INTERN;
8354 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8355 opts_type = OPTS_TYPE_PT_GENERATE_LE
8356 | OPTS_TYPE_PT_ADD80
8357 | OPTS_TYPE_PT_ADDBITS14;
8358 kern_type = KERN_TYPE_MD55_SLTPW;
8359 dgst_size = DGST_SIZE_4_4;
8360 parse_func = ipb2_parse_hash;
8361 sort_by_digest = sort_by_digest_4_4;
8362 opti_type = OPTI_TYPE_ZERO_BYTE
8363 | OPTI_TYPE_PRECOMPUTE_INIT
8364 | OPTI_TYPE_EARLY_SKIP;
8365 dgst_pos0 = 0;
8366 dgst_pos1 = 3;
8367 dgst_pos2 = 2;
8368 dgst_pos3 = 1;
8369 break;
8370
8371 case 3000: hash_type = HASH_TYPE_LM;
8372 salt_type = SALT_TYPE_NONE;
8373 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8374 opts_type = OPTS_TYPE_PT_GENERATE_LE
8375 | OPTS_TYPE_PT_UPPER
8376 | OPTS_TYPE_PT_BITSLICE;
8377 kern_type = KERN_TYPE_LM;
8378 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8379 parse_func = lm_parse_hash;
8380 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8381 opti_type = OPTI_TYPE_ZERO_BYTE
8382 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8383 dgst_pos0 = 0;
8384 dgst_pos1 = 1;
8385 dgst_pos2 = 2;
8386 dgst_pos3 = 3;
8387 break;
8388
8389 case 3100: hash_type = HASH_TYPE_ORACLEH;
8390 salt_type = SALT_TYPE_INTERN;
8391 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8392 opts_type = OPTS_TYPE_PT_GENERATE_LE
8393 | OPTS_TYPE_PT_UPPER
8394 | OPTS_TYPE_ST_UPPER;
8395 kern_type = KERN_TYPE_ORACLEH;
8396 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8397 parse_func = oracleh_parse_hash;
8398 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8399 opti_type = OPTI_TYPE_ZERO_BYTE;
8400 dgst_pos0 = 0;
8401 dgst_pos1 = 1;
8402 dgst_pos2 = 2;
8403 dgst_pos3 = 3;
8404 break;
8405
8406 case 3200: hash_type = HASH_TYPE_BCRYPT;
8407 salt_type = SALT_TYPE_EMBEDDED;
8408 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8409 opts_type = OPTS_TYPE_PT_GENERATE_LE
8410 | OPTS_TYPE_ST_GENERATE_LE;
8411 kern_type = KERN_TYPE_BCRYPT;
8412 dgst_size = DGST_SIZE_4_6;
8413 parse_func = bcrypt_parse_hash;
8414 sort_by_digest = sort_by_digest_4_6;
8415 opti_type = OPTI_TYPE_ZERO_BYTE;
8416 dgst_pos0 = 0;
8417 dgst_pos1 = 1;
8418 dgst_pos2 = 2;
8419 dgst_pos3 = 3;
8420 break;
8421
8422 case 3710: hash_type = HASH_TYPE_MD5;
8423 salt_type = SALT_TYPE_INTERN;
8424 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8425 opts_type = OPTS_TYPE_PT_GENERATE_LE
8426 | OPTS_TYPE_PT_ADD80
8427 | OPTS_TYPE_PT_ADDBITS14;
8428 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8429 dgst_size = DGST_SIZE_4_4;
8430 parse_func = md5s_parse_hash;
8431 sort_by_digest = sort_by_digest_4_4;
8432 opti_type = OPTI_TYPE_ZERO_BYTE
8433 | OPTI_TYPE_PRECOMPUTE_INIT
8434 | OPTI_TYPE_PRECOMPUTE_MERKLE
8435 | OPTI_TYPE_EARLY_SKIP;
8436 dgst_pos0 = 0;
8437 dgst_pos1 = 3;
8438 dgst_pos2 = 2;
8439 dgst_pos3 = 1;
8440 break;
8441
8442 case 3711: hash_type = HASH_TYPE_MD5;
8443 salt_type = SALT_TYPE_EMBEDDED;
8444 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8445 opts_type = OPTS_TYPE_PT_GENERATE_LE
8446 | OPTS_TYPE_PT_ADD80
8447 | OPTS_TYPE_PT_ADDBITS14;
8448 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8449 dgst_size = DGST_SIZE_4_4;
8450 parse_func = mediawiki_b_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 dgst_pos0 = 0;
8457 dgst_pos1 = 3;
8458 dgst_pos2 = 2;
8459 dgst_pos3 = 1;
8460 break;
8461
8462 case 3800: hash_type = HASH_TYPE_MD5;
8463 salt_type = SALT_TYPE_INTERN;
8464 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8465 opts_type = OPTS_TYPE_PT_GENERATE_LE
8466 | OPTS_TYPE_ST_ADDBITS14;
8467 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8468 dgst_size = DGST_SIZE_4_4;
8469 parse_func = md5s_parse_hash;
8470 sort_by_digest = sort_by_digest_4_4;
8471 opti_type = OPTI_TYPE_ZERO_BYTE
8472 | OPTI_TYPE_PRECOMPUTE_INIT
8473 | OPTI_TYPE_PRECOMPUTE_MERKLE
8474 | OPTI_TYPE_EARLY_SKIP
8475 | OPTI_TYPE_NOT_ITERATED
8476 | OPTI_TYPE_RAW_HASH;
8477 dgst_pos0 = 0;
8478 dgst_pos1 = 3;
8479 dgst_pos2 = 2;
8480 dgst_pos3 = 1;
8481 break;
8482
8483 case 4300: hash_type = HASH_TYPE_MD5;
8484 salt_type = SALT_TYPE_VIRTUAL;
8485 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8486 opts_type = OPTS_TYPE_PT_GENERATE_LE
8487 | OPTS_TYPE_PT_ADD80
8488 | OPTS_TYPE_PT_ADDBITS14
8489 | OPTS_TYPE_ST_ADD80;
8490 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8491 dgst_size = DGST_SIZE_4_4;
8492 parse_func = md5md5_parse_hash;
8493 sort_by_digest = sort_by_digest_4_4;
8494 opti_type = OPTI_TYPE_ZERO_BYTE
8495 | OPTI_TYPE_PRECOMPUTE_INIT
8496 | OPTI_TYPE_PRECOMPUTE_MERKLE
8497 | OPTI_TYPE_EARLY_SKIP;
8498 dgst_pos0 = 0;
8499 dgst_pos1 = 3;
8500 dgst_pos2 = 2;
8501 dgst_pos3 = 1;
8502 break;
8503
8504
8505 case 4400: hash_type = HASH_TYPE_MD5;
8506 salt_type = SALT_TYPE_NONE;
8507 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8508 opts_type = OPTS_TYPE_PT_GENERATE_BE
8509 | OPTS_TYPE_PT_ADD80
8510 | OPTS_TYPE_PT_ADDBITS15;
8511 kern_type = KERN_TYPE_MD5_SHA1;
8512 dgst_size = DGST_SIZE_4_4;
8513 parse_func = md5_parse_hash;
8514 sort_by_digest = sort_by_digest_4_4;
8515 opti_type = OPTI_TYPE_ZERO_BYTE
8516 | OPTI_TYPE_PRECOMPUTE_INIT
8517 | OPTI_TYPE_PRECOMPUTE_MERKLE
8518 | OPTI_TYPE_EARLY_SKIP
8519 | OPTI_TYPE_NOT_ITERATED
8520 | OPTI_TYPE_NOT_SALTED
8521 | OPTI_TYPE_RAW_HASH;
8522 dgst_pos0 = 0;
8523 dgst_pos1 = 3;
8524 dgst_pos2 = 2;
8525 dgst_pos3 = 1;
8526 break;
8527
8528 case 4500: hash_type = HASH_TYPE_SHA1;
8529 salt_type = SALT_TYPE_NONE;
8530 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8531 opts_type = OPTS_TYPE_PT_GENERATE_BE
8532 | OPTS_TYPE_PT_ADD80
8533 | OPTS_TYPE_PT_ADDBITS15;
8534 kern_type = KERN_TYPE_SHA11;
8535 dgst_size = DGST_SIZE_4_5;
8536 parse_func = sha1_parse_hash;
8537 sort_by_digest = sort_by_digest_4_5;
8538 opti_type = OPTI_TYPE_ZERO_BYTE
8539 | OPTI_TYPE_PRECOMPUTE_INIT
8540 | OPTI_TYPE_PRECOMPUTE_MERKLE
8541 | OPTI_TYPE_EARLY_SKIP
8542 | OPTI_TYPE_NOT_SALTED;
8543 dgst_pos0 = 3;
8544 dgst_pos1 = 4;
8545 dgst_pos2 = 2;
8546 dgst_pos3 = 1;
8547 break;
8548
8549 case 4700: hash_type = HASH_TYPE_SHA1;
8550 salt_type = SALT_TYPE_NONE;
8551 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8552 opts_type = OPTS_TYPE_PT_GENERATE_LE
8553 | OPTS_TYPE_PT_ADD80
8554 | OPTS_TYPE_PT_ADDBITS14;
8555 kern_type = KERN_TYPE_SHA1_MD5;
8556 dgst_size = DGST_SIZE_4_5;
8557 parse_func = sha1_parse_hash;
8558 sort_by_digest = sort_by_digest_4_5;
8559 opti_type = OPTI_TYPE_ZERO_BYTE
8560 | OPTI_TYPE_PRECOMPUTE_INIT
8561 | OPTI_TYPE_PRECOMPUTE_MERKLE
8562 | OPTI_TYPE_EARLY_SKIP
8563 | OPTI_TYPE_NOT_ITERATED
8564 | OPTI_TYPE_NOT_SALTED
8565 | OPTI_TYPE_RAW_HASH;
8566 dgst_pos0 = 3;
8567 dgst_pos1 = 4;
8568 dgst_pos2 = 2;
8569 dgst_pos3 = 1;
8570 break;
8571
8572 case 4800: hash_type = HASH_TYPE_MD5;
8573 salt_type = SALT_TYPE_EMBEDDED;
8574 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8575 opts_type = OPTS_TYPE_PT_GENERATE_LE
8576 | OPTS_TYPE_PT_ADDBITS14;
8577 kern_type = KERN_TYPE_MD5_CHAP;
8578 dgst_size = DGST_SIZE_4_4;
8579 parse_func = chap_parse_hash;
8580 sort_by_digest = sort_by_digest_4_4;
8581 opti_type = OPTI_TYPE_ZERO_BYTE
8582 | OPTI_TYPE_PRECOMPUTE_INIT
8583 | OPTI_TYPE_PRECOMPUTE_MERKLE
8584 | OPTI_TYPE_MEET_IN_MIDDLE
8585 | OPTI_TYPE_EARLY_SKIP
8586 | OPTI_TYPE_NOT_ITERATED
8587 | OPTI_TYPE_RAW_HASH;
8588 dgst_pos0 = 0;
8589 dgst_pos1 = 3;
8590 dgst_pos2 = 2;
8591 dgst_pos3 = 1;
8592 break;
8593
8594 case 4900: hash_type = HASH_TYPE_SHA1;
8595 salt_type = SALT_TYPE_INTERN;
8596 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8597 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8598 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8599 dgst_size = DGST_SIZE_4_5;
8600 parse_func = sha1s_parse_hash;
8601 sort_by_digest = sort_by_digest_4_5;
8602 opti_type = OPTI_TYPE_ZERO_BYTE
8603 | OPTI_TYPE_PRECOMPUTE_INIT
8604 | OPTI_TYPE_PRECOMPUTE_MERKLE
8605 | OPTI_TYPE_EARLY_SKIP;
8606 dgst_pos0 = 3;
8607 dgst_pos1 = 4;
8608 dgst_pos2 = 2;
8609 dgst_pos3 = 1;
8610 break;
8611
8612 case 5000: hash_type = HASH_TYPE_KECCAK;
8613 salt_type = SALT_TYPE_EMBEDDED;
8614 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8615 opts_type = OPTS_TYPE_PT_GENERATE_LE
8616 | OPTS_TYPE_PT_ADD01;
8617 kern_type = KERN_TYPE_KECCAK;
8618 dgst_size = DGST_SIZE_8_25;
8619 parse_func = keccak_parse_hash;
8620 sort_by_digest = sort_by_digest_8_25;
8621 opti_type = OPTI_TYPE_ZERO_BYTE
8622 | OPTI_TYPE_USES_BITS_64
8623 | OPTI_TYPE_RAW_HASH;
8624 dgst_pos0 = 2;
8625 dgst_pos1 = 3;
8626 dgst_pos2 = 4;
8627 dgst_pos3 = 5;
8628 break;
8629
8630 case 5100: hash_type = HASH_TYPE_MD5H;
8631 salt_type = SALT_TYPE_NONE;
8632 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8633 opts_type = OPTS_TYPE_PT_GENERATE_LE
8634 | OPTS_TYPE_PT_ADD80
8635 | OPTS_TYPE_PT_ADDBITS14;
8636 kern_type = KERN_TYPE_MD5H;
8637 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8638 parse_func = md5half_parse_hash;
8639 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8640 opti_type = OPTI_TYPE_ZERO_BYTE
8641 | OPTI_TYPE_RAW_HASH;
8642 dgst_pos0 = 0;
8643 dgst_pos1 = 1;
8644 dgst_pos2 = 2;
8645 dgst_pos3 = 3;
8646 break;
8647
8648 case 5200: hash_type = HASH_TYPE_SHA256;
8649 salt_type = SALT_TYPE_EMBEDDED;
8650 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8651 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8652 kern_type = KERN_TYPE_PSAFE3;
8653 dgst_size = DGST_SIZE_4_8;
8654 parse_func = psafe3_parse_hash;
8655 sort_by_digest = sort_by_digest_4_8;
8656 opti_type = OPTI_TYPE_ZERO_BYTE;
8657 dgst_pos0 = 0;
8658 dgst_pos1 = 1;
8659 dgst_pos2 = 2;
8660 dgst_pos3 = 3;
8661 break;
8662
8663 case 5300: hash_type = HASH_TYPE_MD5;
8664 salt_type = SALT_TYPE_EMBEDDED;
8665 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8666 opts_type = OPTS_TYPE_PT_GENERATE_LE
8667 | OPTS_TYPE_ST_ADD80;
8668 kern_type = KERN_TYPE_IKEPSK_MD5;
8669 dgst_size = DGST_SIZE_4_4;
8670 parse_func = ikepsk_md5_parse_hash;
8671 sort_by_digest = sort_by_digest_4_4;
8672 opti_type = OPTI_TYPE_ZERO_BYTE;
8673 dgst_pos0 = 0;
8674 dgst_pos1 = 3;
8675 dgst_pos2 = 2;
8676 dgst_pos3 = 1;
8677 break;
8678
8679 case 5400: hash_type = HASH_TYPE_SHA1;
8680 salt_type = SALT_TYPE_EMBEDDED;
8681 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8682 opts_type = OPTS_TYPE_PT_GENERATE_BE
8683 | OPTS_TYPE_ST_ADD80;
8684 kern_type = KERN_TYPE_IKEPSK_SHA1;
8685 dgst_size = DGST_SIZE_4_5;
8686 parse_func = ikepsk_sha1_parse_hash;
8687 sort_by_digest = sort_by_digest_4_5;
8688 opti_type = OPTI_TYPE_ZERO_BYTE;
8689 dgst_pos0 = 3;
8690 dgst_pos1 = 4;
8691 dgst_pos2 = 2;
8692 dgst_pos3 = 1;
8693 break;
8694
8695 case 5500: hash_type = HASH_TYPE_NETNTLM;
8696 salt_type = SALT_TYPE_EMBEDDED;
8697 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8698 opts_type = OPTS_TYPE_PT_GENERATE_LE
8699 | OPTS_TYPE_PT_ADD80
8700 | OPTS_TYPE_PT_ADDBITS14
8701 | OPTS_TYPE_PT_UNICODE
8702 | OPTS_TYPE_ST_HEX;
8703 kern_type = KERN_TYPE_NETNTLMv1;
8704 dgst_size = DGST_SIZE_4_4;
8705 parse_func = netntlmv1_parse_hash;
8706 sort_by_digest = sort_by_digest_4_4;
8707 opti_type = OPTI_TYPE_ZERO_BYTE
8708 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8709 dgst_pos0 = 0;
8710 dgst_pos1 = 1;
8711 dgst_pos2 = 2;
8712 dgst_pos3 = 3;
8713 break;
8714
8715 case 5600: hash_type = HASH_TYPE_MD5;
8716 salt_type = SALT_TYPE_EMBEDDED;
8717 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8718 opts_type = OPTS_TYPE_PT_GENERATE_LE
8719 | OPTS_TYPE_PT_ADD80
8720 | OPTS_TYPE_PT_ADDBITS14
8721 | OPTS_TYPE_PT_UNICODE;
8722 kern_type = KERN_TYPE_NETNTLMv2;
8723 dgst_size = DGST_SIZE_4_4;
8724 parse_func = netntlmv2_parse_hash;
8725 sort_by_digest = sort_by_digest_4_4;
8726 opti_type = OPTI_TYPE_ZERO_BYTE;
8727 dgst_pos0 = 0;
8728 dgst_pos1 = 3;
8729 dgst_pos2 = 2;
8730 dgst_pos3 = 1;
8731 break;
8732
8733 case 5700: hash_type = HASH_TYPE_SHA256;
8734 salt_type = SALT_TYPE_NONE;
8735 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8736 opts_type = OPTS_TYPE_PT_GENERATE_BE
8737 | OPTS_TYPE_PT_ADD80
8738 | OPTS_TYPE_PT_ADDBITS15;
8739 kern_type = KERN_TYPE_SHA256;
8740 dgst_size = DGST_SIZE_4_8;
8741 parse_func = cisco4_parse_hash;
8742 sort_by_digest = sort_by_digest_4_8;
8743 opti_type = OPTI_TYPE_ZERO_BYTE
8744 | OPTI_TYPE_PRECOMPUTE_INIT
8745 | OPTI_TYPE_PRECOMPUTE_MERKLE
8746 | OPTI_TYPE_EARLY_SKIP
8747 | OPTI_TYPE_NOT_ITERATED
8748 | OPTI_TYPE_NOT_SALTED
8749 | OPTI_TYPE_RAW_HASH;
8750 dgst_pos0 = 3;
8751 dgst_pos1 = 7;
8752 dgst_pos2 = 2;
8753 dgst_pos3 = 6;
8754 break;
8755
8756 case 5800: hash_type = HASH_TYPE_SHA1;
8757 salt_type = SALT_TYPE_INTERN;
8758 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8759 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8760 | OPTS_TYPE_ST_ADD80;
8761 kern_type = KERN_TYPE_ANDROIDPIN;
8762 dgst_size = DGST_SIZE_4_5;
8763 parse_func = androidpin_parse_hash;
8764 sort_by_digest = sort_by_digest_4_5;
8765 opti_type = OPTI_TYPE_ZERO_BYTE;
8766 dgst_pos0 = 0;
8767 dgst_pos1 = 1;
8768 dgst_pos2 = 2;
8769 dgst_pos3 = 3;
8770 break;
8771
8772 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8773 salt_type = SALT_TYPE_NONE;
8774 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8775 opts_type = OPTS_TYPE_PT_GENERATE_LE
8776 | OPTS_TYPE_PT_ADD80;
8777 kern_type = KERN_TYPE_RIPEMD160;
8778 dgst_size = DGST_SIZE_4_5;
8779 parse_func = ripemd160_parse_hash;
8780 sort_by_digest = sort_by_digest_4_5;
8781 opti_type = OPTI_TYPE_ZERO_BYTE;
8782 dgst_pos0 = 0;
8783 dgst_pos1 = 1;
8784 dgst_pos2 = 2;
8785 dgst_pos3 = 3;
8786 break;
8787
8788 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8789 salt_type = SALT_TYPE_NONE;
8790 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8791 opts_type = OPTS_TYPE_PT_GENERATE_BE
8792 | OPTS_TYPE_PT_ADD80;
8793 kern_type = KERN_TYPE_WHIRLPOOL;
8794 dgst_size = DGST_SIZE_4_16;
8795 parse_func = whirlpool_parse_hash;
8796 sort_by_digest = sort_by_digest_4_16;
8797 opti_type = OPTI_TYPE_ZERO_BYTE;
8798 dgst_pos0 = 0;
8799 dgst_pos1 = 1;
8800 dgst_pos2 = 2;
8801 dgst_pos3 = 3;
8802 break;
8803
8804 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8805 salt_type = SALT_TYPE_EMBEDDED;
8806 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8807 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8808 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8809 dgst_size = DGST_SIZE_4_5;
8810 parse_func = truecrypt_parse_hash_2k;
8811 sort_by_digest = sort_by_digest_4_5;
8812 opti_type = OPTI_TYPE_ZERO_BYTE;
8813 dgst_pos0 = 0;
8814 dgst_pos1 = 1;
8815 dgst_pos2 = 2;
8816 dgst_pos3 = 3;
8817 break;
8818
8819 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8820 salt_type = SALT_TYPE_EMBEDDED;
8821 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8822 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8823 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8824 dgst_size = DGST_SIZE_4_5;
8825 parse_func = truecrypt_parse_hash_2k;
8826 sort_by_digest = sort_by_digest_4_5;
8827 opti_type = OPTI_TYPE_ZERO_BYTE;
8828 dgst_pos0 = 0;
8829 dgst_pos1 = 1;
8830 dgst_pos2 = 2;
8831 dgst_pos3 = 3;
8832 break;
8833
8834 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8835 salt_type = SALT_TYPE_EMBEDDED;
8836 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8837 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8838 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8839 dgst_size = DGST_SIZE_4_5;
8840 parse_func = truecrypt_parse_hash_2k;
8841 sort_by_digest = sort_by_digest_4_5;
8842 opti_type = OPTI_TYPE_ZERO_BYTE;
8843 dgst_pos0 = 0;
8844 dgst_pos1 = 1;
8845 dgst_pos2 = 2;
8846 dgst_pos3 = 3;
8847 break;
8848
8849 case 6221: hash_type = HASH_TYPE_SHA512;
8850 salt_type = SALT_TYPE_EMBEDDED;
8851 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8852 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8853 kern_type = KERN_TYPE_TCSHA512_XTS512;
8854 dgst_size = DGST_SIZE_8_8;
8855 parse_func = truecrypt_parse_hash_1k;
8856 sort_by_digest = sort_by_digest_8_8;
8857 opti_type = OPTI_TYPE_ZERO_BYTE
8858 | OPTI_TYPE_USES_BITS_64;
8859 dgst_pos0 = 0;
8860 dgst_pos1 = 1;
8861 dgst_pos2 = 2;
8862 dgst_pos3 = 3;
8863 break;
8864
8865 case 6222: hash_type = HASH_TYPE_SHA512;
8866 salt_type = SALT_TYPE_EMBEDDED;
8867 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8868 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8869 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8870 dgst_size = DGST_SIZE_8_8;
8871 parse_func = truecrypt_parse_hash_1k;
8872 sort_by_digest = sort_by_digest_8_8;
8873 opti_type = OPTI_TYPE_ZERO_BYTE
8874 | OPTI_TYPE_USES_BITS_64;
8875 dgst_pos0 = 0;
8876 dgst_pos1 = 1;
8877 dgst_pos2 = 2;
8878 dgst_pos3 = 3;
8879 break;
8880
8881 case 6223: hash_type = HASH_TYPE_SHA512;
8882 salt_type = SALT_TYPE_EMBEDDED;
8883 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8884 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8885 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8886 dgst_size = DGST_SIZE_8_8;
8887 parse_func = truecrypt_parse_hash_1k;
8888 sort_by_digest = sort_by_digest_8_8;
8889 opti_type = OPTI_TYPE_ZERO_BYTE
8890 | OPTI_TYPE_USES_BITS_64;
8891 dgst_pos0 = 0;
8892 dgst_pos1 = 1;
8893 dgst_pos2 = 2;
8894 dgst_pos3 = 3;
8895 break;
8896
8897 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8898 salt_type = SALT_TYPE_EMBEDDED;
8899 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8900 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8901 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8902 dgst_size = DGST_SIZE_4_8;
8903 parse_func = truecrypt_parse_hash_1k;
8904 sort_by_digest = sort_by_digest_4_8;
8905 opti_type = OPTI_TYPE_ZERO_BYTE;
8906 dgst_pos0 = 0;
8907 dgst_pos1 = 1;
8908 dgst_pos2 = 2;
8909 dgst_pos3 = 3;
8910 break;
8911
8912 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8913 salt_type = SALT_TYPE_EMBEDDED;
8914 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8915 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8916 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8917 dgst_size = DGST_SIZE_4_8;
8918 parse_func = truecrypt_parse_hash_1k;
8919 sort_by_digest = sort_by_digest_4_8;
8920 opti_type = OPTI_TYPE_ZERO_BYTE;
8921 dgst_pos0 = 0;
8922 dgst_pos1 = 1;
8923 dgst_pos2 = 2;
8924 dgst_pos3 = 3;
8925 break;
8926
8927 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8928 salt_type = SALT_TYPE_EMBEDDED;
8929 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8930 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8931 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8932 dgst_size = DGST_SIZE_4_8;
8933 parse_func = truecrypt_parse_hash_1k;
8934 sort_by_digest = sort_by_digest_4_8;
8935 opti_type = OPTI_TYPE_ZERO_BYTE;
8936 dgst_pos0 = 0;
8937 dgst_pos1 = 1;
8938 dgst_pos2 = 2;
8939 dgst_pos3 = 3;
8940 break;
8941
8942 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8943 salt_type = SALT_TYPE_EMBEDDED;
8944 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8945 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8946 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8947 dgst_size = DGST_SIZE_4_5;
8948 parse_func = truecrypt_parse_hash_1k;
8949 sort_by_digest = sort_by_digest_4_5;
8950 opti_type = OPTI_TYPE_ZERO_BYTE;
8951 dgst_pos0 = 0;
8952 dgst_pos1 = 1;
8953 dgst_pos2 = 2;
8954 dgst_pos3 = 3;
8955 break;
8956
8957 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8958 salt_type = SALT_TYPE_EMBEDDED;
8959 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8960 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8961 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8962 dgst_size = DGST_SIZE_4_5;
8963 parse_func = truecrypt_parse_hash_1k;
8964 sort_by_digest = sort_by_digest_4_5;
8965 opti_type = OPTI_TYPE_ZERO_BYTE;
8966 dgst_pos0 = 0;
8967 dgst_pos1 = 1;
8968 dgst_pos2 = 2;
8969 dgst_pos3 = 3;
8970 break;
8971
8972 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8973 salt_type = SALT_TYPE_EMBEDDED;
8974 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8975 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8976 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8977 dgst_size = DGST_SIZE_4_5;
8978 parse_func = truecrypt_parse_hash_1k;
8979 sort_by_digest = sort_by_digest_4_5;
8980 opti_type = OPTI_TYPE_ZERO_BYTE;
8981 dgst_pos0 = 0;
8982 dgst_pos1 = 1;
8983 dgst_pos2 = 2;
8984 dgst_pos3 = 3;
8985 break;
8986
8987 case 6300: hash_type = HASH_TYPE_MD5;
8988 salt_type = SALT_TYPE_EMBEDDED;
8989 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8990 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8991 kern_type = KERN_TYPE_MD5AIX;
8992 dgst_size = DGST_SIZE_4_4;
8993 parse_func = md5aix_parse_hash;
8994 sort_by_digest = sort_by_digest_4_4;
8995 opti_type = OPTI_TYPE_ZERO_BYTE;
8996 dgst_pos0 = 0;
8997 dgst_pos1 = 1;
8998 dgst_pos2 = 2;
8999 dgst_pos3 = 3;
9000 break;
9001
9002 case 6400: hash_type = HASH_TYPE_SHA256;
9003 salt_type = SALT_TYPE_EMBEDDED;
9004 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9005 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9006 kern_type = KERN_TYPE_SHA256AIX;
9007 dgst_size = DGST_SIZE_4_8;
9008 parse_func = sha256aix_parse_hash;
9009 sort_by_digest = sort_by_digest_4_8;
9010 opti_type = OPTI_TYPE_ZERO_BYTE;
9011 dgst_pos0 = 0;
9012 dgst_pos1 = 1;
9013 dgst_pos2 = 2;
9014 dgst_pos3 = 3;
9015 break;
9016
9017 case 6500: hash_type = HASH_TYPE_SHA512;
9018 salt_type = SALT_TYPE_EMBEDDED;
9019 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9020 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9021 kern_type = KERN_TYPE_SHA512AIX;
9022 dgst_size = DGST_SIZE_8_8;
9023 parse_func = sha512aix_parse_hash;
9024 sort_by_digest = sort_by_digest_8_8;
9025 opti_type = OPTI_TYPE_ZERO_BYTE
9026 | OPTI_TYPE_USES_BITS_64;
9027 dgst_pos0 = 0;
9028 dgst_pos1 = 1;
9029 dgst_pos2 = 2;
9030 dgst_pos3 = 3;
9031 break;
9032
9033 case 6600: hash_type = HASH_TYPE_AES;
9034 salt_type = SALT_TYPE_EMBEDDED;
9035 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9036 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9037 kern_type = KERN_TYPE_AGILEKEY;
9038 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9039 parse_func = agilekey_parse_hash;
9040 sort_by_digest = sort_by_digest_4_5;
9041 opti_type = OPTI_TYPE_ZERO_BYTE;
9042 dgst_pos0 = 0;
9043 dgst_pos1 = 1;
9044 dgst_pos2 = 2;
9045 dgst_pos3 = 3;
9046 break;
9047
9048 case 6700: hash_type = HASH_TYPE_SHA1;
9049 salt_type = SALT_TYPE_EMBEDDED;
9050 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9051 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9052 kern_type = KERN_TYPE_SHA1AIX;
9053 dgst_size = DGST_SIZE_4_5;
9054 parse_func = sha1aix_parse_hash;
9055 sort_by_digest = sort_by_digest_4_5;
9056 opti_type = OPTI_TYPE_ZERO_BYTE;
9057 dgst_pos0 = 0;
9058 dgst_pos1 = 1;
9059 dgst_pos2 = 2;
9060 dgst_pos3 = 3;
9061 break;
9062
9063 case 6800: hash_type = HASH_TYPE_AES;
9064 salt_type = SALT_TYPE_EMBEDDED;
9065 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9066 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9067 kern_type = KERN_TYPE_LASTPASS;
9068 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9069 parse_func = lastpass_parse_hash;
9070 sort_by_digest = sort_by_digest_4_8;
9071 opti_type = OPTI_TYPE_ZERO_BYTE;
9072 dgst_pos0 = 0;
9073 dgst_pos1 = 1;
9074 dgst_pos2 = 2;
9075 dgst_pos3 = 3;
9076 break;
9077
9078 case 6900: hash_type = HASH_TYPE_GOST;
9079 salt_type = SALT_TYPE_NONE;
9080 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9081 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9082 kern_type = KERN_TYPE_GOST;
9083 dgst_size = DGST_SIZE_4_8;
9084 parse_func = gost_parse_hash;
9085 sort_by_digest = sort_by_digest_4_8;
9086 opti_type = OPTI_TYPE_ZERO_BYTE;
9087 dgst_pos0 = 0;
9088 dgst_pos1 = 1;
9089 dgst_pos2 = 2;
9090 dgst_pos3 = 3;
9091 break;
9092
9093 case 7100: hash_type = HASH_TYPE_SHA512;
9094 salt_type = SALT_TYPE_EMBEDDED;
9095 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9096 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9097 kern_type = KERN_TYPE_PBKDF2_SHA512;
9098 dgst_size = DGST_SIZE_8_16;
9099 parse_func = sha512osx_parse_hash;
9100 sort_by_digest = sort_by_digest_8_16;
9101 opti_type = OPTI_TYPE_ZERO_BYTE
9102 | OPTI_TYPE_USES_BITS_64;
9103 dgst_pos0 = 0;
9104 dgst_pos1 = 1;
9105 dgst_pos2 = 2;
9106 dgst_pos3 = 3;
9107 break;
9108
9109 case 7200: hash_type = HASH_TYPE_SHA512;
9110 salt_type = SALT_TYPE_EMBEDDED;
9111 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9112 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9113 kern_type = KERN_TYPE_PBKDF2_SHA512;
9114 dgst_size = DGST_SIZE_8_16;
9115 parse_func = sha512grub_parse_hash;
9116 sort_by_digest = sort_by_digest_8_16;
9117 opti_type = OPTI_TYPE_ZERO_BYTE
9118 | OPTI_TYPE_USES_BITS_64;
9119 dgst_pos0 = 0;
9120 dgst_pos1 = 1;
9121 dgst_pos2 = 2;
9122 dgst_pos3 = 3;
9123 break;
9124
9125 case 7300: hash_type = HASH_TYPE_SHA1;
9126 salt_type = SALT_TYPE_EMBEDDED;
9127 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9128 opts_type = OPTS_TYPE_PT_GENERATE_BE
9129 | OPTS_TYPE_ST_ADD80
9130 | OPTS_TYPE_ST_ADDBITS15;
9131 kern_type = KERN_TYPE_RAKP;
9132 dgst_size = DGST_SIZE_4_5;
9133 parse_func = rakp_parse_hash;
9134 sort_by_digest = sort_by_digest_4_5;
9135 opti_type = OPTI_TYPE_ZERO_BYTE
9136 | OPTI_TYPE_NOT_ITERATED;
9137 dgst_pos0 = 3;
9138 dgst_pos1 = 4;
9139 dgst_pos2 = 2;
9140 dgst_pos3 = 1;
9141 break;
9142
9143 case 7400: hash_type = HASH_TYPE_SHA256;
9144 salt_type = SALT_TYPE_EMBEDDED;
9145 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9146 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9147 kern_type = KERN_TYPE_SHA256CRYPT;
9148 dgst_size = DGST_SIZE_4_8;
9149 parse_func = sha256crypt_parse_hash;
9150 sort_by_digest = sort_by_digest_4_8;
9151 opti_type = OPTI_TYPE_ZERO_BYTE;
9152 dgst_pos0 = 0;
9153 dgst_pos1 = 1;
9154 dgst_pos2 = 2;
9155 dgst_pos3 = 3;
9156 break;
9157
9158 case 7500: hash_type = HASH_TYPE_KRB5PA;
9159 salt_type = SALT_TYPE_EMBEDDED;
9160 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9161 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9162 kern_type = KERN_TYPE_KRB5PA;
9163 dgst_size = DGST_SIZE_4_4;
9164 parse_func = krb5pa_parse_hash;
9165 sort_by_digest = sort_by_digest_4_4;
9166 opti_type = OPTI_TYPE_ZERO_BYTE
9167 | OPTI_TYPE_NOT_ITERATED;
9168 dgst_pos0 = 0;
9169 dgst_pos1 = 1;
9170 dgst_pos2 = 2;
9171 dgst_pos3 = 3;
9172 break;
9173
9174 case 7600: hash_type = HASH_TYPE_SHA1;
9175 salt_type = SALT_TYPE_INTERN;
9176 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9177 opts_type = OPTS_TYPE_PT_GENERATE_BE
9178 | OPTS_TYPE_PT_ADD80
9179 | OPTS_TYPE_PT_ADDBITS15;
9180 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9181 dgst_size = DGST_SIZE_4_5;
9182 parse_func = redmine_parse_hash;
9183 sort_by_digest = sort_by_digest_4_5;
9184 opti_type = OPTI_TYPE_ZERO_BYTE
9185 | OPTI_TYPE_PRECOMPUTE_INIT
9186 | OPTI_TYPE_EARLY_SKIP
9187 | OPTI_TYPE_NOT_ITERATED
9188 | OPTI_TYPE_PREPENDED_SALT;
9189 dgst_pos0 = 3;
9190 dgst_pos1 = 4;
9191 dgst_pos2 = 2;
9192 dgst_pos3 = 1;
9193 break;
9194
9195 case 7700: hash_type = HASH_TYPE_SAPB;
9196 salt_type = SALT_TYPE_EMBEDDED;
9197 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9198 opts_type = OPTS_TYPE_PT_GENERATE_LE
9199 | OPTS_TYPE_PT_UPPER
9200 | OPTS_TYPE_ST_UPPER;
9201 kern_type = KERN_TYPE_SAPB;
9202 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9203 parse_func = sapb_parse_hash;
9204 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9205 opti_type = OPTI_TYPE_ZERO_BYTE
9206 | OPTI_TYPE_PRECOMPUTE_INIT
9207 | OPTI_TYPE_NOT_ITERATED;
9208 dgst_pos0 = 0;
9209 dgst_pos1 = 1;
9210 dgst_pos2 = 2;
9211 dgst_pos3 = 3;
9212 break;
9213
9214 case 7800: hash_type = HASH_TYPE_SAPG;
9215 salt_type = SALT_TYPE_EMBEDDED;
9216 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9217 opts_type = OPTS_TYPE_PT_GENERATE_BE
9218 | OPTS_TYPE_ST_ADD80
9219 | OPTS_TYPE_ST_UPPER;
9220 kern_type = KERN_TYPE_SAPG;
9221 dgst_size = DGST_SIZE_4_5;
9222 parse_func = sapg_parse_hash;
9223 sort_by_digest = sort_by_digest_4_5;
9224 opti_type = OPTI_TYPE_ZERO_BYTE
9225 | OPTI_TYPE_PRECOMPUTE_INIT
9226 | OPTI_TYPE_NOT_ITERATED;
9227 dgst_pos0 = 3;
9228 dgst_pos1 = 4;
9229 dgst_pos2 = 2;
9230 dgst_pos3 = 1;
9231 break;
9232
9233 case 7900: hash_type = HASH_TYPE_SHA512;
9234 salt_type = SALT_TYPE_EMBEDDED;
9235 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9236 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9237 kern_type = KERN_TYPE_DRUPAL7;
9238 dgst_size = DGST_SIZE_8_8;
9239 parse_func = drupal7_parse_hash;
9240 sort_by_digest = sort_by_digest_8_8;
9241 opti_type = OPTI_TYPE_ZERO_BYTE
9242 | OPTI_TYPE_USES_BITS_64;
9243 dgst_pos0 = 0;
9244 dgst_pos1 = 1;
9245 dgst_pos2 = 2;
9246 dgst_pos3 = 3;
9247 break;
9248
9249 case 8000: hash_type = HASH_TYPE_SHA256;
9250 salt_type = SALT_TYPE_EMBEDDED;
9251 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9252 opts_type = OPTS_TYPE_PT_GENERATE_BE
9253 | OPTS_TYPE_PT_UNICODE
9254 | OPTS_TYPE_ST_ADD80
9255 | OPTS_TYPE_ST_HEX;
9256 kern_type = KERN_TYPE_SYBASEASE;
9257 dgst_size = DGST_SIZE_4_8;
9258 parse_func = sybasease_parse_hash;
9259 sort_by_digest = sort_by_digest_4_8;
9260 opti_type = OPTI_TYPE_ZERO_BYTE
9261 | OPTI_TYPE_PRECOMPUTE_INIT
9262 | OPTI_TYPE_EARLY_SKIP
9263 | OPTI_TYPE_NOT_ITERATED
9264 | OPTI_TYPE_RAW_HASH;
9265 dgst_pos0 = 3;
9266 dgst_pos1 = 7;
9267 dgst_pos2 = 2;
9268 dgst_pos3 = 6;
9269 break;
9270
9271 case 8100: hash_type = HASH_TYPE_SHA1;
9272 salt_type = SALT_TYPE_EMBEDDED;
9273 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9274 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9275 kern_type = KERN_TYPE_NETSCALER;
9276 dgst_size = DGST_SIZE_4_5;
9277 parse_func = netscaler_parse_hash;
9278 sort_by_digest = sort_by_digest_4_5;
9279 opti_type = OPTI_TYPE_ZERO_BYTE
9280 | OPTI_TYPE_PRECOMPUTE_INIT
9281 | OPTI_TYPE_PRECOMPUTE_MERKLE
9282 | OPTI_TYPE_EARLY_SKIP
9283 | OPTI_TYPE_NOT_ITERATED
9284 | OPTI_TYPE_PREPENDED_SALT
9285 | OPTI_TYPE_RAW_HASH;
9286 dgst_pos0 = 3;
9287 dgst_pos1 = 4;
9288 dgst_pos2 = 2;
9289 dgst_pos3 = 1;
9290 break;
9291
9292 case 8200: hash_type = HASH_TYPE_SHA256;
9293 salt_type = SALT_TYPE_EMBEDDED;
9294 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9295 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9296 kern_type = KERN_TYPE_CLOUDKEY;
9297 dgst_size = DGST_SIZE_4_8;
9298 parse_func = cloudkey_parse_hash;
9299 sort_by_digest = sort_by_digest_4_8;
9300 opti_type = OPTI_TYPE_ZERO_BYTE;
9301 dgst_pos0 = 0;
9302 dgst_pos1 = 1;
9303 dgst_pos2 = 2;
9304 dgst_pos3 = 3;
9305 break;
9306
9307 case 8300: hash_type = HASH_TYPE_SHA1;
9308 salt_type = SALT_TYPE_EMBEDDED;
9309 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9310 opts_type = OPTS_TYPE_PT_GENERATE_BE
9311 | OPTS_TYPE_ST_HEX
9312 | OPTS_TYPE_ST_ADD80;
9313 kern_type = KERN_TYPE_NSEC3;
9314 dgst_size = DGST_SIZE_4_5;
9315 parse_func = nsec3_parse_hash;
9316 sort_by_digest = sort_by_digest_4_5;
9317 opti_type = OPTI_TYPE_ZERO_BYTE;
9318 dgst_pos0 = 3;
9319 dgst_pos1 = 4;
9320 dgst_pos2 = 2;
9321 dgst_pos3 = 1;
9322 break;
9323
9324 case 8400: hash_type = HASH_TYPE_SHA1;
9325 salt_type = SALT_TYPE_INTERN;
9326 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9327 opts_type = OPTS_TYPE_PT_GENERATE_BE
9328 | OPTS_TYPE_PT_ADD80
9329 | OPTS_TYPE_PT_ADDBITS15;
9330 kern_type = KERN_TYPE_WBB3;
9331 dgst_size = DGST_SIZE_4_5;
9332 parse_func = wbb3_parse_hash;
9333 sort_by_digest = sort_by_digest_4_5;
9334 opti_type = OPTI_TYPE_ZERO_BYTE
9335 | OPTI_TYPE_PRECOMPUTE_INIT
9336 | OPTI_TYPE_NOT_ITERATED;
9337 dgst_pos0 = 3;
9338 dgst_pos1 = 4;
9339 dgst_pos2 = 2;
9340 dgst_pos3 = 1;
9341 break;
9342
9343 case 8500: hash_type = HASH_TYPE_DESRACF;
9344 salt_type = SALT_TYPE_EMBEDDED;
9345 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9346 opts_type = OPTS_TYPE_PT_GENERATE_LE
9347 | OPTS_TYPE_ST_UPPER;
9348 kern_type = KERN_TYPE_RACF;
9349 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9350 parse_func = racf_parse_hash;
9351 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9352 opti_type = OPTI_TYPE_ZERO_BYTE
9353 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9354 dgst_pos0 = 0;
9355 dgst_pos1 = 1;
9356 dgst_pos2 = 2;
9357 dgst_pos3 = 3;
9358 break;
9359
9360 case 8600: hash_type = HASH_TYPE_LOTUS5;
9361 salt_type = SALT_TYPE_NONE;
9362 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9363 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9364 kern_type = KERN_TYPE_LOTUS5;
9365 dgst_size = DGST_SIZE_4_4;
9366 parse_func = lotus5_parse_hash;
9367 sort_by_digest = sort_by_digest_4_4;
9368 opti_type = OPTI_TYPE_EARLY_SKIP
9369 | OPTI_TYPE_NOT_ITERATED
9370 | OPTI_TYPE_NOT_SALTED
9371 | OPTI_TYPE_RAW_HASH;
9372 dgst_pos0 = 0;
9373 dgst_pos1 = 1;
9374 dgst_pos2 = 2;
9375 dgst_pos3 = 3;
9376 break;
9377
9378 case 8700: hash_type = HASH_TYPE_LOTUS6;
9379 salt_type = SALT_TYPE_EMBEDDED;
9380 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9381 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9382 kern_type = KERN_TYPE_LOTUS6;
9383 dgst_size = DGST_SIZE_4_4;
9384 parse_func = lotus6_parse_hash;
9385 sort_by_digest = sort_by_digest_4_4;
9386 opti_type = OPTI_TYPE_EARLY_SKIP
9387 | OPTI_TYPE_NOT_ITERATED
9388 | OPTI_TYPE_RAW_HASH;
9389 dgst_pos0 = 0;
9390 dgst_pos1 = 1;
9391 dgst_pos2 = 2;
9392 dgst_pos3 = 3;
9393 break;
9394
9395 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9396 salt_type = SALT_TYPE_EMBEDDED;
9397 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9398 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9399 kern_type = KERN_TYPE_ANDROIDFDE;
9400 dgst_size = DGST_SIZE_4_4;
9401 parse_func = androidfde_parse_hash;
9402 sort_by_digest = sort_by_digest_4_4;
9403 opti_type = OPTI_TYPE_ZERO_BYTE;
9404 dgst_pos0 = 0;
9405 dgst_pos1 = 1;
9406 dgst_pos2 = 2;
9407 dgst_pos3 = 3;
9408 break;
9409
9410 case 8900: hash_type = HASH_TYPE_SCRYPT;
9411 salt_type = SALT_TYPE_EMBEDDED;
9412 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9413 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9414 kern_type = KERN_TYPE_SCRYPT;
9415 dgst_size = DGST_SIZE_4_8;
9416 parse_func = scrypt_parse_hash;
9417 sort_by_digest = sort_by_digest_4_8;
9418 opti_type = OPTI_TYPE_ZERO_BYTE;
9419 dgst_pos0 = 0;
9420 dgst_pos1 = 1;
9421 dgst_pos2 = 2;
9422 dgst_pos3 = 3;
9423 break;
9424
9425 case 9000: hash_type = HASH_TYPE_SHA1;
9426 salt_type = SALT_TYPE_EMBEDDED;
9427 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9428 opts_type = OPTS_TYPE_PT_GENERATE_LE
9429 | OPTS_TYPE_ST_GENERATE_LE;
9430 kern_type = KERN_TYPE_PSAFE2;
9431 dgst_size = DGST_SIZE_4_5;
9432 parse_func = psafe2_parse_hash;
9433 sort_by_digest = sort_by_digest_4_5;
9434 opti_type = OPTI_TYPE_ZERO_BYTE;
9435 dgst_pos0 = 0;
9436 dgst_pos1 = 1;
9437 dgst_pos2 = 2;
9438 dgst_pos3 = 3;
9439 break;
9440
9441 case 9100: hash_type = HASH_TYPE_LOTUS8;
9442 salt_type = SALT_TYPE_EMBEDDED;
9443 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9444 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9445 kern_type = KERN_TYPE_LOTUS8;
9446 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9447 parse_func = lotus8_parse_hash;
9448 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9449 opti_type = OPTI_TYPE_ZERO_BYTE;
9450 dgst_pos0 = 0;
9451 dgst_pos1 = 1;
9452 dgst_pos2 = 2;
9453 dgst_pos3 = 3;
9454 break;
9455
9456 case 9200: hash_type = HASH_TYPE_SHA256;
9457 salt_type = SALT_TYPE_EMBEDDED;
9458 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9459 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9460 kern_type = KERN_TYPE_PBKDF2_SHA256;
9461 dgst_size = DGST_SIZE_4_32;
9462 parse_func = cisco8_parse_hash;
9463 sort_by_digest = sort_by_digest_4_32;
9464 opti_type = OPTI_TYPE_ZERO_BYTE;
9465 dgst_pos0 = 0;
9466 dgst_pos1 = 1;
9467 dgst_pos2 = 2;
9468 dgst_pos3 = 3;
9469 break;
9470
9471 case 9300: hash_type = HASH_TYPE_SCRYPT;
9472 salt_type = SALT_TYPE_EMBEDDED;
9473 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9474 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9475 kern_type = KERN_TYPE_SCRYPT;
9476 dgst_size = DGST_SIZE_4_8;
9477 parse_func = cisco9_parse_hash;
9478 sort_by_digest = sort_by_digest_4_8;
9479 opti_type = OPTI_TYPE_ZERO_BYTE;
9480 dgst_pos0 = 0;
9481 dgst_pos1 = 1;
9482 dgst_pos2 = 2;
9483 dgst_pos3 = 3;
9484 break;
9485
9486 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9487 salt_type = SALT_TYPE_EMBEDDED;
9488 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9489 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9490 kern_type = KERN_TYPE_OFFICE2007;
9491 dgst_size = DGST_SIZE_4_4;
9492 parse_func = office2007_parse_hash;
9493 sort_by_digest = sort_by_digest_4_4;
9494 opti_type = OPTI_TYPE_ZERO_BYTE;
9495 dgst_pos0 = 0;
9496 dgst_pos1 = 1;
9497 dgst_pos2 = 2;
9498 dgst_pos3 = 3;
9499 break;
9500
9501 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9502 salt_type = SALT_TYPE_EMBEDDED;
9503 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9504 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9505 kern_type = KERN_TYPE_OFFICE2010;
9506 dgst_size = DGST_SIZE_4_4;
9507 parse_func = office2010_parse_hash;
9508 sort_by_digest = sort_by_digest_4_4;
9509 opti_type = OPTI_TYPE_ZERO_BYTE;
9510 dgst_pos0 = 0;
9511 dgst_pos1 = 1;
9512 dgst_pos2 = 2;
9513 dgst_pos3 = 3;
9514 break;
9515
9516 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9517 salt_type = SALT_TYPE_EMBEDDED;
9518 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9519 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9520 kern_type = KERN_TYPE_OFFICE2013;
9521 dgst_size = DGST_SIZE_4_4;
9522 parse_func = office2013_parse_hash;
9523 sort_by_digest = sort_by_digest_4_4;
9524 opti_type = OPTI_TYPE_ZERO_BYTE;
9525 dgst_pos0 = 0;
9526 dgst_pos1 = 1;
9527 dgst_pos2 = 2;
9528 dgst_pos3 = 3;
9529 break;
9530
9531 case 9700: 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 | OPTS_TYPE_PT_UNICODE;
9537 kern_type = KERN_TYPE_OLDOFFICE01;
9538 dgst_size = DGST_SIZE_4_4;
9539 parse_func = oldoffice01_parse_hash;
9540 sort_by_digest = sort_by_digest_4_4;
9541 opti_type = OPTI_TYPE_ZERO_BYTE
9542 | OPTI_TYPE_PRECOMPUTE_INIT
9543 | OPTI_TYPE_NOT_ITERATED;
9544 dgst_pos0 = 0;
9545 dgst_pos1 = 1;
9546 dgst_pos2 = 2;
9547 dgst_pos3 = 3;
9548 break;
9549
9550 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9551 salt_type = SALT_TYPE_EMBEDDED;
9552 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9553 opts_type = OPTS_TYPE_PT_GENERATE_LE
9554 | OPTS_TYPE_PT_ADD80;
9555 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9556 dgst_size = DGST_SIZE_4_4;
9557 parse_func = oldoffice01cm1_parse_hash;
9558 sort_by_digest = sort_by_digest_4_4;
9559 opti_type = OPTI_TYPE_ZERO_BYTE
9560 | OPTI_TYPE_PRECOMPUTE_INIT
9561 | OPTI_TYPE_NOT_ITERATED;
9562 dgst_pos0 = 0;
9563 dgst_pos1 = 1;
9564 dgst_pos2 = 2;
9565 dgst_pos3 = 3;
9566 break;
9567
9568 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9569 salt_type = SALT_TYPE_EMBEDDED;
9570 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9571 opts_type = OPTS_TYPE_PT_GENERATE_LE
9572 | OPTS_TYPE_PT_ADD80
9573 | OPTS_TYPE_PT_UNICODE
9574 | OPTS_TYPE_PT_NEVERCRACK;
9575 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9576 dgst_size = DGST_SIZE_4_4;
9577 parse_func = oldoffice01cm2_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 9800: 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_BE
9592 | OPTS_TYPE_PT_ADD80
9593 | OPTS_TYPE_PT_UNICODE;
9594 kern_type = KERN_TYPE_OLDOFFICE34;
9595 dgst_size = DGST_SIZE_4_4;
9596 parse_func = oldoffice34_parse_hash;
9597 sort_by_digest = sort_by_digest_4_4;
9598 opti_type = OPTI_TYPE_ZERO_BYTE
9599 | OPTI_TYPE_PRECOMPUTE_INIT
9600 | OPTI_TYPE_NOT_ITERATED;
9601 dgst_pos0 = 0;
9602 dgst_pos1 = 1;
9603 dgst_pos2 = 2;
9604 dgst_pos3 = 3;
9605 break;
9606
9607 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9608 salt_type = SALT_TYPE_EMBEDDED;
9609 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9610 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9611 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9612 dgst_size = DGST_SIZE_4_4;
9613 parse_func = oldoffice34cm1_parse_hash;
9614 sort_by_digest = sort_by_digest_4_4;
9615 opti_type = OPTI_TYPE_ZERO_BYTE
9616 | OPTI_TYPE_PRECOMPUTE_INIT
9617 | OPTI_TYPE_NOT_ITERATED;
9618 dgst_pos0 = 0;
9619 dgst_pos1 = 1;
9620 dgst_pos2 = 2;
9621 dgst_pos3 = 3;
9622 break;
9623
9624 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9625 salt_type = SALT_TYPE_EMBEDDED;
9626 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9627 opts_type = OPTS_TYPE_PT_GENERATE_BE
9628 | OPTS_TYPE_PT_ADD80
9629 | OPTS_TYPE_PT_UNICODE
9630 | OPTS_TYPE_PT_NEVERCRACK;
9631 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9632 dgst_size = DGST_SIZE_4_4;
9633 parse_func = oldoffice34cm2_parse_hash;
9634 sort_by_digest = sort_by_digest_4_4;
9635 opti_type = OPTI_TYPE_ZERO_BYTE
9636 | OPTI_TYPE_PRECOMPUTE_INIT
9637 | OPTI_TYPE_NOT_ITERATED;
9638 dgst_pos0 = 0;
9639 dgst_pos1 = 1;
9640 dgst_pos2 = 2;
9641 dgst_pos3 = 3;
9642 break;
9643
9644 case 9900: hash_type = HASH_TYPE_MD5;
9645 salt_type = SALT_TYPE_NONE;
9646 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9647 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9648 kern_type = KERN_TYPE_RADMIN2;
9649 dgst_size = DGST_SIZE_4_4;
9650 parse_func = radmin2_parse_hash;
9651 sort_by_digest = sort_by_digest_4_4;
9652 opti_type = OPTI_TYPE_ZERO_BYTE
9653 | OPTI_TYPE_PRECOMPUTE_INIT
9654 | OPTI_TYPE_EARLY_SKIP
9655 | OPTI_TYPE_NOT_ITERATED
9656 | OPTI_TYPE_NOT_SALTED;
9657 dgst_pos0 = 0;
9658 dgst_pos1 = 3;
9659 dgst_pos2 = 2;
9660 dgst_pos3 = 1;
9661 break;
9662
9663 case 10000: hash_type = HASH_TYPE_SHA256;
9664 salt_type = SALT_TYPE_EMBEDDED;
9665 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9666 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9667 kern_type = KERN_TYPE_PBKDF2_SHA256;
9668 dgst_size = DGST_SIZE_4_32;
9669 parse_func = djangopbkdf2_parse_hash;
9670 sort_by_digest = sort_by_digest_4_32;
9671 opti_type = OPTI_TYPE_ZERO_BYTE;
9672 dgst_pos0 = 0;
9673 dgst_pos1 = 1;
9674 dgst_pos2 = 2;
9675 dgst_pos3 = 3;
9676 break;
9677
9678 case 10100: hash_type = HASH_TYPE_SIPHASH;
9679 salt_type = SALT_TYPE_EMBEDDED;
9680 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9681 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9682 kern_type = KERN_TYPE_SIPHASH;
9683 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9684 parse_func = siphash_parse_hash;
9685 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9686 opti_type = OPTI_TYPE_ZERO_BYTE
9687 | OPTI_TYPE_NOT_ITERATED
9688 | OPTI_TYPE_RAW_HASH;
9689 dgst_pos0 = 0;
9690 dgst_pos1 = 1;
9691 dgst_pos2 = 2;
9692 dgst_pos3 = 3;
9693 break;
9694
9695 case 10200: hash_type = HASH_TYPE_MD5;
9696 salt_type = SALT_TYPE_EMBEDDED;
9697 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9698 opts_type = OPTS_TYPE_PT_GENERATE_LE
9699 | OPTS_TYPE_ST_ADD80
9700 | OPTS_TYPE_ST_ADDBITS14;
9701 kern_type = KERN_TYPE_HMACMD5_PW;
9702 dgst_size = DGST_SIZE_4_4;
9703 parse_func = crammd5_parse_hash;
9704 sort_by_digest = sort_by_digest_4_4;
9705 opti_type = OPTI_TYPE_ZERO_BYTE
9706 | OPTI_TYPE_NOT_ITERATED;
9707 dgst_pos0 = 0;
9708 dgst_pos1 = 3;
9709 dgst_pos2 = 2;
9710 dgst_pos3 = 1;
9711 break;
9712
9713 case 10300: hash_type = HASH_TYPE_SHA1;
9714 salt_type = SALT_TYPE_EMBEDDED;
9715 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9716 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9717 kern_type = KERN_TYPE_SAPH_SHA1;
9718 dgst_size = DGST_SIZE_4_5;
9719 parse_func = saph_sha1_parse_hash;
9720 sort_by_digest = sort_by_digest_4_5;
9721 opti_type = OPTI_TYPE_ZERO_BYTE;
9722 dgst_pos0 = 0;
9723 dgst_pos1 = 1;
9724 dgst_pos2 = 2;
9725 dgst_pos3 = 3;
9726 break;
9727
9728 case 10400: hash_type = HASH_TYPE_PDFU16;
9729 salt_type = SALT_TYPE_EMBEDDED;
9730 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9731 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9732 kern_type = KERN_TYPE_PDF11;
9733 dgst_size = DGST_SIZE_4_4;
9734 parse_func = pdf11_parse_hash;
9735 sort_by_digest = sort_by_digest_4_4;
9736 opti_type = OPTI_TYPE_ZERO_BYTE
9737 | OPTI_TYPE_NOT_ITERATED;
9738 dgst_pos0 = 0;
9739 dgst_pos1 = 1;
9740 dgst_pos2 = 2;
9741 dgst_pos3 = 3;
9742 break;
9743
9744 case 10410: hash_type = HASH_TYPE_PDFU16;
9745 salt_type = SALT_TYPE_EMBEDDED;
9746 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9747 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9748 kern_type = KERN_TYPE_PDF11CM1;
9749 dgst_size = DGST_SIZE_4_4;
9750 parse_func = pdf11cm1_parse_hash;
9751 sort_by_digest = sort_by_digest_4_4;
9752 opti_type = OPTI_TYPE_ZERO_BYTE
9753 | OPTI_TYPE_NOT_ITERATED;
9754 dgst_pos0 = 0;
9755 dgst_pos1 = 1;
9756 dgst_pos2 = 2;
9757 dgst_pos3 = 3;
9758 break;
9759
9760 case 10420: hash_type = HASH_TYPE_PDFU16;
9761 salt_type = SALT_TYPE_EMBEDDED;
9762 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9763 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9764 kern_type = KERN_TYPE_PDF11CM2;
9765 dgst_size = DGST_SIZE_4_4;
9766 parse_func = pdf11cm2_parse_hash;
9767 sort_by_digest = sort_by_digest_4_4;
9768 opti_type = OPTI_TYPE_ZERO_BYTE
9769 | OPTI_TYPE_NOT_ITERATED;
9770 dgst_pos0 = 0;
9771 dgst_pos1 = 1;
9772 dgst_pos2 = 2;
9773 dgst_pos3 = 3;
9774 break;
9775
9776 case 10500: hash_type = HASH_TYPE_PDFU16;
9777 salt_type = SALT_TYPE_EMBEDDED;
9778 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9779 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9780 kern_type = KERN_TYPE_PDF14;
9781 dgst_size = DGST_SIZE_4_4;
9782 parse_func = pdf14_parse_hash;
9783 sort_by_digest = sort_by_digest_4_4;
9784 opti_type = OPTI_TYPE_ZERO_BYTE
9785 | OPTI_TYPE_NOT_ITERATED;
9786 dgst_pos0 = 0;
9787 dgst_pos1 = 1;
9788 dgst_pos2 = 2;
9789 dgst_pos3 = 3;
9790 break;
9791
9792 case 10600: hash_type = HASH_TYPE_SHA256;
9793 salt_type = SALT_TYPE_EMBEDDED;
9794 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9795 opts_type = OPTS_TYPE_PT_GENERATE_BE
9796 | OPTS_TYPE_ST_ADD80
9797 | OPTS_TYPE_ST_ADDBITS15
9798 | OPTS_TYPE_HASH_COPY;
9799 kern_type = KERN_TYPE_SHA256_PWSLT;
9800 dgst_size = DGST_SIZE_4_8;
9801 parse_func = pdf17l3_parse_hash;
9802 sort_by_digest = sort_by_digest_4_8;
9803 opti_type = OPTI_TYPE_ZERO_BYTE
9804 | OPTI_TYPE_PRECOMPUTE_INIT
9805 | OPTI_TYPE_PRECOMPUTE_MERKLE
9806 | OPTI_TYPE_EARLY_SKIP
9807 | OPTI_TYPE_NOT_ITERATED
9808 | OPTI_TYPE_APPENDED_SALT
9809 | OPTI_TYPE_RAW_HASH;
9810 dgst_pos0 = 3;
9811 dgst_pos1 = 7;
9812 dgst_pos2 = 2;
9813 dgst_pos3 = 6;
9814 break;
9815
9816 case 10700: hash_type = HASH_TYPE_PDFU32;
9817 salt_type = SALT_TYPE_EMBEDDED;
9818 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9819 opts_type = OPTS_TYPE_PT_GENERATE_LE
9820 | OPTS_TYPE_HASH_COPY;
9821 kern_type = KERN_TYPE_PDF17L8;
9822 dgst_size = DGST_SIZE_4_8;
9823 parse_func = pdf17l8_parse_hash;
9824 sort_by_digest = sort_by_digest_4_8;
9825 opti_type = OPTI_TYPE_ZERO_BYTE
9826 | OPTI_TYPE_NOT_ITERATED;
9827 dgst_pos0 = 0;
9828 dgst_pos1 = 1;
9829 dgst_pos2 = 2;
9830 dgst_pos3 = 3;
9831 break;
9832
9833 case 10800: hash_type = HASH_TYPE_SHA384;
9834 salt_type = SALT_TYPE_NONE;
9835 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9836 opts_type = OPTS_TYPE_PT_GENERATE_BE
9837 | OPTS_TYPE_PT_ADD80
9838 | OPTS_TYPE_PT_ADDBITS15;
9839 kern_type = KERN_TYPE_SHA384;
9840 dgst_size = DGST_SIZE_8_8;
9841 parse_func = sha384_parse_hash;
9842 sort_by_digest = sort_by_digest_8_8;
9843 opti_type = OPTI_TYPE_ZERO_BYTE
9844 | OPTI_TYPE_PRECOMPUTE_INIT
9845 | OPTI_TYPE_PRECOMPUTE_MERKLE
9846 | OPTI_TYPE_EARLY_SKIP
9847 | OPTI_TYPE_NOT_ITERATED
9848 | OPTI_TYPE_NOT_SALTED
9849 | OPTI_TYPE_USES_BITS_64
9850 | OPTI_TYPE_RAW_HASH;
9851 dgst_pos0 = 6;
9852 dgst_pos1 = 7;
9853 dgst_pos2 = 4;
9854 dgst_pos3 = 5;
9855 break;
9856
9857 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9858 salt_type = SALT_TYPE_EMBEDDED;
9859 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9860 opts_type = OPTS_TYPE_PT_GENERATE_LE
9861 | OPTS_TYPE_ST_BASE64
9862 | OPTS_TYPE_HASH_COPY;
9863 kern_type = KERN_TYPE_PBKDF2_SHA256;
9864 dgst_size = DGST_SIZE_4_32;
9865 parse_func = pbkdf2_sha256_parse_hash;
9866 sort_by_digest = sort_by_digest_4_32;
9867 opti_type = OPTI_TYPE_ZERO_BYTE;
9868 dgst_pos0 = 0;
9869 dgst_pos1 = 1;
9870 dgst_pos2 = 2;
9871 dgst_pos3 = 3;
9872 break;
9873
9874 case 11000: hash_type = HASH_TYPE_MD5;
9875 salt_type = SALT_TYPE_INTERN;
9876 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9877 opts_type = OPTS_TYPE_PT_GENERATE_LE
9878 | OPTS_TYPE_PT_ADD80;
9879 kern_type = KERN_TYPE_PRESTASHOP;
9880 dgst_size = DGST_SIZE_4_4;
9881 parse_func = prestashop_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_NOT_ITERATED
9886 | OPTI_TYPE_PREPENDED_SALT;
9887 dgst_pos0 = 0;
9888 dgst_pos1 = 3;
9889 dgst_pos2 = 2;
9890 dgst_pos3 = 1;
9891 break;
9892
9893 case 11100: hash_type = HASH_TYPE_MD5;
9894 salt_type = SALT_TYPE_EMBEDDED;
9895 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9896 opts_type = OPTS_TYPE_PT_GENERATE_LE
9897 | OPTS_TYPE_ST_ADD80;
9898 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9899 dgst_size = DGST_SIZE_4_4;
9900 parse_func = postgresql_auth_parse_hash;
9901 sort_by_digest = sort_by_digest_4_4;
9902 opti_type = OPTI_TYPE_ZERO_BYTE
9903 | OPTI_TYPE_PRECOMPUTE_INIT
9904 | OPTI_TYPE_PRECOMPUTE_MERKLE
9905 | OPTI_TYPE_EARLY_SKIP;
9906 dgst_pos0 = 0;
9907 dgst_pos1 = 3;
9908 dgst_pos2 = 2;
9909 dgst_pos3 = 1;
9910 break;
9911
9912 case 11200: hash_type = HASH_TYPE_SHA1;
9913 salt_type = SALT_TYPE_EMBEDDED;
9914 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9915 opts_type = OPTS_TYPE_PT_GENERATE_BE
9916 | OPTS_TYPE_PT_ADD80
9917 | OPTS_TYPE_ST_HEX;
9918 kern_type = KERN_TYPE_MYSQL_AUTH;
9919 dgst_size = DGST_SIZE_4_5;
9920 parse_func = mysql_auth_parse_hash;
9921 sort_by_digest = sort_by_digest_4_5;
9922 opti_type = OPTI_TYPE_ZERO_BYTE
9923 | OPTI_TYPE_EARLY_SKIP;
9924 dgst_pos0 = 3;
9925 dgst_pos1 = 4;
9926 dgst_pos2 = 2;
9927 dgst_pos3 = 1;
9928 break;
9929
9930 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9931 salt_type = SALT_TYPE_EMBEDDED;
9932 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9933 opts_type = OPTS_TYPE_PT_GENERATE_LE
9934 | OPTS_TYPE_ST_HEX
9935 | OPTS_TYPE_ST_ADD80;
9936 kern_type = KERN_TYPE_BITCOIN_WALLET;
9937 dgst_size = DGST_SIZE_4_4;
9938 parse_func = bitcoin_wallet_parse_hash;
9939 sort_by_digest = sort_by_digest_4_4;
9940 opti_type = OPTI_TYPE_ZERO_BYTE;
9941 dgst_pos0 = 0;
9942 dgst_pos1 = 1;
9943 dgst_pos2 = 2;
9944 dgst_pos3 = 3;
9945 break;
9946
9947 case 11400: hash_type = HASH_TYPE_MD5;
9948 salt_type = SALT_TYPE_EMBEDDED;
9949 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9950 opts_type = OPTS_TYPE_PT_GENERATE_LE
9951 | OPTS_TYPE_PT_ADD80
9952 | OPTS_TYPE_HASH_COPY;
9953 kern_type = KERN_TYPE_SIP_AUTH;
9954 dgst_size = DGST_SIZE_4_4;
9955 parse_func = sip_auth_parse_hash;
9956 sort_by_digest = sort_by_digest_4_4;
9957 opti_type = OPTI_TYPE_ZERO_BYTE;
9958 dgst_pos0 = 0;
9959 dgst_pos1 = 3;
9960 dgst_pos2 = 2;
9961 dgst_pos3 = 1;
9962 break;
9963
9964 case 11500: hash_type = HASH_TYPE_CRC32;
9965 salt_type = SALT_TYPE_INTERN;
9966 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9967 opts_type = OPTS_TYPE_PT_GENERATE_LE
9968 | OPTS_TYPE_ST_GENERATE_LE
9969 | OPTS_TYPE_ST_HEX;
9970 kern_type = KERN_TYPE_CRC32;
9971 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9972 parse_func = crc32_parse_hash;
9973 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9974 opti_type = OPTI_TYPE_ZERO_BYTE;
9975 dgst_pos0 = 0;
9976 dgst_pos1 = 1;
9977 dgst_pos2 = 2;
9978 dgst_pos3 = 3;
9979 break;
9980
9981 case 11600: hash_type = HASH_TYPE_AES;
9982 salt_type = SALT_TYPE_EMBEDDED;
9983 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9984 opts_type = OPTS_TYPE_PT_GENERATE_LE
9985 | OPTS_TYPE_PT_NEVERCRACK;
9986 kern_type = KERN_TYPE_SEVEN_ZIP;
9987 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9988 parse_func = seven_zip_parse_hash;
9989 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9990 opti_type = OPTI_TYPE_ZERO_BYTE;
9991 dgst_pos0 = 0;
9992 dgst_pos1 = 1;
9993 dgst_pos2 = 2;
9994 dgst_pos3 = 3;
9995 break;
9996
9997 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9998 salt_type = SALT_TYPE_NONE;
9999 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10000 opts_type = OPTS_TYPE_PT_GENERATE_LE
10001 | OPTS_TYPE_PT_ADD01;
10002 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10003 dgst_size = DGST_SIZE_4_8;
10004 parse_func = gost2012sbog_256_parse_hash;
10005 sort_by_digest = sort_by_digest_4_8;
10006 opti_type = OPTI_TYPE_ZERO_BYTE;
10007 dgst_pos0 = 0;
10008 dgst_pos1 = 1;
10009 dgst_pos2 = 2;
10010 dgst_pos3 = 3;
10011 break;
10012
10013 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10014 salt_type = SALT_TYPE_NONE;
10015 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10016 opts_type = OPTS_TYPE_PT_GENERATE_LE
10017 | OPTS_TYPE_PT_ADD01;
10018 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10019 dgst_size = DGST_SIZE_4_16;
10020 parse_func = gost2012sbog_512_parse_hash;
10021 sort_by_digest = sort_by_digest_4_16;
10022 opti_type = OPTI_TYPE_ZERO_BYTE;
10023 dgst_pos0 = 0;
10024 dgst_pos1 = 1;
10025 dgst_pos2 = 2;
10026 dgst_pos3 = 3;
10027 break;
10028
10029 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10030 salt_type = SALT_TYPE_EMBEDDED;
10031 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10032 opts_type = OPTS_TYPE_PT_GENERATE_LE
10033 | OPTS_TYPE_ST_BASE64
10034 | OPTS_TYPE_HASH_COPY;
10035 kern_type = KERN_TYPE_PBKDF2_MD5;
10036 dgst_size = DGST_SIZE_4_32;
10037 parse_func = pbkdf2_md5_parse_hash;
10038 sort_by_digest = sort_by_digest_4_32;
10039 opti_type = OPTI_TYPE_ZERO_BYTE;
10040 dgst_pos0 = 0;
10041 dgst_pos1 = 1;
10042 dgst_pos2 = 2;
10043 dgst_pos3 = 3;
10044 break;
10045
10046 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10047 salt_type = SALT_TYPE_EMBEDDED;
10048 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10049 opts_type = OPTS_TYPE_PT_GENERATE_LE
10050 | OPTS_TYPE_ST_BASE64
10051 | OPTS_TYPE_HASH_COPY;
10052 kern_type = KERN_TYPE_PBKDF2_SHA1;
10053 dgst_size = DGST_SIZE_4_32;
10054 parse_func = pbkdf2_sha1_parse_hash;
10055 sort_by_digest = sort_by_digest_4_32;
10056 opti_type = OPTI_TYPE_ZERO_BYTE;
10057 dgst_pos0 = 0;
10058 dgst_pos1 = 1;
10059 dgst_pos2 = 2;
10060 dgst_pos3 = 3;
10061 break;
10062
10063 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10064 salt_type = SALT_TYPE_EMBEDDED;
10065 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10066 opts_type = OPTS_TYPE_PT_GENERATE_LE
10067 | OPTS_TYPE_ST_BASE64
10068 | OPTS_TYPE_HASH_COPY;
10069 kern_type = KERN_TYPE_PBKDF2_SHA512;
10070 dgst_size = DGST_SIZE_8_16;
10071 parse_func = pbkdf2_sha512_parse_hash;
10072 sort_by_digest = sort_by_digest_8_16;
10073 opti_type = OPTI_TYPE_ZERO_BYTE
10074 | OPTI_TYPE_USES_BITS_64;
10075 dgst_pos0 = 0;
10076 dgst_pos1 = 1;
10077 dgst_pos2 = 2;
10078 dgst_pos3 = 3;
10079 break;
10080
10081 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10082 salt_type = SALT_TYPE_EMBEDDED;
10083 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10084 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10085 kern_type = KERN_TYPE_ECRYPTFS;
10086 dgst_size = DGST_SIZE_8_8;
10087 parse_func = ecryptfs_parse_hash;
10088 sort_by_digest = sort_by_digest_8_8;
10089 opti_type = OPTI_TYPE_ZERO_BYTE
10090 | OPTI_TYPE_USES_BITS_64;
10091 dgst_pos0 = 0;
10092 dgst_pos1 = 1;
10093 dgst_pos2 = 2;
10094 dgst_pos3 = 3;
10095 break;
10096
10097 case 12300: hash_type = HASH_TYPE_ORACLET;
10098 salt_type = SALT_TYPE_EMBEDDED;
10099 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10100 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10101 kern_type = KERN_TYPE_ORACLET;
10102 dgst_size = DGST_SIZE_8_16;
10103 parse_func = oraclet_parse_hash;
10104 sort_by_digest = sort_by_digest_8_16;
10105 opti_type = OPTI_TYPE_ZERO_BYTE
10106 | OPTI_TYPE_USES_BITS_64;
10107 dgst_pos0 = 0;
10108 dgst_pos1 = 1;
10109 dgst_pos2 = 2;
10110 dgst_pos3 = 3;
10111 break;
10112
10113 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10114 salt_type = SALT_TYPE_EMBEDDED;
10115 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10116 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10117 kern_type = KERN_TYPE_BSDICRYPT;
10118 dgst_size = DGST_SIZE_4_4;
10119 parse_func = bsdicrypt_parse_hash;
10120 sort_by_digest = sort_by_digest_4_4;
10121 opti_type = OPTI_TYPE_ZERO_BYTE
10122 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10123 dgst_pos0 = 0;
10124 dgst_pos1 = 1;
10125 dgst_pos2 = 2;
10126 dgst_pos3 = 3;
10127 break;
10128
10129 case 12500: hash_type = HASH_TYPE_RAR3HP;
10130 salt_type = SALT_TYPE_EMBEDDED;
10131 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10132 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10133 kern_type = KERN_TYPE_RAR3;
10134 dgst_size = DGST_SIZE_4_4;
10135 parse_func = rar3hp_parse_hash;
10136 sort_by_digest = sort_by_digest_4_4;
10137 opti_type = OPTI_TYPE_ZERO_BYTE;
10138 dgst_pos0 = 0;
10139 dgst_pos1 = 1;
10140 dgst_pos2 = 2;
10141 dgst_pos3 = 3;
10142 break;
10143
10144 case 12600: hash_type = HASH_TYPE_SHA256;
10145 salt_type = SALT_TYPE_INTERN;
10146 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10147 opts_type = OPTS_TYPE_PT_GENERATE_BE
10148 | OPTS_TYPE_PT_ADD80;
10149 kern_type = KERN_TYPE_CF10;
10150 dgst_size = DGST_SIZE_4_8;
10151 parse_func = cf10_parse_hash;
10152 sort_by_digest = sort_by_digest_4_8;
10153 opti_type = OPTI_TYPE_ZERO_BYTE
10154 | OPTI_TYPE_PRECOMPUTE_INIT
10155 | OPTI_TYPE_EARLY_SKIP
10156 | OPTI_TYPE_NOT_ITERATED;
10157 dgst_pos0 = 3;
10158 dgst_pos1 = 7;
10159 dgst_pos2 = 2;
10160 dgst_pos3 = 6;
10161 break;
10162
10163 case 12700: hash_type = HASH_TYPE_AES;
10164 salt_type = SALT_TYPE_EMBEDDED;
10165 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10166 opts_type = OPTS_TYPE_PT_GENERATE_LE
10167 | OPTS_TYPE_HASH_COPY;
10168 kern_type = KERN_TYPE_MYWALLET;
10169 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10170 parse_func = mywallet_parse_hash;
10171 sort_by_digest = sort_by_digest_4_5;
10172 opti_type = OPTI_TYPE_ZERO_BYTE;
10173 dgst_pos0 = 0;
10174 dgst_pos1 = 1;
10175 dgst_pos2 = 2;
10176 dgst_pos3 = 3;
10177 break;
10178
10179 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10180 salt_type = SALT_TYPE_EMBEDDED;
10181 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10182 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10183 kern_type = KERN_TYPE_MS_DRSR;
10184 dgst_size = DGST_SIZE_4_8;
10185 parse_func = ms_drsr_parse_hash;
10186 sort_by_digest = sort_by_digest_4_8;
10187 opti_type = OPTI_TYPE_ZERO_BYTE;
10188 dgst_pos0 = 0;
10189 dgst_pos1 = 1;
10190 dgst_pos2 = 2;
10191 dgst_pos3 = 3;
10192 break;
10193
10194 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10195 salt_type = SALT_TYPE_EMBEDDED;
10196 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10197 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10198 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10199 dgst_size = DGST_SIZE_4_8;
10200 parse_func = androidfde_samsung_parse_hash;
10201 sort_by_digest = sort_by_digest_4_8;
10202 opti_type = OPTI_TYPE_ZERO_BYTE;
10203 dgst_pos0 = 0;
10204 dgst_pos1 = 1;
10205 dgst_pos2 = 2;
10206 dgst_pos3 = 3;
10207 break;
10208
10209 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10210 salt_type = SALT_TYPE_EMBEDDED;
10211 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10212 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10213 kern_type = KERN_TYPE_RAR5;
10214 dgst_size = DGST_SIZE_4_4;
10215 parse_func = rar5_parse_hash;
10216 sort_by_digest = sort_by_digest_4_4;
10217 opti_type = OPTI_TYPE_ZERO_BYTE;
10218 dgst_pos0 = 0;
10219 dgst_pos1 = 1;
10220 dgst_pos2 = 2;
10221 dgst_pos3 = 3;
10222 break;
10223
10224 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10225 salt_type = SALT_TYPE_EMBEDDED;
10226 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10227 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10228 kern_type = KERN_TYPE_KRB5TGS;
10229 dgst_size = DGST_SIZE_4_4;
10230 parse_func = krb5tgs_parse_hash;
10231 sort_by_digest = sort_by_digest_4_4;
10232 opti_type = OPTI_TYPE_ZERO_BYTE
10233 | OPTI_TYPE_NOT_ITERATED;
10234 dgst_pos0 = 0;
10235 dgst_pos1 = 1;
10236 dgst_pos2 = 2;
10237 dgst_pos3 = 3;
10238 break;
10239
10240 case 13200: hash_type = HASH_TYPE_AES;
10241 salt_type = SALT_TYPE_EMBEDDED;
10242 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10243 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10244 kern_type = KERN_TYPE_AXCRYPT;
10245 dgst_size = DGST_SIZE_4_4;
10246 parse_func = axcrypt_parse_hash;
10247 sort_by_digest = sort_by_digest_4_4;
10248 opti_type = OPTI_TYPE_ZERO_BYTE;
10249 dgst_pos0 = 0;
10250 dgst_pos1 = 1;
10251 dgst_pos2 = 2;
10252 dgst_pos3 = 3;
10253 break;
10254
10255 case 13300: hash_type = HASH_TYPE_SHA1;
10256 salt_type = SALT_TYPE_NONE;
10257 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10258 opts_type = OPTS_TYPE_PT_GENERATE_BE
10259 | OPTS_TYPE_PT_ADD80
10260 | OPTS_TYPE_PT_ADDBITS15;
10261 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10262 dgst_size = DGST_SIZE_4_5;
10263 parse_func = sha1axcrypt_parse_hash;
10264 sort_by_digest = sort_by_digest_4_5;
10265 opti_type = OPTI_TYPE_ZERO_BYTE
10266 | OPTI_TYPE_PRECOMPUTE_INIT
10267 | OPTI_TYPE_EARLY_SKIP
10268 | OPTI_TYPE_NOT_ITERATED
10269 | OPTI_TYPE_NOT_SALTED;
10270 dgst_pos0 = 0;
10271 dgst_pos1 = 4;
10272 dgst_pos2 = 3;
10273 dgst_pos3 = 2;
10274 break;
10275
10276 case 13400: hash_type = HASH_TYPE_AES;
10277 salt_type = SALT_TYPE_EMBEDDED;
10278 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10279 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10280 kern_type = KERN_TYPE_KEEPASS;
10281 dgst_size = DGST_SIZE_4_4;
10282 parse_func = keepass_parse_hash;
10283 sort_by_digest = sort_by_digest_4_4;
10284 opti_type = OPTI_TYPE_ZERO_BYTE;
10285 dgst_pos0 = 0;
10286 dgst_pos1 = 1;
10287 dgst_pos2 = 2;
10288 dgst_pos3 = 3;
10289 break;
10290
10291 default: usage_mini_print (PROGNAME); return (-1);
10292 }
10293
10294 /**
10295 * parser
10296 */
10297
10298 data.parse_func = parse_func;
10299
10300 /**
10301 * misc stuff
10302 */
10303
10304 if (hex_salt)
10305 {
10306 if (salt_type == SALT_TYPE_INTERN)
10307 {
10308 opts_type |= OPTS_TYPE_ST_HEX;
10309 }
10310 else
10311 {
10312 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10313
10314 return (-1);
10315 }
10316 }
10317
10318 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10319 | (salt_type == SALT_TYPE_EXTERN)
10320 | (salt_type == SALT_TYPE_EMBEDDED)
10321 | (salt_type == SALT_TYPE_VIRTUAL));
10322
10323 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10324
10325 data.hash_type = hash_type;
10326 data.attack_mode = attack_mode;
10327 data.attack_kern = attack_kern;
10328 data.attack_exec = attack_exec;
10329 data.kern_type = kern_type;
10330 data.opts_type = opts_type;
10331 data.dgst_size = dgst_size;
10332 data.salt_type = salt_type;
10333 data.isSalted = isSalted;
10334 data.sort_by_digest = sort_by_digest;
10335 data.dgst_pos0 = dgst_pos0;
10336 data.dgst_pos1 = dgst_pos1;
10337 data.dgst_pos2 = dgst_pos2;
10338 data.dgst_pos3 = dgst_pos3;
10339
10340 esalt_size = 0;
10341
10342 switch (hash_mode)
10343 {
10344 case 2500: esalt_size = sizeof (wpa_t); break;
10345 case 5300: esalt_size = sizeof (ikepsk_t); break;
10346 case 5400: esalt_size = sizeof (ikepsk_t); break;
10347 case 5500: esalt_size = sizeof (netntlm_t); break;
10348 case 5600: esalt_size = sizeof (netntlm_t); break;
10349 case 6211: esalt_size = sizeof (tc_t); break;
10350 case 6212: esalt_size = sizeof (tc_t); break;
10351 case 6213: esalt_size = sizeof (tc_t); break;
10352 case 6221: esalt_size = sizeof (tc_t); break;
10353 case 6222: esalt_size = sizeof (tc_t); break;
10354 case 6223: esalt_size = sizeof (tc_t); break;
10355 case 6231: esalt_size = sizeof (tc_t); break;
10356 case 6232: esalt_size = sizeof (tc_t); break;
10357 case 6233: esalt_size = sizeof (tc_t); break;
10358 case 6241: esalt_size = sizeof (tc_t); break;
10359 case 6242: esalt_size = sizeof (tc_t); break;
10360 case 6243: esalt_size = sizeof (tc_t); break;
10361 case 6600: esalt_size = sizeof (agilekey_t); break;
10362 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10363 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10364 case 7300: esalt_size = sizeof (rakp_t); break;
10365 case 7500: esalt_size = sizeof (krb5pa_t); break;
10366 case 8200: esalt_size = sizeof (cloudkey_t); break;
10367 case 8800: esalt_size = sizeof (androidfde_t); break;
10368 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10369 case 9400: esalt_size = sizeof (office2007_t); break;
10370 case 9500: esalt_size = sizeof (office2010_t); break;
10371 case 9600: esalt_size = sizeof (office2013_t); break;
10372 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10373 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10374 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10375 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10376 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10377 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10378 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10379 case 10200: esalt_size = sizeof (cram_md5_t); break;
10380 case 10400: esalt_size = sizeof (pdf_t); break;
10381 case 10410: esalt_size = sizeof (pdf_t); break;
10382 case 10420: esalt_size = sizeof (pdf_t); break;
10383 case 10500: esalt_size = sizeof (pdf_t); break;
10384 case 10600: esalt_size = sizeof (pdf_t); break;
10385 case 10700: esalt_size = sizeof (pdf_t); break;
10386 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10387 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10388 case 11400: esalt_size = sizeof (sip_t); break;
10389 case 11600: esalt_size = sizeof (seven_zip_t); break;
10390 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10391 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10392 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10393 case 13000: esalt_size = sizeof (rar5_t); break;
10394 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10395 case 13400: esalt_size = sizeof (keepass_t); break;
10396 }
10397
10398 data.esalt_size = esalt_size;
10399
10400 /**
10401 * choose dictionary parser
10402 */
10403
10404 if (hash_type == HASH_TYPE_LM)
10405 {
10406 get_next_word_func = get_next_word_lm;
10407 }
10408 else if (opts_type & OPTS_TYPE_PT_UPPER)
10409 {
10410 get_next_word_func = get_next_word_uc;
10411 }
10412 else
10413 {
10414 get_next_word_func = get_next_word_std;
10415 }
10416
10417 /**
10418 * dictstat
10419 */
10420
10421 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10422
10423 #ifdef _POSIX
10424 size_t dictstat_nmemb = 0;
10425 #endif
10426
10427 #ifdef _WIN
10428 uint dictstat_nmemb = 0;
10429 #endif
10430
10431 char dictstat[256] = { 0 };
10432
10433 FILE *dictstat_fp = NULL;
10434
10435 if (keyspace == 0)
10436 {
10437 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10438
10439 dictstat_fp = fopen (dictstat, "rb");
10440
10441 if (dictstat_fp)
10442 {
10443 #ifdef _POSIX
10444 struct stat tmpstat;
10445
10446 fstat (fileno (dictstat_fp), &tmpstat);
10447 #endif
10448
10449 #ifdef _WIN
10450 struct stat64 tmpstat;
10451
10452 _fstat64 (fileno (dictstat_fp), &tmpstat);
10453 #endif
10454
10455 if (tmpstat.st_mtime < COMPTIME)
10456 {
10457 /* with v0.15 the format changed so we have to ensure user is using a good version
10458 since there is no version-header in the dictstat file */
10459
10460 fclose (dictstat_fp);
10461
10462 unlink (dictstat);
10463 }
10464 else
10465 {
10466 while (!feof (dictstat_fp))
10467 {
10468 dictstat_t d;
10469
10470 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10471
10472 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10473
10474 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10475 {
10476 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10477
10478 return -1;
10479 }
10480 }
10481
10482 fclose (dictstat_fp);
10483 }
10484 }
10485 }
10486
10487 /**
10488 * potfile
10489 */
10490
10491 char potfile[256] = { 0 };
10492
10493 if (potfile_path == NULL)
10494 {
10495 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10496 }
10497 else
10498 {
10499 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10500 }
10501
10502 data.pot_fp = NULL;
10503
10504 FILE *out_fp = NULL;
10505 FILE *pot_fp = NULL;
10506
10507 if (show == 1 || left == 1)
10508 {
10509 pot_fp = fopen (potfile, "rb");
10510
10511 if (pot_fp == NULL)
10512 {
10513 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10514
10515 return (-1);
10516 }
10517
10518 if (outfile != NULL)
10519 {
10520 if ((out_fp = fopen (outfile, "ab")) == NULL)
10521 {
10522 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10523
10524 fclose (pot_fp);
10525
10526 return (-1);
10527 }
10528 }
10529 else
10530 {
10531 out_fp = stdout;
10532 }
10533 }
10534 else
10535 {
10536 if (potfile_disable == 0)
10537 {
10538 pot_fp = fopen (potfile, "ab");
10539
10540 if (pot_fp == NULL)
10541 {
10542 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10543
10544 return (-1);
10545 }
10546
10547 data.pot_fp = pot_fp;
10548 }
10549 }
10550
10551 pot_t *pot = NULL;
10552
10553 uint pot_cnt = 0;
10554 uint pot_avail = 0;
10555
10556 if (show == 1 || left == 1)
10557 {
10558 SUPPRESS_OUTPUT = 1;
10559
10560 pot_avail = count_lines (pot_fp);
10561
10562 rewind (pot_fp);
10563
10564 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10565
10566 uint pot_hashes_avail = 0;
10567
10568 uint line_num = 0;
10569
10570 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10571
10572 while (!feof (pot_fp))
10573 {
10574 line_num++;
10575
10576 int line_len = fgetl (pot_fp, line_buf);
10577
10578 if (line_len == 0) continue;
10579
10580 char *plain_buf = line_buf + line_len;
10581
10582 pot_t *pot_ptr = &pot[pot_cnt];
10583
10584 hash_t *hashes_buf = &pot_ptr->hash;
10585
10586 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10587 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10588
10589 if (pot_cnt == pot_hashes_avail)
10590 {
10591 uint pos = 0;
10592
10593 for (pos = 0; pos < INCR_POT; pos++)
10594 {
10595 if ((pot_cnt + pos) >= pot_avail) break;
10596
10597 pot_t *tmp_pot = &pot[pot_cnt + pos];
10598
10599 hash_t *tmp_hash = &tmp_pot->hash;
10600
10601 tmp_hash->digest = mymalloc (dgst_size);
10602
10603 if (isSalted)
10604 {
10605 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10606 }
10607
10608 if (esalt_size)
10609 {
10610 tmp_hash->esalt = mymalloc (esalt_size);
10611 }
10612
10613 pot_hashes_avail++;
10614 }
10615 }
10616
10617 int plain_len = 0;
10618
10619 int parser_status;
10620
10621 int iter = MAX_CUT_TRIES;
10622
10623 do
10624 {
10625 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10626 {
10627 if (line_buf[i] == ':')
10628 {
10629 line_len--;
10630
10631 break;
10632 }
10633 }
10634
10635 if (data.hash_mode != 2500)
10636 {
10637 parser_status = parse_func (line_buf, line_len, hashes_buf);
10638 }
10639 else
10640 {
10641 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10642
10643 if (line_len > max_salt_size)
10644 {
10645 parser_status = PARSER_GLOBAL_LENGTH;
10646 }
10647 else
10648 {
10649 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10650
10651 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10652
10653 hashes_buf->salt->salt_len = line_len;
10654
10655 parser_status = PARSER_OK;
10656 }
10657 }
10658
10659 // if NOT parsed without error, we add the ":" to the plain
10660
10661 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10662 {
10663 plain_len++;
10664 plain_buf--;
10665 }
10666
10667 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10668
10669 if (parser_status < PARSER_GLOBAL_ZERO)
10670 {
10671 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10672
10673 continue;
10674 }
10675
10676 if (plain_len >= 255) continue;
10677
10678 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10679
10680 pot_ptr->plain_len = plain_len;
10681
10682 pot_cnt++;
10683 }
10684
10685 myfree (line_buf);
10686
10687 fclose (pot_fp);
10688
10689 SUPPRESS_OUTPUT = 0;
10690
10691 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10692 }
10693
10694 /**
10695 * word len
10696 */
10697
10698 uint pw_min = PW_MIN;
10699 uint pw_max = PW_MAX;
10700
10701 switch (hash_mode)
10702 {
10703 case 125: if (pw_max > 32) pw_max = 32;
10704 break;
10705 case 400: if (pw_max > 40) pw_max = 40;
10706 break;
10707 case 500: if (pw_max > 16) pw_max = 16;
10708 break;
10709 case 1500: if (pw_max > 8) pw_max = 8;
10710 break;
10711 case 1600: if (pw_max > 16) pw_max = 16;
10712 break;
10713 case 1800: if (pw_max > 16) pw_max = 16;
10714 break;
10715 case 2100: if (pw_max > 16) pw_max = 16;
10716 break;
10717 case 2500: if (pw_min < 8) pw_min = 8;
10718 break;
10719 case 3000: if (pw_max > 7) pw_max = 7;
10720 break;
10721 case 5200: if (pw_max > 24) pw_max = 24;
10722 break;
10723 case 5800: if (pw_max > 16) pw_max = 16;
10724 break;
10725 case 6300: if (pw_max > 16) pw_max = 16;
10726 break;
10727 case 7400: if (pw_max > 16) pw_max = 16;
10728 break;
10729 case 7900: if (pw_max > 48) pw_max = 48;
10730 break;
10731 case 8500: if (pw_max > 8) pw_max = 8;
10732 break;
10733 case 8600: if (pw_max > 16) pw_max = 16;
10734 break;
10735 case 9710: pw_min = 5;
10736 pw_max = 5;
10737 break;
10738 case 9810: pw_min = 5;
10739 pw_max = 5;
10740 break;
10741 case 10410: pw_min = 5;
10742 pw_max = 5;
10743 break;
10744 case 10300: if (pw_max < 3) pw_min = 3;
10745 if (pw_max > 40) pw_max = 40;
10746 break;
10747 case 10500: if (pw_max < 3) pw_min = 3;
10748 if (pw_max > 40) pw_max = 40;
10749 break;
10750 case 10700: if (pw_max > 16) pw_max = 16;
10751 break;
10752 case 11300: if (pw_max > 40) pw_max = 40;
10753 break;
10754 case 12500: if (pw_max > 20) pw_max = 20;
10755 break;
10756 case 12800: if (pw_max > 24) pw_max = 24;
10757 break;
10758 }
10759
10760 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10761 {
10762 switch (attack_kern)
10763 {
10764 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10765 break;
10766 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10767 break;
10768 }
10769 }
10770
10771 /**
10772 * charsets : keep them together for more easy maintainnce
10773 */
10774
10775 cs_t mp_sys[6] = { { { 0 }, 0 } };
10776 cs_t mp_usr[4] = { { { 0 }, 0 } };
10777
10778 mp_setup_sys (mp_sys);
10779
10780 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10781 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10782 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10783 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10784
10785 /**
10786 * load hashes, part I: find input mode, count hashes
10787 */
10788
10789 uint hashlist_mode = 0;
10790 uint hashlist_format = HLFMT_HASHCAT;
10791
10792 uint hashes_avail = 0;
10793
10794 if (benchmark == 0)
10795 {
10796 struct stat f;
10797
10798 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10799
10800 if ((hash_mode == 2500) ||
10801 (hash_mode == 5200) ||
10802 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10803 (hash_mode == 9000))
10804 {
10805 hashlist_mode = HL_MODE_ARG;
10806
10807 char *hashfile = myargv[optind];
10808
10809 data.hashfile = hashfile;
10810
10811 logfile_top_var_string ("target", hashfile);
10812 }
10813
10814 if (hashlist_mode == HL_MODE_ARG)
10815 {
10816 if (hash_mode == 2500)
10817 {
10818 struct stat st;
10819
10820 if (stat (data.hashfile, &st) == -1)
10821 {
10822 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10823
10824 return (-1);
10825 }
10826
10827 hashes_avail = st.st_size / sizeof (hccap_t);
10828 }
10829 else
10830 {
10831 hashes_avail = 1;
10832 }
10833 }
10834 else if (hashlist_mode == HL_MODE_FILE)
10835 {
10836 char *hashfile = myargv[optind];
10837
10838 data.hashfile = hashfile;
10839
10840 logfile_top_var_string ("target", hashfile);
10841
10842 FILE *fp = NULL;
10843
10844 if ((fp = fopen (hashfile, "rb")) == NULL)
10845 {
10846 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10847
10848 return (-1);
10849 }
10850
10851 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10852
10853 hashes_avail = count_lines (fp);
10854
10855 rewind (fp);
10856
10857 if (hashes_avail == 0)
10858 {
10859 log_error ("ERROR: hashfile is empty or corrupt");
10860
10861 fclose (fp);
10862
10863 return (-1);
10864 }
10865
10866 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10867
10868 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10869 {
10870 log_error ("ERROR: remove not supported in native hashfile-format mode");
10871
10872 fclose (fp);
10873
10874 return (-1);
10875 }
10876
10877 fclose (fp);
10878 }
10879 }
10880 else
10881 {
10882 hashlist_mode = HL_MODE_ARG;
10883
10884 hashes_avail = 1;
10885 }
10886
10887 if (hash_mode == 3000) hashes_avail *= 2;
10888
10889 data.hashlist_mode = hashlist_mode;
10890 data.hashlist_format = hashlist_format;
10891
10892 logfile_top_uint (hashlist_mode);
10893 logfile_top_uint (hashlist_format);
10894
10895 /**
10896 * load hashes, part II: allocate required memory, set pointers
10897 */
10898
10899 hash_t *hashes_buf = NULL;
10900 void *digests_buf = NULL;
10901 salt_t *salts_buf = NULL;
10902 void *esalts_buf = NULL;
10903
10904 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10905
10906 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10907
10908 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10909 {
10910 u32 hash_pos;
10911
10912 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10913 {
10914 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10915
10916 hashes_buf[hash_pos].hash_info = hash_info;
10917
10918 if (username && (remove || show || left))
10919 {
10920 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10921 }
10922
10923 if (benchmark)
10924 {
10925 hash_info->orighash = (char *) mymalloc (256);
10926 }
10927 }
10928 }
10929
10930 if (isSalted)
10931 {
10932 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10933
10934 if (esalt_size)
10935 {
10936 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10937 }
10938 }
10939 else
10940 {
10941 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10942 }
10943
10944 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10945 {
10946 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10947
10948 if (isSalted)
10949 {
10950 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10951
10952 if (esalt_size)
10953 {
10954 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10955 }
10956 }
10957 else
10958 {
10959 hashes_buf[hash_pos].salt = &salts_buf[0];
10960 }
10961 }
10962
10963 /**
10964 * load hashes, part III: parse hashes or generate them if benchmark
10965 */
10966
10967 uint hashes_cnt = 0;
10968
10969 if (benchmark == 0)
10970 {
10971 if (keyspace == 1)
10972 {
10973 // useless to read hash file for keyspace, cheat a little bit w/ optind
10974 }
10975 else if (hashes_avail == 0)
10976 {
10977 }
10978 else if (hashlist_mode == HL_MODE_ARG)
10979 {
10980 char *input_buf = myargv[optind];
10981
10982 uint input_len = strlen (input_buf);
10983
10984 logfile_top_var_string ("target", input_buf);
10985
10986 char *hash_buf = NULL;
10987 int hash_len = 0;
10988
10989 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10990
10991 bool hash_fmt_error = 0;
10992
10993 if (hash_len < 1) hash_fmt_error = 1;
10994 if (hash_buf == NULL) hash_fmt_error = 1;
10995
10996 if (hash_fmt_error)
10997 {
10998 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
10999 }
11000 else
11001 {
11002 if (opts_type & OPTS_TYPE_HASH_COPY)
11003 {
11004 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11005
11006 hash_info_tmp->orighash = mystrdup (hash_buf);
11007 }
11008
11009 if (isSalted)
11010 {
11011 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11012 }
11013
11014 int parser_status = PARSER_OK;
11015
11016 if (hash_mode == 2500)
11017 {
11018 if (hash_len == 0)
11019 {
11020 log_error ("ERROR: hccap file not specified");
11021
11022 return (-1);
11023 }
11024
11025 hashlist_mode = HL_MODE_FILE;
11026
11027 data.hashlist_mode = hashlist_mode;
11028
11029 FILE *fp = fopen (hash_buf, "rb");
11030
11031 if (fp == NULL)
11032 {
11033 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11034
11035 return (-1);
11036 }
11037
11038 if (hashes_avail < 1)
11039 {
11040 log_error ("ERROR: hccap file is empty or corrupt");
11041
11042 fclose (fp);
11043
11044 return (-1);
11045 }
11046
11047 uint hccap_size = sizeof (hccap_t);
11048
11049 char *in = (char *) mymalloc (hccap_size);
11050
11051 while (!feof (fp))
11052 {
11053 int n = fread (in, hccap_size, 1, fp);
11054
11055 if (n != 1)
11056 {
11057 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11058
11059 break;
11060 }
11061
11062 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11063
11064 if (parser_status != PARSER_OK)
11065 {
11066 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11067
11068 continue;
11069 }
11070
11071 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11072
11073 if ((show == 1) || (left == 1))
11074 {
11075 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11076
11077 char *salt_ptr = (char *) tmp_salt->salt_buf;
11078
11079 int cur_pos = tmp_salt->salt_len;
11080 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11081
11082 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11083
11084 // do the appending task
11085
11086 snprintf (salt_ptr + cur_pos,
11087 rem_len,
11088 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11089 wpa->orig_mac1[0],
11090 wpa->orig_mac1[1],
11091 wpa->orig_mac1[2],
11092 wpa->orig_mac1[3],
11093 wpa->orig_mac1[4],
11094 wpa->orig_mac1[5],
11095 wpa->orig_mac2[0],
11096 wpa->orig_mac2[1],
11097 wpa->orig_mac2[2],
11098 wpa->orig_mac2[3],
11099 wpa->orig_mac2[4],
11100 wpa->orig_mac2[5]);
11101
11102 // memset () the remaining part of the salt
11103
11104 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11105 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11106
11107 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11108
11109 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11110 }
11111
11112 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);
11113 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);
11114
11115 hashes_cnt++;
11116 }
11117
11118 fclose (fp);
11119
11120 myfree (in);
11121 }
11122 else if (hash_mode == 3000)
11123 {
11124 if (hash_len == 32)
11125 {
11126 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11127
11128 hash_t *lm_hash_left = NULL;
11129
11130 if (parser_status == PARSER_OK)
11131 {
11132 lm_hash_left = &hashes_buf[hashes_cnt];
11133
11134 hashes_cnt++;
11135 }
11136 else
11137 {
11138 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11139 }
11140
11141 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11142
11143 hash_t *lm_hash_right = NULL;
11144
11145 if (parser_status == PARSER_OK)
11146 {
11147 lm_hash_right = &hashes_buf[hashes_cnt];
11148
11149 hashes_cnt++;
11150 }
11151 else
11152 {
11153 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11154 }
11155
11156 // show / left
11157
11158 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11159 {
11160 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);
11161 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);
11162 }
11163 }
11164 else
11165 {
11166 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11167
11168 if (parser_status == PARSER_OK)
11169 {
11170 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11171 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11172 }
11173
11174 if (parser_status == PARSER_OK)
11175 {
11176 hashes_cnt++;
11177 }
11178 else
11179 {
11180 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11181 }
11182 }
11183 }
11184 else
11185 {
11186 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11187
11188 if (parser_status == PARSER_OK)
11189 {
11190 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11191 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11192 }
11193
11194 if (parser_status == PARSER_OK)
11195 {
11196 hashes_cnt++;
11197 }
11198 else
11199 {
11200 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11201 }
11202 }
11203 }
11204 }
11205 else if (hashlist_mode == HL_MODE_FILE)
11206 {
11207 char *hashfile = data.hashfile;
11208
11209 FILE *fp;
11210
11211 if ((fp = fopen (hashfile, "rb")) == NULL)
11212 {
11213 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11214
11215 return (-1);
11216 }
11217
11218 uint line_num = 0;
11219
11220 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11221
11222 while (!feof (fp))
11223 {
11224 line_num++;
11225
11226 int line_len = fgetl (fp, line_buf);
11227
11228 if (line_len == 0) continue;
11229
11230 char *hash_buf = NULL;
11231 int hash_len = 0;
11232
11233 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11234
11235 bool hash_fmt_error = 0;
11236
11237 if (hash_len < 1) hash_fmt_error = 1;
11238 if (hash_buf == NULL) hash_fmt_error = 1;
11239
11240 if (hash_fmt_error)
11241 {
11242 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11243
11244 continue;
11245 }
11246
11247 if (username)
11248 {
11249 char *user_buf = NULL;
11250 int user_len = 0;
11251
11252 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11253
11254 if (remove || show)
11255 {
11256 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11257
11258 *user = (user_t *) mymalloc (sizeof (user_t));
11259
11260 user_t *user_ptr = *user;
11261
11262 if (user_buf != NULL)
11263 {
11264 user_ptr->user_name = mystrdup (user_buf);
11265 }
11266 else
11267 {
11268 user_ptr->user_name = mystrdup ("");
11269 }
11270
11271 user_ptr->user_len = user_len;
11272 }
11273 }
11274
11275 if (opts_type & OPTS_TYPE_HASH_COPY)
11276 {
11277 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11278
11279 hash_info_tmp->orighash = mystrdup (hash_buf);
11280 }
11281
11282 if (isSalted)
11283 {
11284 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11285 }
11286
11287 if (hash_mode == 3000)
11288 {
11289 if (hash_len == 32)
11290 {
11291 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11292
11293 if (parser_status < PARSER_GLOBAL_ZERO)
11294 {
11295 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11296
11297 continue;
11298 }
11299
11300 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11301
11302 hashes_cnt++;
11303
11304 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11305
11306 if (parser_status < PARSER_GLOBAL_ZERO)
11307 {
11308 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11309
11310 continue;
11311 }
11312
11313 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11314
11315 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);
11316
11317 hashes_cnt++;
11318
11319 // show / left
11320
11321 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);
11322 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);
11323 }
11324 else
11325 {
11326 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11327
11328 if (parser_status < PARSER_GLOBAL_ZERO)
11329 {
11330 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11331
11332 continue;
11333 }
11334
11335 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);
11336
11337 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11338 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11339
11340 hashes_cnt++;
11341 }
11342 }
11343 else
11344 {
11345 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11346
11347 if (parser_status < PARSER_GLOBAL_ZERO)
11348 {
11349 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11350
11351 continue;
11352 }
11353
11354 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);
11355
11356 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11357 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11358
11359 hashes_cnt++;
11360 }
11361 }
11362
11363 myfree (line_buf);
11364
11365 fclose (fp);
11366
11367 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11368
11369 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11370 }
11371 }
11372 else
11373 {
11374 if (isSalted)
11375 {
11376 hashes_buf[0].salt->salt_len = 8;
11377
11378 // special salt handling
11379
11380 switch (hash_mode)
11381 {
11382 case 1500: hashes_buf[0].salt->salt_len = 2;
11383 break;
11384 case 1731: hashes_buf[0].salt->salt_len = 4;
11385 break;
11386 case 2410: hashes_buf[0].salt->salt_len = 4;
11387 break;
11388 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11389 break;
11390 case 3100: hashes_buf[0].salt->salt_len = 1;
11391 break;
11392 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11393 break;
11394 case 5800: hashes_buf[0].salt->salt_len = 16;
11395 break;
11396 case 6800: hashes_buf[0].salt->salt_len = 32;
11397 break;
11398 case 8400: hashes_buf[0].salt->salt_len = 40;
11399 break;
11400 case 8800: hashes_buf[0].salt->salt_len = 16;
11401 break;
11402 case 8900: hashes_buf[0].salt->salt_len = 16;
11403 hashes_buf[0].salt->scrypt_N = 1024;
11404 hashes_buf[0].salt->scrypt_r = 1;
11405 hashes_buf[0].salt->scrypt_p = 1;
11406 break;
11407 case 9100: hashes_buf[0].salt->salt_len = 16;
11408 break;
11409 case 9300: hashes_buf[0].salt->salt_len = 14;
11410 hashes_buf[0].salt->scrypt_N = 16384;
11411 hashes_buf[0].salt->scrypt_r = 1;
11412 hashes_buf[0].salt->scrypt_p = 1;
11413 break;
11414 case 9400: hashes_buf[0].salt->salt_len = 16;
11415 break;
11416 case 9500: hashes_buf[0].salt->salt_len = 16;
11417 break;
11418 case 9600: hashes_buf[0].salt->salt_len = 16;
11419 break;
11420 case 9700: hashes_buf[0].salt->salt_len = 16;
11421 break;
11422 case 9710: hashes_buf[0].salt->salt_len = 16;
11423 break;
11424 case 9720: hashes_buf[0].salt->salt_len = 16;
11425 break;
11426 case 9800: hashes_buf[0].salt->salt_len = 16;
11427 break;
11428 case 9810: hashes_buf[0].salt->salt_len = 16;
11429 break;
11430 case 9820: hashes_buf[0].salt->salt_len = 16;
11431 break;
11432 case 10300: hashes_buf[0].salt->salt_len = 12;
11433 break;
11434 case 11500: hashes_buf[0].salt->salt_len = 4;
11435 break;
11436 case 11600: hashes_buf[0].salt->salt_len = 4;
11437 break;
11438 case 12400: hashes_buf[0].salt->salt_len = 4;
11439 break;
11440 case 12500: hashes_buf[0].salt->salt_len = 8;
11441 break;
11442 case 12600: hashes_buf[0].salt->salt_len = 64;
11443 break;
11444 }
11445
11446 // special esalt handling
11447
11448 switch (hash_mode)
11449 {
11450 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11451 break;
11452 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11453 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11454 break;
11455 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11456 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11457 break;
11458 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11459 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11460 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11461 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11462 break;
11463 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11464 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11465 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11466 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11467 break;
11468 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11469 break;
11470 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11471 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11472 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11473 break;
11474 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11475 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11476 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11477 break;
11478 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11479 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11480 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11481 break;
11482 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11483 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11484 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11485 break;
11486 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11487 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11488 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11489 break;
11490 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11491 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11492 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11493 break;
11494 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11495 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11496 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11497 break;
11498 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11499 break;
11500 }
11501 }
11502
11503 // set hashfile
11504
11505 switch (hash_mode)
11506 {
11507 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11508 break;
11509 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11510 break;
11511 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11512 break;
11513 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11514 break;
11515 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11516 break;
11517 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11518 break;
11519 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11520 break;
11521 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11522 break;
11523 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11524 break;
11525 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11526 break;
11527 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11528 break;
11529 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11530 break;
11531 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11532 break;
11533 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11534 break;
11535 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11536 break;
11537 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11538 break;
11539 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11540 break;
11541 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11542 break;
11543 }
11544
11545 // set default iterations
11546
11547 switch (hash_mode)
11548 {
11549 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11550 break;
11551 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11552 break;
11553 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11554 break;
11555 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11556 break;
11557 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11558 break;
11559 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11560 break;
11561 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11562 break;
11563 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11564 break;
11565 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11566 break;
11567 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11568 break;
11569 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11570 break;
11571 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11572 break;
11573 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11574 break;
11575 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11576 break;
11577 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11578 break;
11579 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11580 break;
11581 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11582 break;
11583 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11584 break;
11585 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11586 break;
11587 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11588 break;
11589 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11590 break;
11591 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11592 break;
11593 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11594 break;
11595 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11596 break;
11597 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11598 break;
11599 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11600 break;
11601 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11602 break;
11603 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11604 break;
11605 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11606 break;
11607 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11608 break;
11609 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11610 break;
11611 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11612 break;
11613 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11614 break;
11615 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11616 break;
11617 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11618 break;
11619 case 8900: hashes_buf[0].salt->salt_iter = 1;
11620 break;
11621 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11622 break;
11623 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11624 break;
11625 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11626 break;
11627 case 9300: hashes_buf[0].salt->salt_iter = 1;
11628 break;
11629 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11630 break;
11631 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11632 break;
11633 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11634 break;
11635 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11636 break;
11637 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11638 break;
11639 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11640 break;
11641 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11642 break;
11643 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11644 break;
11645 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11646 break;
11647 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11648 break;
11649 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11650 break;
11651 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11652 break;
11653 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11654 break;
11655 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11656 break;
11657 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11658 break;
11659 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11660 break;
11661 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11662 break;
11663 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11664 break;
11665 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11666 break;
11667 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11668 break;
11669 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11670 break;
11671 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
11672 break;
11673 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
11674 break;
11675 }
11676
11677 hashes_cnt = 1;
11678 }
11679
11680 if (show == 1 || left == 1)
11681 {
11682 for (uint i = 0; i < pot_cnt; i++)
11683 {
11684 pot_t *pot_ptr = &pot[i];
11685
11686 hash_t *hashes_buf = &pot_ptr->hash;
11687
11688 local_free (hashes_buf->digest);
11689
11690 if (isSalted)
11691 {
11692 local_free (hashes_buf->salt);
11693 }
11694 }
11695
11696 local_free (pot);
11697
11698 if (data.quiet == 0) log_info_nn ("");
11699
11700 return (0);
11701 }
11702
11703 if (keyspace == 0)
11704 {
11705 if (hashes_cnt == 0)
11706 {
11707 log_error ("ERROR: No hashes loaded");
11708
11709 return (-1);
11710 }
11711 }
11712
11713 /**
11714 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11715 */
11716
11717 if (data.outfile != NULL)
11718 {
11719 if (data.hashfile != NULL)
11720 {
11721 #ifdef _POSIX
11722 struct stat tmpstat_outfile;
11723 struct stat tmpstat_hashfile;
11724 #endif
11725
11726 #ifdef _WIN
11727 struct stat64 tmpstat_outfile;
11728 struct stat64 tmpstat_hashfile;
11729 #endif
11730
11731 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11732
11733 if (tmp_outfile_fp)
11734 {
11735 #ifdef _POSIX
11736 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11737 #endif
11738
11739 #ifdef _WIN
11740 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11741 #endif
11742
11743 fclose (tmp_outfile_fp);
11744 }
11745
11746 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11747
11748 if (tmp_hashfile_fp)
11749 {
11750 #ifdef _POSIX
11751 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11752 #endif
11753
11754 #ifdef _WIN
11755 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11756 #endif
11757
11758 fclose (tmp_hashfile_fp);
11759 }
11760
11761 if (tmp_outfile_fp && tmp_outfile_fp)
11762 {
11763 tmpstat_outfile.st_mode = 0;
11764 tmpstat_outfile.st_nlink = 0;
11765 tmpstat_outfile.st_uid = 0;
11766 tmpstat_outfile.st_gid = 0;
11767 tmpstat_outfile.st_rdev = 0;
11768 tmpstat_outfile.st_atime = 0;
11769
11770 tmpstat_hashfile.st_mode = 0;
11771 tmpstat_hashfile.st_nlink = 0;
11772 tmpstat_hashfile.st_uid = 0;
11773 tmpstat_hashfile.st_gid = 0;
11774 tmpstat_hashfile.st_rdev = 0;
11775 tmpstat_hashfile.st_atime = 0;
11776
11777 #ifdef _POSIX
11778 tmpstat_outfile.st_blksize = 0;
11779 tmpstat_outfile.st_blocks = 0;
11780
11781 tmpstat_hashfile.st_blksize = 0;
11782 tmpstat_hashfile.st_blocks = 0;
11783 #endif
11784
11785 #ifdef _POSIX
11786 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11787 {
11788 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11789
11790 return (-1);
11791 }
11792 #endif
11793
11794 #ifdef _WIN
11795 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11796 {
11797 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11798
11799 return (-1);
11800 }
11801 #endif
11802 }
11803 }
11804 }
11805
11806 /**
11807 * Remove duplicates
11808 */
11809
11810 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11811
11812 if (isSalted)
11813 {
11814 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11815 }
11816 else
11817 {
11818 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11819 }
11820
11821 uint hashes_cnt_orig = hashes_cnt;
11822
11823 hashes_cnt = 1;
11824
11825 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11826 {
11827 if (isSalted)
11828 {
11829 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11830 {
11831 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11832 }
11833 }
11834 else
11835 {
11836 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11837 }
11838
11839 if (hashes_pos > hashes_cnt)
11840 {
11841 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11842 }
11843
11844 hashes_cnt++;
11845 }
11846
11847 /**
11848 * Potfile removes
11849 */
11850
11851 uint potfile_remove_cracks = 0;
11852
11853 if (potfile_disable == 0)
11854 {
11855 hash_t hash_buf;
11856
11857 hash_buf.digest = mymalloc (dgst_size);
11858 hash_buf.salt = NULL;
11859 hash_buf.esalt = NULL;
11860 hash_buf.hash_info = NULL;
11861 hash_buf.cracked = 0;
11862
11863 if (isSalted)
11864 {
11865 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11866 }
11867
11868 if (esalt_size)
11869 {
11870 hash_buf.esalt = mymalloc (esalt_size);
11871 }
11872
11873 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11874
11875 // no solution for these special hash types (for instane because they use hashfile in output etc)
11876 if ((hash_mode != 5200) &&
11877 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11878 (hash_mode != 9000))
11879 {
11880 FILE *fp = fopen (potfile, "rb");
11881
11882 if (fp != NULL)
11883 {
11884 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11885
11886 // to be safe work with a copy (because of line_len loop, i etc)
11887 // moved up here because it's easier to handle continue case
11888 // it's just 64kb
11889
11890 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
11891
11892 while (!feof (fp))
11893 {
11894 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
11895
11896 if (ptr == NULL) break;
11897
11898 int line_len = strlen (line_buf);
11899
11900 if (line_len == 0) continue;
11901
11902 int iter = MAX_CUT_TRIES;
11903
11904 for (int i = line_len - 1; i && iter; i--, line_len--)
11905 {
11906 if (line_buf[i] != ':') continue;
11907
11908 if (isSalted)
11909 {
11910 memset (hash_buf.salt, 0, sizeof (salt_t));
11911 }
11912
11913 hash_t *found = NULL;
11914
11915 if (hash_mode == 6800)
11916 {
11917 if (i < 64) // 64 = 16 * uint in salt_buf[]
11918 {
11919 // manipulate salt_buf
11920 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11921
11922 hash_buf.salt->salt_len = i;
11923
11924 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11925 }
11926 }
11927 else if (hash_mode == 2500)
11928 {
11929 if (i < 64) // 64 = 16 * uint in salt_buf[]
11930 {
11931 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11932 // manipulate salt_buf
11933
11934 memcpy (line_buf_cpy, line_buf, i);
11935
11936 char *mac2_pos = strrchr (line_buf_cpy, ':');
11937
11938 if (mac2_pos == NULL) continue;
11939
11940 mac2_pos[0] = 0;
11941 mac2_pos++;
11942
11943 if (strlen (mac2_pos) != 12) continue;
11944
11945 char *mac1_pos = strrchr (line_buf_cpy, ':');
11946
11947 if (mac1_pos == NULL) continue;
11948
11949 mac1_pos[0] = 0;
11950 mac1_pos++;
11951
11952 if (strlen (mac1_pos) != 12) continue;
11953
11954 uint essid_length = mac1_pos - line_buf_cpy - 1;
11955
11956 // here we need the ESSID
11957 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11958
11959 hash_buf.salt->salt_len = essid_length;
11960
11961 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11962
11963 if (found)
11964 {
11965 wpa_t *wpa = (wpa_t *) found->esalt;
11966
11967 // compare hex string(s) vs binary MAC address(es)
11968
11969 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11970 {
11971 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11972 {
11973 found = NULL;
11974
11975 break;
11976 }
11977 }
11978
11979 // early skip ;)
11980 if (!found) continue;
11981
11982 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11983 {
11984 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11985 {
11986 found = NULL;
11987
11988 break;
11989 }
11990 }
11991 }
11992 }
11993 }
11994 else
11995 {
11996 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11997
11998 if (parser_status == PARSER_OK)
11999 {
12000 if (isSalted)
12001 {
12002 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12003 }
12004 else
12005 {
12006 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12007 }
12008 }
12009 }
12010
12011 if (found == NULL) continue;
12012
12013 if (!found->cracked) potfile_remove_cracks++;
12014
12015 found->cracked = 1;
12016
12017 if (found) break;
12018
12019 iter--;
12020 }
12021 }
12022
12023 myfree (line_buf_cpy);
12024
12025 myfree (line_buf);
12026
12027 fclose (fp);
12028 }
12029 }
12030
12031 if (esalt_size)
12032 {
12033 local_free (hash_buf.esalt);
12034 }
12035
12036 if (isSalted)
12037 {
12038 local_free (hash_buf.salt);
12039 }
12040
12041 local_free (hash_buf.digest);
12042 }
12043
12044 /**
12045 * Now generate all the buffers required for later
12046 */
12047
12048 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12049
12050 salt_t *salts_buf_new = NULL;
12051 void *esalts_buf_new = NULL;
12052
12053 if (isSalted)
12054 {
12055 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12056
12057 if (esalt_size)
12058 {
12059 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12060 }
12061 }
12062 else
12063 {
12064 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12065 }
12066
12067 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12068
12069 uint digests_cnt = hashes_cnt;
12070 uint digests_done = 0;
12071
12072 uint size_digests = digests_cnt * dgst_size;
12073 uint size_shown = digests_cnt * sizeof (uint);
12074
12075 uint *digests_shown = (uint *) mymalloc (size_shown);
12076 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12077
12078 uint salts_cnt = 0;
12079 uint salts_done = 0;
12080
12081 hashinfo_t **hash_info = NULL;
12082
12083 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12084 {
12085 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12086
12087 if (username && (remove || show))
12088 {
12089 uint user_pos;
12090
12091 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12092 {
12093 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12094
12095 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12096 }
12097 }
12098 }
12099
12100 uint *salts_shown = (uint *) mymalloc (size_shown);
12101
12102 salt_t *salt_buf;
12103
12104 {
12105 // copied from inner loop
12106
12107 salt_buf = &salts_buf_new[salts_cnt];
12108
12109 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12110
12111 if (esalt_size)
12112 {
12113 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12114 }
12115
12116 salt_buf->digests_cnt = 0;
12117 salt_buf->digests_done = 0;
12118 salt_buf->digests_offset = 0;
12119
12120 salts_cnt++;
12121 }
12122
12123 if (hashes_buf[0].cracked == 1)
12124 {
12125 digests_shown[0] = 1;
12126
12127 digests_done++;
12128
12129 salt_buf->digests_done++;
12130 }
12131
12132 salt_buf->digests_cnt++;
12133
12134 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12135
12136 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12137 {
12138 hash_info[0] = hashes_buf[0].hash_info;
12139 }
12140
12141 // copy from inner loop
12142
12143 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12144 {
12145 if (isSalted)
12146 {
12147 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12148 {
12149 salt_buf = &salts_buf_new[salts_cnt];
12150
12151 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12152
12153 if (esalt_size)
12154 {
12155 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12156 }
12157
12158 salt_buf->digests_cnt = 0;
12159 salt_buf->digests_done = 0;
12160 salt_buf->digests_offset = hashes_pos;
12161
12162 salts_cnt++;
12163 }
12164 }
12165
12166 if (hashes_buf[hashes_pos].cracked == 1)
12167 {
12168 digests_shown[hashes_pos] = 1;
12169
12170 digests_done++;
12171
12172 salt_buf->digests_done++;
12173 }
12174
12175 salt_buf->digests_cnt++;
12176
12177 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12178
12179 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12180 {
12181 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12182 }
12183 }
12184
12185 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12186 {
12187 salt_t *salt_buf = &salts_buf_new[salt_pos];
12188
12189 if (salt_buf->digests_done == salt_buf->digests_cnt)
12190 {
12191 salts_shown[salt_pos] = 1;
12192
12193 salts_done++;
12194 }
12195
12196 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12197 }
12198
12199 local_free (digests_buf);
12200 local_free (salts_buf);
12201 local_free (esalts_buf);
12202
12203 digests_buf = digests_buf_new;
12204 salts_buf = salts_buf_new;
12205 esalts_buf = esalts_buf_new;
12206
12207 local_free (hashes_buf);
12208
12209 /**
12210 * special modification not set from parser
12211 */
12212
12213 switch (hash_mode)
12214 {
12215 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12216 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12217 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12218 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12219 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12220 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12221 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12222 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12223 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12224 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12225 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12226 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12227 }
12228
12229 if (truecrypt_keyfiles)
12230 {
12231 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12232
12233 char *keyfiles = strdup (truecrypt_keyfiles);
12234
12235 char *keyfile = strtok (keyfiles, ",");
12236
12237 do
12238 {
12239 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12240
12241 } while ((keyfile = strtok (NULL, ",")) != NULL);
12242
12243 free (keyfiles);
12244 }
12245
12246 data.digests_cnt = digests_cnt;
12247 data.digests_done = digests_done;
12248 data.digests_buf = digests_buf;
12249 data.digests_shown = digests_shown;
12250 data.digests_shown_tmp = digests_shown_tmp;
12251
12252 data.salts_cnt = salts_cnt;
12253 data.salts_done = salts_done;
12254 data.salts_buf = salts_buf;
12255 data.salts_shown = salts_shown;
12256
12257 data.esalts_buf = esalts_buf;
12258 data.hash_info = hash_info;
12259
12260 /**
12261 * Automatic Optimizers
12262 */
12263
12264 if (salts_cnt == 1)
12265 opti_type |= OPTI_TYPE_SINGLE_SALT;
12266
12267 if (digests_cnt == 1)
12268 opti_type |= OPTI_TYPE_SINGLE_HASH;
12269
12270 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12271 opti_type |= OPTI_TYPE_NOT_ITERATED;
12272
12273 if (attack_mode == ATTACK_MODE_BF)
12274 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12275
12276 data.opti_type = opti_type;
12277
12278 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12279 {
12280 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12281 {
12282 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12283 {
12284 if (opts_type & OPTS_TYPE_ST_ADD80)
12285 {
12286 opts_type &= ~OPTS_TYPE_ST_ADD80;
12287 opts_type |= OPTS_TYPE_PT_ADD80;
12288 }
12289
12290 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12291 {
12292 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12293 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12294 }
12295
12296 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12297 {
12298 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12299 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12300 }
12301 }
12302 }
12303 }
12304
12305 /**
12306 * Some algorithm, like descrypt, can benefit from JIT compilation
12307 */
12308
12309 int force_jit_compilation = -1;
12310
12311 if (hash_mode == 8900)
12312 {
12313 force_jit_compilation = 8900;
12314 }
12315 else if (hash_mode == 9300)
12316 {
12317 force_jit_compilation = 8900;
12318 }
12319 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12320 {
12321 force_jit_compilation = 1500;
12322 }
12323
12324 /**
12325 * generate bitmap tables
12326 */
12327
12328 const uint bitmap_shift1 = 5;
12329 const uint bitmap_shift2 = 13;
12330
12331 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12332
12333 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12334 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12335 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12336 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12337 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12338 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12339 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12340 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12341
12342 uint bitmap_bits;
12343 uint bitmap_nums;
12344 uint bitmap_mask;
12345 uint bitmap_size;
12346
12347 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12348 {
12349 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12350
12351 bitmap_nums = 1 << bitmap_bits;
12352
12353 bitmap_mask = bitmap_nums - 1;
12354
12355 bitmap_size = bitmap_nums * sizeof (uint);
12356
12357 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12358
12359 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;
12360 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;
12361
12362 break;
12363 }
12364
12365 bitmap_nums = 1 << bitmap_bits;
12366
12367 bitmap_mask = bitmap_nums - 1;
12368
12369 bitmap_size = bitmap_nums * sizeof (uint);
12370
12371 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);
12372 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);
12373
12374 /**
12375 * prepare quick rule
12376 */
12377
12378 data.rule_buf_l = rule_buf_l;
12379 data.rule_buf_r = rule_buf_r;
12380
12381 int rule_len_l = (int) strlen (rule_buf_l);
12382 int rule_len_r = (int) strlen (rule_buf_r);
12383
12384 data.rule_len_l = rule_len_l;
12385 data.rule_len_r = rule_len_r;
12386
12387 /**
12388 * load rules
12389 */
12390
12391 uint *all_kernel_rules_cnt = NULL;
12392
12393 kernel_rule_t **all_kernel_rules_buf = NULL;
12394
12395 if (rp_files_cnt)
12396 {
12397 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12398
12399 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12400 }
12401
12402 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12403
12404 int rule_len = 0;
12405
12406 for (uint i = 0; i < rp_files_cnt; i++)
12407 {
12408 uint kernel_rules_avail = 0;
12409
12410 uint kernel_rules_cnt = 0;
12411
12412 kernel_rule_t *kernel_rules_buf = NULL;
12413
12414 char *rp_file = rp_files[i];
12415
12416 char in[BLOCK_SIZE] = { 0 };
12417 char out[BLOCK_SIZE] = { 0 };
12418
12419 FILE *fp = NULL;
12420
12421 uint rule_line = 0;
12422
12423 if ((fp = fopen (rp_file, "rb")) == NULL)
12424 {
12425 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12426
12427 return (-1);
12428 }
12429
12430 while (!feof (fp))
12431 {
12432 memset (rule_buf, 0, HCBUFSIZ);
12433
12434 rule_len = fgetl (fp, rule_buf);
12435
12436 rule_line++;
12437
12438 if (rule_len == 0) continue;
12439
12440 if (rule_buf[0] == '#') continue;
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 (in, 0, BLOCK_SIZE);
12450 memset (out, 0, BLOCK_SIZE);
12451
12452 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12453
12454 if (result == -1)
12455 {
12456 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12457
12458 continue;
12459 }
12460
12461 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12462 {
12463 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12464
12465 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12466
12467 continue;
12468 }
12469
12470 /* its so slow
12471 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12472 {
12473 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12474
12475 continue;
12476 }
12477 */
12478
12479 kernel_rules_cnt++;
12480 }
12481
12482 fclose (fp);
12483
12484 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12485
12486 all_kernel_rules_buf[i] = kernel_rules_buf;
12487 }
12488
12489 /**
12490 * merge rules or automatic rule generator
12491 */
12492
12493 uint kernel_rules_cnt = 0;
12494
12495 kernel_rule_t *kernel_rules_buf = NULL;
12496
12497 if (attack_mode == ATTACK_MODE_STRAIGHT)
12498 {
12499 if (rp_files_cnt)
12500 {
12501 kernel_rules_cnt = 1;
12502
12503 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12504
12505 repeats[0] = kernel_rules_cnt;
12506
12507 for (uint i = 0; i < rp_files_cnt; i++)
12508 {
12509 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12510
12511 repeats[i + 1] = kernel_rules_cnt;
12512 }
12513
12514 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12515
12516 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12517
12518 for (uint i = 0; i < kernel_rules_cnt; i++)
12519 {
12520 uint out_pos = 0;
12521
12522 kernel_rule_t *out = &kernel_rules_buf[i];
12523
12524 for (uint j = 0; j < rp_files_cnt; j++)
12525 {
12526 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12527 uint in_pos;
12528
12529 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12530
12531 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12532 {
12533 if (out_pos == RULES_MAX - 1)
12534 {
12535 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12536
12537 break;
12538 }
12539
12540 out->cmds[out_pos] = in->cmds[in_pos];
12541 }
12542 }
12543 }
12544
12545 local_free (repeats);
12546 }
12547 else if (rp_gen)
12548 {
12549 uint kernel_rules_avail = 0;
12550
12551 while (kernel_rules_cnt < rp_gen)
12552 {
12553 if (kernel_rules_avail == kernel_rules_cnt)
12554 {
12555 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12556
12557 kernel_rules_avail += INCR_RULES;
12558 }
12559
12560 memset (rule_buf, 0, HCBUFSIZ);
12561
12562 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12563
12564 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12565
12566 kernel_rules_cnt++;
12567 }
12568 }
12569 }
12570
12571 myfree (rule_buf);
12572
12573 /**
12574 * generate NOP rules
12575 */
12576
12577 if (kernel_rules_cnt == 0)
12578 {
12579 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12580
12581 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12582
12583 kernel_rules_cnt++;
12584 }
12585
12586 data.kernel_rules_cnt = kernel_rules_cnt;
12587 data.kernel_rules_buf = kernel_rules_buf;
12588
12589 /**
12590 * OpenCL platforms: detect
12591 */
12592
12593 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12594 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12595
12596 cl_uint platforms_cnt = 0;
12597 cl_uint platform_devices_cnt = 0;
12598
12599 if (keyspace == 0)
12600 {
12601 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12602
12603 if (platforms_cnt == 0)
12604 {
12605 log_error ("ERROR: No OpenCL compatible platform found");
12606
12607 return (-1);
12608 }
12609
12610 if (opencl_platforms_filter != (uint) -1)
12611 {
12612 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
12613
12614 if (opencl_platforms_filter > platform_cnt_mask)
12615 {
12616 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
12617
12618 return (-1);
12619 }
12620 }
12621 }
12622
12623 /**
12624 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12625 */
12626
12627 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12628 {
12629 cl_platform_id platform = platforms[platform_id];
12630
12631 char platform_vendor[INFOSZ] = { 0 };
12632
12633 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12634
12635 #ifdef HAVE_HWMON
12636 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12637 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12638 {
12639 // make sure that we do not directly control the fan for NVidia
12640
12641 gpu_temp_retain = 0;
12642
12643 data.gpu_temp_retain = gpu_temp_retain;
12644 }
12645 #endif // HAVE_NVML || HAVE_NVAPI
12646 #endif
12647 }
12648
12649 /**
12650 * OpenCL devices: simply push all devices from all platforms into the same device array
12651 */
12652
12653 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12654
12655 data.devices_param = devices_param;
12656
12657 uint devices_cnt = 0;
12658
12659 uint devices_active = 0;
12660
12661 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12662 {
12663 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12664
12665 cl_platform_id platform = platforms[platform_id];
12666
12667 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12668
12669 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12670 {
12671 size_t param_value_size = 0;
12672
12673 const uint device_id = devices_cnt;
12674
12675 hc_device_param_t *device_param = &data.devices_param[device_id];
12676
12677 device_param->device = platform_devices[platform_devices_id];
12678
12679 device_param->device_id = device_id;
12680
12681 device_param->platform_devices_id = platform_devices_id;
12682
12683 // device_type
12684
12685 cl_device_type device_type;
12686
12687 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12688
12689 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12690
12691 device_param->device_type = device_type;
12692
12693 // vendor_id
12694
12695 cl_uint vendor_id = 0;
12696
12697 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12698
12699 device_param->vendor_id = vendor_id;
12700
12701 // device_name
12702
12703 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12704
12705 char *device_name = (char *) mymalloc (param_value_size);
12706
12707 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12708
12709 device_param->device_name = device_name;
12710
12711 // tuning db
12712
12713 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12714
12715 // device_version
12716
12717 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12718
12719 char *device_version = (char *) mymalloc (param_value_size);
12720
12721 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12722
12723 device_param->device_version = device_version;
12724
12725 // device_opencl_version
12726
12727 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12728
12729 char *device_opencl_version = (char *) mymalloc (param_value_size);
12730
12731 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12732
12733 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12734
12735 myfree (device_opencl_version);
12736
12737 if (strstr (device_version, "pocl"))
12738 {
12739 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12740 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12741
12742 cl_uint vendor_id = VENDOR_ID_GENERIC;
12743
12744 device_param->vendor_id = vendor_id;
12745 }
12746
12747 // vector_width
12748
12749 cl_uint vector_width;
12750
12751 if (opencl_vector_width_chgd == 0)
12752 {
12753 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12754 {
12755 if (opti_type & OPTI_TYPE_USES_BITS_64)
12756 {
12757 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12758 }
12759 else
12760 {
12761 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12762 }
12763 }
12764 else
12765 {
12766 vector_width = (cl_uint) tuningdb_entry->vector_width;
12767 }
12768 }
12769 else
12770 {
12771 vector_width = opencl_vector_width;
12772 }
12773
12774 if (vector_width > 16) vector_width = 16;
12775
12776 device_param->vector_width = vector_width;
12777
12778 // max_compute_units
12779
12780 cl_uint device_processors;
12781
12782 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12783
12784 device_param->device_processors = device_processors;
12785
12786 // max_mem_alloc_size
12787
12788 cl_ulong device_maxmem_alloc;
12789
12790 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12791
12792 device_param->device_maxmem_alloc = device_maxmem_alloc;
12793
12794 // max_mem_alloc_size
12795
12796 cl_ulong device_global_mem;
12797
12798 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12799
12800 device_param->device_global_mem = device_global_mem;
12801
12802 // max_clock_frequency
12803
12804 cl_uint device_maxclock_frequency;
12805
12806 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12807
12808 device_param->device_maxclock_frequency = device_maxclock_frequency;
12809
12810 // skipped
12811
12812 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12813 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12814
12815 device_param->skipped = (skipped1 || skipped2);
12816
12817 // driver_version
12818 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12819
12820 char *driver_version = (char *) mymalloc (param_value_size);
12821
12822 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12823
12824 device_param->driver_version = driver_version;
12825
12826 // device_name_chksum
12827
12828 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12829
12830 #if __x86_64__
12831 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);
12832 #else
12833 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);
12834 #endif
12835
12836 uint device_name_digest[4] = { 0 };
12837
12838 md5_64 ((uint *) device_name_chksum, device_name_digest);
12839
12840 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12841
12842 device_param->device_name_chksum = device_name_chksum;
12843
12844 // device_processor_cores
12845
12846 if (device_type & CL_DEVICE_TYPE_CPU)
12847 {
12848 cl_uint device_processor_cores = 1;
12849
12850 device_param->device_processor_cores = device_processor_cores;
12851 }
12852
12853 if (device_type & CL_DEVICE_TYPE_GPU)
12854 {
12855 if (vendor_id == VENDOR_ID_AMD)
12856 {
12857 cl_uint device_processor_cores = 0;
12858
12859 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12860
12861 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12862
12863 device_param->device_processor_cores = device_processor_cores;
12864 }
12865 else if (vendor_id == VENDOR_ID_NV)
12866 {
12867 cl_uint kernel_exec_timeout = 0;
12868
12869 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12870
12871 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12872
12873 device_param->kernel_exec_timeout = kernel_exec_timeout;
12874
12875 cl_uint device_processor_cores = 0;
12876
12877 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12878
12879 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12880
12881 device_param->device_processor_cores = device_processor_cores;
12882
12883 cl_uint sm_minor = 0;
12884 cl_uint sm_major = 0;
12885
12886 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12887 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12888
12889 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12890 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12891
12892 device_param->sm_minor = sm_minor;
12893 device_param->sm_major = sm_major;
12894 }
12895 else
12896 {
12897 cl_uint device_processor_cores = 1;
12898
12899 device_param->device_processor_cores = device_processor_cores;
12900 }
12901 }
12902
12903 // display results
12904
12905 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12906 {
12907 if (device_param->skipped == 0)
12908 {
12909 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12910 device_id + 1,
12911 device_name,
12912 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12913 (unsigned int) (device_global_mem / 1024 / 1024),
12914 (unsigned int) (device_maxclock_frequency),
12915 (unsigned int) device_processors);
12916 }
12917 else
12918 {
12919 log_info ("Device #%u: %s, skipped",
12920 device_id + 1,
12921 device_name);
12922 }
12923 }
12924
12925 // common driver check
12926
12927 if (device_param->skipped == 0)
12928 {
12929 if (strstr (device_version, "pocl"))
12930 {
12931 if (force == 0)
12932 {
12933 log_info ("");
12934 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12935 log_info ("You are STRONGLY encouraged not to use it");
12936 log_info ("You can use --force to override this but do not post error reports if you do so");
12937 log_info ("");
12938
12939 return (-1);
12940 }
12941 }
12942
12943 if (device_type & CL_DEVICE_TYPE_GPU)
12944 {
12945 if (vendor_id == VENDOR_ID_NV)
12946 {
12947 if (device_param->kernel_exec_timeout != 0)
12948 {
12949 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);
12950 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12951 }
12952 }
12953 else if (vendor_id == VENDOR_ID_AMD)
12954 {
12955 int catalyst_check = (force == 1) ? 0 : 1;
12956
12957 int catalyst_warn = 0;
12958
12959 int catalyst_broken = 0;
12960
12961 if (catalyst_check == 1)
12962 {
12963 catalyst_warn = 1;
12964
12965 // v14.9 and higher
12966 if (atoi (device_param->driver_version) >= 1573)
12967 {
12968 catalyst_warn = 0;
12969 }
12970
12971 catalyst_check = 0;
12972 }
12973
12974 if (catalyst_broken == 1)
12975 {
12976 log_info ("");
12977 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12978 log_info ("It will pass over cracked hashes and does not report them as cracked");
12979 log_info ("You are STRONGLY encouraged not to use it");
12980 log_info ("You can use --force to override this but do not post error reports if you do so");
12981 log_info ("");
12982
12983 return (-1);
12984 }
12985
12986 if (catalyst_warn == 1)
12987 {
12988 log_info ("");
12989 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12990 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12991 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12992 #ifdef _WIN
12993 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12994 #endif
12995 log_info ("You can use --force to override this but do not post error reports if you do so");
12996 log_info ("");
12997
12998 return (-1);
12999 }
13000 }
13001 }
13002
13003 /**
13004 * kernel accel and loops tuning db adjustment
13005 */
13006
13007 device_param->kernel_accel_min = 1;
13008 device_param->kernel_accel_max = 1024;
13009
13010 device_param->kernel_loops_min = 1;
13011 device_param->kernel_loops_max = 1024;
13012
13013 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13014
13015 if (tuningdb_entry)
13016 {
13017 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13018 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13019
13020 if (_kernel_accel)
13021 {
13022 device_param->kernel_accel_min = _kernel_accel;
13023 device_param->kernel_accel_max = _kernel_accel;
13024 }
13025
13026 if (_kernel_loops)
13027 {
13028 if (workload_profile == 1)
13029 {
13030 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13031 }
13032 else if (workload_profile == 2)
13033 {
13034 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13035 }
13036
13037 device_param->kernel_loops_min = _kernel_loops;
13038 device_param->kernel_loops_max = _kernel_loops;
13039 }
13040 }
13041
13042 // commandline parameters overwrite tuningdb entries
13043
13044 if (kernel_accel)
13045 {
13046 device_param->kernel_accel_min = kernel_accel;
13047 device_param->kernel_accel_max = kernel_accel;
13048 }
13049
13050 if (kernel_loops)
13051 {
13052 device_param->kernel_loops_min = kernel_loops;
13053 device_param->kernel_loops_max = kernel_loops;
13054 }
13055
13056 /**
13057 * activate device
13058 */
13059
13060 devices_active++;
13061 }
13062
13063 // next please
13064
13065 devices_cnt++;
13066 }
13067 }
13068
13069 if (keyspace == 0 && devices_active == 0)
13070 {
13071 log_error ("ERROR: No devices found/left");
13072
13073 return (-1);
13074 }
13075
13076 // additional check to see if the user has chosen a device that is not within the range of available devices (i.e. larger than devices_cnt)
13077
13078 if (devices_filter != (uint) -1)
13079 {
13080 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13081
13082 if (devices_filter > devices_cnt_mask)
13083 {
13084 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13085
13086 return (-1);
13087 }
13088 }
13089
13090 data.devices_cnt = devices_cnt;
13091
13092 data.devices_active = devices_active;
13093
13094 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13095 {
13096 log_info ("");
13097 }
13098
13099 /**
13100 * HM devices: init
13101 */
13102
13103 #ifdef HAVE_HWMON
13104 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13105 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13106 #endif
13107
13108 #ifdef HAVE_ADL
13109 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13110 #endif
13111
13112 if (gpu_temp_disable == 0)
13113 {
13114 #if defined(WIN) && defined(HAVE_NVAPI)
13115 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13116
13117 if (nvapi_init (nvapi) == 0)
13118 data.hm_nv = nvapi;
13119
13120 if (data.hm_nv)
13121 {
13122 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13123 {
13124 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13125
13126 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13127
13128 int tmp_out = 0;
13129
13130 for (int i = 0; i < tmp_in; i++)
13131 {
13132 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13133 }
13134
13135 for (int i = 0; i < tmp_out; i++)
13136 {
13137 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13138
13139 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13140
13141 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;
13142 }
13143 }
13144 }
13145 #endif // WIN && HAVE_NVAPI
13146
13147 #if defined(LINUX) && defined(HAVE_NVML)
13148 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13149
13150 if (nvml_init (nvml) == 0)
13151 data.hm_nv = nvml;
13152
13153 if (data.hm_nv)
13154 {
13155 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13156 {
13157 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13158
13159 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13160
13161 int tmp_out = 0;
13162
13163 for (int i = 0; i < tmp_in; i++)
13164 {
13165 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13166 }
13167
13168 for (int i = 0; i < tmp_out; i++)
13169 {
13170 unsigned int speed;
13171
13172 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;
13173 }
13174 }
13175 }
13176 #endif // LINUX && HAVE_NVML
13177
13178 data.hm_amd = NULL;
13179
13180 #ifdef HAVE_ADL
13181 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13182
13183 if (adl_init (adl) == 0)
13184 data.hm_amd = adl;
13185
13186 if (data.hm_amd)
13187 {
13188 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13189 {
13190 // total number of adapters
13191
13192 int hm_adapters_num;
13193
13194 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13195
13196 // adapter info
13197
13198 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13199
13200 if (lpAdapterInfo == NULL) return (-1);
13201
13202 // get a list (of ids of) valid/usable adapters
13203
13204 int num_adl_adapters = 0;
13205
13206 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13207
13208 if (num_adl_adapters > 0)
13209 {
13210 hc_thread_mutex_lock (mux_adl);
13211
13212 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13213
13214 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13215
13216 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13217 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13218
13219 hc_thread_mutex_unlock (mux_adl);
13220 }
13221
13222 myfree (valid_adl_device_list);
13223 myfree (lpAdapterInfo);
13224 }
13225 }
13226 #endif // HAVE_ADL
13227
13228 if (data.hm_amd == NULL && data.hm_nv == NULL)
13229 {
13230 gpu_temp_disable = 1;
13231 }
13232 }
13233
13234 /**
13235 * OpenCL devices: allocate buffer for device specific information
13236 */
13237
13238 #ifdef HAVE_HWMON
13239 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13240
13241 #ifdef HAVE_ADL
13242 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13243
13244 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13245 #endif // ADL
13246 #endif
13247
13248 /**
13249 * enable custom signal handler(s)
13250 */
13251
13252 if (benchmark == 0)
13253 {
13254 hc_signal (sigHandler_default);
13255 }
13256 else
13257 {
13258 hc_signal (sigHandler_benchmark);
13259 }
13260
13261 /**
13262 * User-defined GPU temp handling
13263 */
13264
13265 #ifdef HAVE_HWMON
13266 if (gpu_temp_disable == 1)
13267 {
13268 gpu_temp_abort = 0;
13269 gpu_temp_retain = 0;
13270 }
13271
13272 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13273 {
13274 if (gpu_temp_abort < gpu_temp_retain)
13275 {
13276 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13277
13278 return (-1);
13279 }
13280 }
13281
13282 data.gpu_temp_disable = gpu_temp_disable;
13283 data.gpu_temp_abort = gpu_temp_abort;
13284 data.gpu_temp_retain = gpu_temp_retain;
13285 #endif
13286
13287 /**
13288 * inform the user
13289 */
13290
13291 if (data.quiet == 0)
13292 {
13293 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13294
13295 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);
13296
13297 if (attack_mode == ATTACK_MODE_STRAIGHT)
13298 {
13299 log_info ("Rules: %u", kernel_rules_cnt);
13300 }
13301
13302 if (opti_type)
13303 {
13304 log_info ("Applicable Optimizers:");
13305
13306 for (uint i = 0; i < 32; i++)
13307 {
13308 const uint opti_bit = 1u << i;
13309
13310 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13311 }
13312 }
13313
13314 /**
13315 * Watchdog and Temperature balance
13316 */
13317
13318 #ifdef HAVE_HWMON
13319 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13320 {
13321 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13322 }
13323
13324 if (gpu_temp_abort == 0)
13325 {
13326 log_info ("Watchdog: Temperature abort trigger disabled");
13327 }
13328 else
13329 {
13330 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13331 }
13332
13333 if (gpu_temp_retain == 0)
13334 {
13335 log_info ("Watchdog: Temperature retain trigger disabled");
13336 }
13337 else
13338 {
13339 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13340 }
13341 #endif
13342 }
13343
13344 if (data.quiet == 0) log_info ("");
13345
13346 /**
13347 * HM devices: copy
13348 */
13349
13350 if (gpu_temp_disable == 0)
13351 {
13352 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13353 {
13354 hc_device_param_t *device_param = &data.devices_param[device_id];
13355
13356 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13357
13358 if (device_param->skipped) continue;
13359
13360 const uint platform_devices_id = device_param->platform_devices_id;
13361
13362 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13363 if (device_param->vendor_id == VENDOR_ID_NV)
13364 {
13365 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13366 }
13367 #endif
13368
13369 #ifdef HAVE_ADL
13370 if (device_param->vendor_id == VENDOR_ID_AMD)
13371 {
13372 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13373 }
13374 #endif
13375 }
13376 }
13377
13378 /*
13379 * Temporary fix:
13380 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13381 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13382 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13383 * Driver / ADL bug?
13384 */
13385
13386 #ifdef HAVE_ADL
13387 if (powertune_enable == 1)
13388 {
13389 hc_thread_mutex_lock (mux_adl);
13390
13391 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13392 {
13393 hc_device_param_t *device_param = &data.devices_param[device_id];
13394
13395 if (device_param->skipped) continue;
13396
13397 if (data.hm_device[device_id].od_version == 6)
13398 {
13399 // set powertune value only
13400
13401 int powertune_supported = 0;
13402
13403 int ADL_rc = 0;
13404
13405 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13406 {
13407 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13408
13409 return (-1);
13410 }
13411
13412 if (powertune_supported != 0)
13413 {
13414 // powertune set
13415 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13416
13417 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13418 {
13419 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13420
13421 return (-1);
13422 }
13423
13424 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13425 {
13426 log_error ("ERROR: Failed to set new ADL PowerControl values");
13427
13428 return (-1);
13429 }
13430 }
13431 }
13432 }
13433
13434 hc_thread_mutex_unlock (mux_adl);
13435 }
13436 #endif // HAVE_ADK
13437 #endif // HAVE_HWMON
13438
13439 #ifdef DEBUG
13440 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13441 #endif
13442
13443 uint kernel_power_all = 0;
13444
13445 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13446 {
13447 /**
13448 * host buffer
13449 */
13450
13451 hc_device_param_t *device_param = &data.devices_param[device_id];
13452
13453 if (device_param->skipped) continue;
13454
13455 /**
13456 * device properties
13457 */
13458
13459 const char *device_name_chksum = device_param->device_name_chksum;
13460 const u32 device_processors = device_param->device_processors;
13461 const u32 device_processor_cores = device_param->device_processor_cores;
13462
13463 /**
13464 * create context for each device
13465 */
13466
13467 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13468
13469 /**
13470 * create command-queue
13471 */
13472
13473 // not supported with NV
13474 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13475
13476 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13477
13478 /**
13479 * create input buffers on device : calculate size of fixed memory buffers
13480 */
13481
13482 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13483 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13484
13485 device_param->size_root_css = size_root_css;
13486 device_param->size_markov_css = size_markov_css;
13487
13488 uint size_results = KERNEL_THREADS * sizeof (uint);
13489
13490 device_param->size_results = size_results;
13491
13492 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13493 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13494
13495 uint size_plains = digests_cnt * sizeof (plain_t);
13496 uint size_salts = salts_cnt * sizeof (salt_t);
13497 uint size_esalts = salts_cnt * esalt_size;
13498
13499 device_param->size_plains = size_plains;
13500 device_param->size_digests = size_digests;
13501 device_param->size_shown = size_shown;
13502 device_param->size_salts = size_salts;
13503
13504 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13505 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13506 uint size_tm = 32 * sizeof (bs_word_t);
13507
13508 // scryptV stuff
13509
13510 u64 size_scryptV = 1;
13511
13512 if ((hash_mode == 8900) || (hash_mode == 9300))
13513 {
13514 uint tmto_start = 0;
13515 uint tmto_stop = 10;
13516
13517 if (scrypt_tmto)
13518 {
13519 tmto_start = scrypt_tmto;
13520 }
13521 else
13522 {
13523 // in case the user did not specify the tmto manually
13524 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13525 // but set the lower end only in case the user has a device with too less memory
13526
13527 if (hash_mode == 8900)
13528 {
13529 if (device_param->vendor_id == VENDOR_ID_AMD)
13530 {
13531 tmto_start = 1;
13532 }
13533 else if (device_param->vendor_id == VENDOR_ID_NV)
13534 {
13535 tmto_start = 3;
13536 }
13537 }
13538 else if (hash_mode == 9300)
13539 {
13540 if (device_param->vendor_id == VENDOR_ID_AMD)
13541 {
13542 tmto_start = 3;
13543 }
13544 else if (device_param->vendor_id == VENDOR_ID_NV)
13545 {
13546 tmto_start = 5;
13547 }
13548 }
13549 }
13550
13551 if (quiet == 0) log_info ("");
13552
13553 uint shader_per_mp = 1;
13554
13555 if (device_param->vendor_id == VENDOR_ID_AMD)
13556 {
13557 shader_per_mp = 8;
13558 }
13559 else if (device_param->vendor_id == VENDOR_ID_NV)
13560 {
13561 shader_per_mp = 32;
13562 }
13563
13564 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13565 {
13566 // TODO: in theory the following calculation needs to be done per salt, not global
13567 // we assume all hashes have the same scrypt settings
13568
13569 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13570
13571 size_scryptV /= 1 << tmto;
13572
13573 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13574
13575 if (size_scryptV > device_param->device_maxmem_alloc)
13576 {
13577 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13578
13579 continue;
13580 }
13581
13582 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13583 {
13584 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13585 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13586 }
13587
13588 break;
13589 }
13590
13591 if (data.salts_buf[0].scrypt_phy == 0)
13592 {
13593 log_error ("ERROR: can't allocate enough device memory");
13594
13595 return -1;
13596 }
13597
13598 if (quiet == 0) log_info ("");
13599 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13600 }
13601
13602 /**
13603 * create input buffers on device : calculate size of dynamic size memory buffers
13604 */
13605
13606 uint kernel_threads = KERNEL_THREADS;
13607
13608 // some algorithms need a fixed kernel-threads count (mostly because of shared memory usage)
13609
13610 if (hash_mode == 3200) kernel_threads = 8;
13611 if (hash_mode == 9000) kernel_threads = 8;
13612
13613 /**
13614 * some algorithms need a fixed kernel-loops count
13615 */
13616
13617 if (hash_mode == 1500)
13618 {
13619 const u32 kernel_loops_fixed = 1024;
13620
13621 device_param->kernel_loops_min = kernel_loops_fixed;
13622 device_param->kernel_loops_max = kernel_loops_fixed;
13623 }
13624
13625 if (hash_mode == 3000)
13626 {
13627 const u32 kernel_loops_fixed = 1024;
13628
13629 device_param->kernel_loops_min = kernel_loops_fixed;
13630 device_param->kernel_loops_max = kernel_loops_fixed;
13631 }
13632
13633 if (hash_mode == 8900)
13634 {
13635 const u32 kernel_loops_fixed = 1;
13636
13637 device_param->kernel_loops_min = kernel_loops_fixed;
13638 device_param->kernel_loops_max = kernel_loops_fixed;
13639 }
13640
13641 if (hash_mode == 9300)
13642 {
13643 const u32 kernel_loops_fixed = 1;
13644
13645 device_param->kernel_loops_min = kernel_loops_fixed;
13646 device_param->kernel_loops_max = kernel_loops_fixed;
13647 }
13648
13649 if (hash_mode == 12500)
13650 {
13651 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13652
13653 device_param->kernel_loops_min = kernel_loops_fixed;
13654 device_param->kernel_loops_max = kernel_loops_fixed;
13655 }
13656
13657 /**
13658 * some algorithms have a maximum kernel-loops count
13659 */
13660
13661 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13662 {
13663 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13664 {
13665 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13666 }
13667 }
13668
13669 /**
13670 * some algorithms need a special kernel-accel
13671 */
13672
13673 if (hash_mode == 8900)
13674 {
13675 device_param->kernel_accel_min = 1;
13676 device_param->kernel_accel_max = 64;
13677 }
13678
13679 if (hash_mode == 9300)
13680 {
13681 device_param->kernel_accel_min = 1;
13682 device_param->kernel_accel_max = 64;
13683 }
13684
13685 u32 kernel_accel_min = device_param->kernel_accel_min;
13686 u32 kernel_accel_max = device_param->kernel_accel_max;
13687
13688 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13689
13690 uint size_pws = 4;
13691 uint size_tmps = 4;
13692 uint size_hooks = 4;
13693
13694 while (kernel_accel_max >= kernel_accel_min)
13695 {
13696 uint kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13697
13698 // size_pws
13699
13700 size_pws = kernel_power_max * sizeof (pw_t);
13701
13702 // size_tmps
13703
13704 switch (hash_mode)
13705 {
13706 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13707 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13708 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13709 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13710 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13711 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13712 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13713 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13714 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13715 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13716 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13717 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13718 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13719 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13720 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13721 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13722 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13723 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13724 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13725 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13726 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13727 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13728 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13729 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13730 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13731 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13732 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13733 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13734 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13735 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13736 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13737 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13738 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13739 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13740 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13741 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13742 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13743 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13744 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13745 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13746 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13747 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13748 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13749 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13750 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13751 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13752 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13753 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13754 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13755 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13756 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13757 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13758 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13759 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13760 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13761 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13762 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13763 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13764 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13765 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13766 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13767 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
13768 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
13769 };
13770
13771 // size_hooks
13772
13773 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13774 {
13775 // none yet
13776 }
13777
13778 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13779 // if not, decrease amplifier and try again
13780
13781 int skip = 0;
13782
13783 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13784 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13785 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13786
13787 if (( bitmap_size
13788 + bitmap_size
13789 + bitmap_size
13790 + bitmap_size
13791 + bitmap_size
13792 + bitmap_size
13793 + bitmap_size
13794 + bitmap_size
13795 + size_bfs
13796 + size_combs
13797 + size_digests
13798 + size_esalts
13799 + size_hooks
13800 + size_markov_css
13801 + size_plains
13802 + size_pws
13803 + size_results
13804 + size_root_css
13805 + size_rules
13806 + size_rules_c
13807 + size_salts
13808 + size_scryptV
13809 + size_shown
13810 + size_tm
13811 + size_tmps) > device_param->device_global_mem) skip = 1;
13812
13813 if (skip == 1)
13814 {
13815 kernel_accel_max--;
13816
13817 continue;
13818 }
13819
13820 break;
13821 }
13822
13823 /*
13824 if (kernel_accel_max == 0)
13825 {
13826 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13827
13828 return -1;
13829 }
13830 */
13831
13832 device_param->kernel_accel_min = kernel_accel_min;
13833 device_param->kernel_accel_max = kernel_accel_max;
13834
13835 /*
13836 if (kernel_accel_max < kernel_accel)
13837 {
13838 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13839
13840 device_param->kernel_accel = kernel_accel_max;
13841 }
13842 */
13843
13844 device_param->size_bfs = size_bfs;
13845 device_param->size_combs = size_combs;
13846 device_param->size_rules = size_rules;
13847 device_param->size_rules_c = size_rules_c;
13848 device_param->size_pws = size_pws;
13849 device_param->size_tmps = size_tmps;
13850 device_param->size_hooks = size_hooks;
13851
13852 // do not confuse kernel_accel_max with kernel_accel here
13853
13854 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13855
13856 device_param->kernel_threads = kernel_threads;
13857 device_param->kernel_power_user = kernel_power;
13858
13859 kernel_power_all += kernel_power;
13860
13861 /**
13862 * default building options
13863 */
13864
13865 char build_opts[1024] = { 0 };
13866
13867 // we don't have sm_* on vendors not NV but it doesn't matter
13868
13869 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);
13870
13871 /**
13872 * main kernel
13873 */
13874
13875 {
13876 /**
13877 * kernel source filename
13878 */
13879
13880 char source_file[256] = { 0 };
13881
13882 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13883
13884 struct stat sst;
13885
13886 if (stat (source_file, &sst) == -1)
13887 {
13888 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13889
13890 return -1;
13891 }
13892
13893 /**
13894 * kernel cached filename
13895 */
13896
13897 char cached_file[256] = { 0 };
13898
13899 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13900
13901 int cached = 1;
13902
13903 struct stat cst;
13904
13905 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13906 {
13907 cached = 0;
13908 }
13909
13910 /**
13911 * kernel compile or load
13912 */
13913
13914 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13915
13916 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13917
13918 if (force_jit_compilation == -1)
13919 {
13920 if (cached == 0)
13921 {
13922 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13923
13924 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13925
13926 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13927
13928 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13929
13930 #ifdef DEBUG
13931 size_t build_log_size = 0;
13932
13933 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
13934
13935 if (build_log_size > 1)
13936 {
13937 char *build_log = (char *) malloc (build_log_size + 1);
13938
13939 memset (build_log, 0, build_log_size + 1);
13940
13941 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
13942
13943 puts (build_log);
13944
13945 free (build_log);
13946 }
13947 #endif
13948
13949 if (rc != 0)
13950 {
13951 device_param->skipped = true;
13952 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13953 continue;
13954 }
13955
13956 size_t binary_size;
13957
13958 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13959
13960 u8 *binary = (u8 *) mymalloc (binary_size);
13961
13962 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13963
13964 writeProgramBin (cached_file, binary, binary_size);
13965
13966 local_free (binary);
13967 }
13968 else
13969 {
13970 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13971
13972 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13973
13974 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13975
13976 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
13977 }
13978 }
13979 else
13980 {
13981 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13982
13983 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13984
13985 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13986
13987 char build_opts_update[1024] = { 0 };
13988
13989 if (force_jit_compilation == 1500)
13990 {
13991 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13992 }
13993 else if (force_jit_compilation == 8900)
13994 {
13995 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);
13996 }
13997 else
13998 {
13999 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14000 }
14001
14002 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14003
14004 #ifdef DEBUG
14005 size_t build_log_size = 0;
14006
14007 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14008
14009 if (build_log_size > 1)
14010 {
14011 char *build_log = (char *) malloc (build_log_size + 1);
14012
14013 memset (build_log, 0, build_log_size + 1);
14014
14015 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14016
14017 puts (build_log);
14018
14019 free (build_log);
14020 }
14021 #endif
14022
14023 if (rc != 0)
14024 {
14025 device_param->skipped = true;
14026
14027 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14028 }
14029 }
14030
14031 local_free (kernel_lengths);
14032 local_free (kernel_sources[0]);
14033 local_free (kernel_sources);
14034 }
14035
14036 /**
14037 * word generator kernel
14038 */
14039
14040 if (attack_mode != ATTACK_MODE_STRAIGHT)
14041 {
14042 /**
14043 * kernel mp source filename
14044 */
14045
14046 char source_file[256] = { 0 };
14047
14048 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14049
14050 struct stat sst;
14051
14052 if (stat (source_file, &sst) == -1)
14053 {
14054 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14055
14056 return -1;
14057 }
14058
14059 /**
14060 * kernel mp cached filename
14061 */
14062
14063 char cached_file[256] = { 0 };
14064
14065 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14066
14067 int cached = 1;
14068
14069 struct stat cst;
14070
14071 if (stat (cached_file, &cst) == -1)
14072 {
14073 cached = 0;
14074 }
14075
14076 /**
14077 * kernel compile or load
14078 */
14079
14080 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14081
14082 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14083
14084 if (cached == 0)
14085 {
14086 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14087
14088 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14089
14090 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14091
14092 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14093
14094 if (rc != 0)
14095 {
14096 device_param->skipped = true;
14097 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14098 continue;
14099 }
14100
14101 size_t binary_size;
14102
14103 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14104
14105 u8 *binary = (u8 *) mymalloc (binary_size);
14106
14107 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14108
14109 writeProgramBin (cached_file, binary, binary_size);
14110
14111 local_free (binary);
14112 }
14113 else
14114 {
14115 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14116
14117 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14118
14119 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14120
14121 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14122 }
14123
14124 local_free (kernel_lengths);
14125 local_free (kernel_sources[0]);
14126 local_free (kernel_sources);
14127 }
14128
14129 /**
14130 * amplifier kernel
14131 */
14132
14133 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14134 {
14135
14136 }
14137 else
14138 {
14139 /**
14140 * kernel amp source filename
14141 */
14142
14143 char source_file[256] = { 0 };
14144
14145 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14146
14147 struct stat sst;
14148
14149 if (stat (source_file, &sst) == -1)
14150 {
14151 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14152
14153 return -1;
14154 }
14155
14156 /**
14157 * kernel amp cached filename
14158 */
14159
14160 char cached_file[256] = { 0 };
14161
14162 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14163
14164 int cached = 1;
14165
14166 struct stat cst;
14167
14168 if (stat (cached_file, &cst) == -1)
14169 {
14170 cached = 0;
14171 }
14172
14173 /**
14174 * kernel compile or load
14175 */
14176
14177 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14178
14179 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14180
14181 if (cached == 0)
14182 {
14183 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14184
14185 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14186
14187 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14188
14189 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14190
14191 if (rc != 0)
14192 {
14193 device_param->skipped = true;
14194 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14195 continue;
14196 }
14197
14198 size_t binary_size;
14199
14200 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14201
14202 u8 *binary = (u8 *) mymalloc (binary_size);
14203
14204 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14205
14206 writeProgramBin (cached_file, binary, binary_size);
14207
14208 local_free (binary);
14209 }
14210 else
14211 {
14212 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14213
14214 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14215
14216 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14217
14218 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14219 }
14220
14221 local_free (kernel_lengths);
14222 local_free (kernel_sources[0]);
14223 local_free (kernel_sources);
14224 }
14225
14226 // some algorithm collide too fast, make that impossible
14227
14228 if (benchmark == 1)
14229 {
14230 ((uint *) digests_buf)[0] = -1;
14231 ((uint *) digests_buf)[1] = -1;
14232 ((uint *) digests_buf)[2] = -1;
14233 ((uint *) digests_buf)[3] = -1;
14234 }
14235
14236 /**
14237 * global buffers
14238 */
14239
14240 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14241 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14242 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14243 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14244 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14245 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14246 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14247 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14248 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14249 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14250 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14251 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14252 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14253 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14254 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14255 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14256 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14257 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14258
14259 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);
14260 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);
14261 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);
14262 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);
14263 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);
14264 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);
14265 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);
14266 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);
14267 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14268 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14269 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14270
14271 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14272 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14273 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14274 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14275 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14276 run_kernel_bzero (device_param, device_param->d_result, size_results);
14277
14278 /**
14279 * special buffers
14280 */
14281
14282 if (attack_kern == ATTACK_KERN_STRAIGHT)
14283 {
14284 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14285 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14286
14287 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14288
14289 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14290 }
14291 else if (attack_kern == ATTACK_KERN_COMBI)
14292 {
14293 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14294 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14295 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14296 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14297
14298 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14299 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14300 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14301 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14302 }
14303 else if (attack_kern == ATTACK_KERN_BF)
14304 {
14305 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14306 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14307 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14308 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14309 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14310
14311 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14312 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14313 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14314 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14315 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14316 }
14317
14318 if (size_esalts)
14319 {
14320 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14321
14322 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14323 }
14324
14325 /**
14326 * main host data
14327 */
14328
14329 uint *result = (uint *) mymalloc (size_results);
14330
14331 device_param->result = result;
14332
14333 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14334
14335 device_param->pws_buf = pws_buf;
14336
14337 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14338
14339 device_param->combs_buf = combs_buf;
14340
14341 void *hooks_buf = mymalloc (size_hooks);
14342
14343 device_param->hooks_buf = hooks_buf;
14344
14345 /**
14346 * kernel args
14347 */
14348
14349 device_param->kernel_params_buf32[21] = bitmap_mask;
14350 device_param->kernel_params_buf32[22] = bitmap_shift1;
14351 device_param->kernel_params_buf32[23] = bitmap_shift2;
14352 device_param->kernel_params_buf32[24] = 0; // salt_pos
14353 device_param->kernel_params_buf32[25] = 0; // loop_pos
14354 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14355 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14356 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14357 device_param->kernel_params_buf32[29] = 0; // digests_offset
14358 device_param->kernel_params_buf32[30] = 0; // combs_mode
14359 device_param->kernel_params_buf32[31] = 0; // gid_max
14360
14361 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14362 ? &device_param->d_pws_buf
14363 : &device_param->d_pws_amp_buf;
14364 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14365 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14366 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14367 device_param->kernel_params[ 4] = &device_param->d_tmps;
14368 device_param->kernel_params[ 5] = &device_param->d_hooks;
14369 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14370 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14371 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14372 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14373 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14374 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14375 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14376 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14377 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14378 device_param->kernel_params[15] = &device_param->d_digests_buf;
14379 device_param->kernel_params[16] = &device_param->d_digests_shown;
14380 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14381 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14382 device_param->kernel_params[19] = &device_param->d_result;
14383 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14384 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14385 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14386 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14387 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14388 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14389 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14390 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14391 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14392 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14393 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14394 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14395
14396 device_param->kernel_params_mp_buf64[3] = 0;
14397 device_param->kernel_params_mp_buf32[4] = 0;
14398 device_param->kernel_params_mp_buf32[5] = 0;
14399 device_param->kernel_params_mp_buf32[6] = 0;
14400 device_param->kernel_params_mp_buf32[7] = 0;
14401 device_param->kernel_params_mp_buf32[8] = 0;
14402
14403 device_param->kernel_params_mp[0] = NULL;
14404 device_param->kernel_params_mp[1] = NULL;
14405 device_param->kernel_params_mp[2] = NULL;
14406 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14407 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14408 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14409 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14410 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14411 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14412
14413 device_param->kernel_params_mp_l_buf64[3] = 0;
14414 device_param->kernel_params_mp_l_buf32[4] = 0;
14415 device_param->kernel_params_mp_l_buf32[5] = 0;
14416 device_param->kernel_params_mp_l_buf32[6] = 0;
14417 device_param->kernel_params_mp_l_buf32[7] = 0;
14418 device_param->kernel_params_mp_l_buf32[8] = 0;
14419 device_param->kernel_params_mp_l_buf32[9] = 0;
14420
14421 device_param->kernel_params_mp_l[0] = NULL;
14422 device_param->kernel_params_mp_l[1] = NULL;
14423 device_param->kernel_params_mp_l[2] = NULL;
14424 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14425 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14426 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14427 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14428 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14429 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14430 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14431
14432 device_param->kernel_params_mp_r_buf64[3] = 0;
14433 device_param->kernel_params_mp_r_buf32[4] = 0;
14434 device_param->kernel_params_mp_r_buf32[5] = 0;
14435 device_param->kernel_params_mp_r_buf32[6] = 0;
14436 device_param->kernel_params_mp_r_buf32[7] = 0;
14437 device_param->kernel_params_mp_r_buf32[8] = 0;
14438
14439 device_param->kernel_params_mp_r[0] = NULL;
14440 device_param->kernel_params_mp_r[1] = NULL;
14441 device_param->kernel_params_mp_r[2] = NULL;
14442 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14443 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14444 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14445 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14446 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14447 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14448
14449 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14450 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14451
14452 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14453 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14454 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14455 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14456 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14457 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14458 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14459
14460 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14461 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14462
14463 /**
14464 * kernel name
14465 */
14466
14467 char kernel_name[64] = { 0 };
14468
14469 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14470 {
14471 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14472 {
14473 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14474
14475 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14476
14477 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14478
14479 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14480
14481 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14482
14483 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14484 }
14485 else
14486 {
14487 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14488
14489 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14490
14491 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14492
14493 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14494
14495 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14496
14497 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14498 }
14499
14500 if (data.attack_mode == ATTACK_MODE_BF)
14501 {
14502 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14503 {
14504 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14505
14506 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14507 }
14508 }
14509 }
14510 else
14511 {
14512 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14513
14514 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14515
14516 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14517
14518 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14519
14520 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14521
14522 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14523
14524 if (opts_type & OPTS_TYPE_HOOK12)
14525 {
14526 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14527
14528 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14529 }
14530
14531 if (opts_type & OPTS_TYPE_HOOK23)
14532 {
14533 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14534
14535 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14536 }
14537 }
14538
14539 for (uint i = 0; i <= 20; i++)
14540 {
14541 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14542 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14543 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14544
14545 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14546 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14547 }
14548
14549 for (uint i = 21; i <= 31; i++)
14550 {
14551 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14552 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14553 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14554
14555 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14556 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14557 }
14558
14559 if (attack_mode == ATTACK_MODE_BF)
14560 {
14561 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14562 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14563
14564 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14565 {
14566 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14567 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14568 }
14569 }
14570 else if (attack_mode == ATTACK_MODE_HYBRID1)
14571 {
14572 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14573 }
14574 else if (attack_mode == ATTACK_MODE_HYBRID2)
14575 {
14576 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14577 }
14578
14579 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14580 {
14581 // nothing to do
14582 }
14583 else
14584 {
14585 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14586 }
14587
14588 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14589 {
14590 // nothing to do
14591 }
14592 else
14593 {
14594 for (uint i = 0; i < 5; i++)
14595 {
14596 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14597 }
14598
14599 for (uint i = 5; i < 7; i++)
14600 {
14601 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14602 }
14603 }
14604
14605 /**
14606 * Store initial fanspeed if gpu_temp_retain is enabled
14607 */
14608
14609 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14610 int gpu_temp_retain_set = 0;
14611
14612 if (gpu_temp_disable == 0)
14613 {
14614 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14615 {
14616 hc_thread_mutex_lock (mux_adl);
14617
14618 if (data.hm_device[device_id].fan_supported == 1)
14619 {
14620 if (gpu_temp_retain_chgd == 0)
14621 {
14622 uint cur_temp = 0;
14623 uint default_temp = 0;
14624
14625 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);
14626
14627 if (ADL_rc == ADL_OK)
14628 {
14629 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14630
14631 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14632
14633 // special case with multi gpu setups: always use minimum retain
14634
14635 if (gpu_temp_retain_set == 0)
14636 {
14637 gpu_temp_retain = gpu_temp_retain_target;
14638 gpu_temp_retain_set = 1;
14639 }
14640 else
14641 {
14642 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14643 }
14644
14645 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14646 }
14647 }
14648
14649 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14650
14651 temp_retain_fanspeed_value[device_id] = fan_speed;
14652
14653 if (fan_speed == -1)
14654 {
14655 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14656
14657 temp_retain_fanspeed_value[device_id] = 0;
14658 }
14659 }
14660
14661 hc_thread_mutex_unlock (mux_adl);
14662 }
14663 }
14664
14665 /**
14666 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14667 */
14668
14669 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14670 {
14671 hc_thread_mutex_lock (mux_adl);
14672
14673 if (data.hm_device[device_id].od_version == 6)
14674 {
14675 int ADL_rc;
14676
14677 // check powertune capabilities first, if not available then skip device
14678
14679 int powertune_supported = 0;
14680
14681 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14682 {
14683 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14684
14685 return (-1);
14686 }
14687
14688 if (powertune_supported != 0)
14689 {
14690 // powercontrol settings
14691
14692 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14693
14694 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14695 {
14696 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14697 }
14698
14699 if (ADL_rc != ADL_OK)
14700 {
14701 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14702
14703 return (-1);
14704 }
14705
14706 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14707 {
14708 log_error ("ERROR: Failed to set new ADL PowerControl values");
14709
14710 return (-1);
14711 }
14712
14713 // clocks
14714
14715 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14716
14717 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14718
14719 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)
14720 {
14721 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14722
14723 return (-1);
14724 }
14725
14726 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14727
14728 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14729
14730 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14731 {
14732 log_error ("ERROR: Failed to get ADL device capabilities");
14733
14734 return (-1);
14735 }
14736
14737 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14738 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14739
14740 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14741 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14742
14743 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14744 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14745
14746 // warning if profile has too low max values
14747
14748 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14749 {
14750 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14751 }
14752
14753 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14754 {
14755 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14756 }
14757
14758 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14759
14760 performance_state->iNumberOfPerformanceLevels = 2;
14761
14762 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14763 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14764 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14765 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14766
14767 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)
14768 {
14769 log_info ("ERROR: Failed to set ADL performance state");
14770
14771 return (-1);
14772 }
14773
14774 local_free (performance_state);
14775 }
14776 }
14777
14778 hc_thread_mutex_unlock (mux_adl);
14779 }
14780 #endif // HAVE_HWMON && HAVE_ADL
14781 }
14782
14783 data.kernel_power_all = kernel_power_all;
14784
14785 if (data.quiet == 0) log_info ("");
14786
14787 /**
14788 * Inform user which algorithm is checked and at which workload setting
14789 */
14790
14791 if (benchmark == 1)
14792 {
14793 quiet = 0;
14794
14795 data.quiet = quiet;
14796
14797 char *hash_type = strhashtype (data.hash_mode); // not a bug
14798
14799 log_info ("Hashtype: %s", hash_type);
14800 log_info ("");
14801 }
14802
14803 /**
14804 * keep track of the progress
14805 */
14806
14807 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14808 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14809 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14810
14811 /**
14812 * open filehandles
14813 */
14814
14815 #if _WIN
14816 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14817 {
14818 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14819
14820 return (-1);
14821 }
14822
14823 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14824 {
14825 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14826
14827 return (-1);
14828 }
14829
14830 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14831 {
14832 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14833
14834 return (-1);
14835 }
14836 #endif
14837
14838 /**
14839 * dictionary pad
14840 */
14841
14842 segment_size *= (1024 * 1024);
14843
14844 data.segment_size = segment_size;
14845
14846 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14847
14848 wl_data->buf = (char *) mymalloc (segment_size);
14849 wl_data->avail = segment_size;
14850 wl_data->incr = segment_size;
14851 wl_data->cnt = 0;
14852 wl_data->pos = 0;
14853
14854 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14855
14856 data.wordlist_mode = wordlist_mode;
14857
14858 cs_t *css_buf = NULL;
14859 uint css_cnt = 0;
14860 uint dictcnt = 0;
14861 uint maskcnt = 1;
14862 char **masks = NULL;
14863 char **dictfiles = NULL;
14864
14865 uint mask_from_file = 0;
14866
14867 if (attack_mode == ATTACK_MODE_STRAIGHT)
14868 {
14869 if (wordlist_mode == WL_MODE_FILE)
14870 {
14871 int wls_left = myargc - (optind + 1);
14872
14873 for (int i = 0; i < wls_left; i++)
14874 {
14875 char *l0_filename = myargv[optind + 1 + i];
14876
14877 struct stat l0_stat;
14878
14879 if (stat (l0_filename, &l0_stat) == -1)
14880 {
14881 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14882
14883 return (-1);
14884 }
14885
14886 uint is_dir = S_ISDIR (l0_stat.st_mode);
14887
14888 if (is_dir == 0)
14889 {
14890 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14891
14892 dictcnt++;
14893
14894 dictfiles[dictcnt - 1] = l0_filename;
14895 }
14896 else
14897 {
14898 // do not allow --keyspace w/ a directory
14899
14900 if (keyspace == 1)
14901 {
14902 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14903
14904 return (-1);
14905 }
14906
14907 char **dictionary_files = NULL;
14908
14909 dictionary_files = scan_directory (l0_filename);
14910
14911 if (dictionary_files != NULL)
14912 {
14913 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14914
14915 for (int d = 0; dictionary_files[d] != NULL; d++)
14916 {
14917 char *l1_filename = dictionary_files[d];
14918
14919 struct stat l1_stat;
14920
14921 if (stat (l1_filename, &l1_stat) == -1)
14922 {
14923 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14924
14925 return (-1);
14926 }
14927
14928 if (S_ISREG (l1_stat.st_mode))
14929 {
14930 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14931
14932 dictcnt++;
14933
14934 dictfiles[dictcnt - 1] = strdup (l1_filename);
14935 }
14936 }
14937 }
14938
14939 local_free (dictionary_files);
14940 }
14941 }
14942
14943 if (dictcnt < 1)
14944 {
14945 log_error ("ERROR: No usable dictionary file found.");
14946
14947 return (-1);
14948 }
14949 }
14950 else if (wordlist_mode == WL_MODE_STDIN)
14951 {
14952 dictcnt = 1;
14953 }
14954 }
14955 else if (attack_mode == ATTACK_MODE_COMBI)
14956 {
14957 // display
14958
14959 char *dictfile1 = myargv[optind + 1 + 0];
14960 char *dictfile2 = myargv[optind + 1 + 1];
14961
14962 // find the bigger dictionary and use as base
14963
14964 FILE *fp1 = NULL;
14965 FILE *fp2 = NULL;
14966
14967 struct stat tmp_stat;
14968
14969 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14970 {
14971 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14972
14973 return (-1);
14974 }
14975
14976 if (stat (dictfile1, &tmp_stat) == -1)
14977 {
14978 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14979
14980 fclose (fp1);
14981
14982 return (-1);
14983 }
14984
14985 if (S_ISDIR (tmp_stat.st_mode))
14986 {
14987 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14988
14989 fclose (fp1);
14990
14991 return (-1);
14992 }
14993
14994 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14995 {
14996 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14997
14998 fclose (fp1);
14999
15000 return (-1);
15001 }
15002
15003 if (stat (dictfile2, &tmp_stat) == -1)
15004 {
15005 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15006
15007 fclose (fp1);
15008 fclose (fp2);
15009
15010 return (-1);
15011 }
15012
15013 if (S_ISDIR (tmp_stat.st_mode))
15014 {
15015 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15016
15017 fclose (fp1);
15018 fclose (fp2);
15019
15020 return (-1);
15021 }
15022
15023 data.combs_cnt = 1;
15024
15025 data.quiet = 1;
15026
15027 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15028
15029 data.quiet = quiet;
15030
15031 if (words1_cnt == 0)
15032 {
15033 log_error ("ERROR: %s: empty file", dictfile1);
15034
15035 fclose (fp1);
15036 fclose (fp2);
15037
15038 return (-1);
15039 }
15040
15041 data.combs_cnt = 1;
15042
15043 data.quiet = 1;
15044
15045 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15046
15047 data.quiet = quiet;
15048
15049 if (words2_cnt == 0)
15050 {
15051 log_error ("ERROR: %s: empty file", dictfile2);
15052
15053 fclose (fp1);
15054 fclose (fp2);
15055
15056 return (-1);
15057 }
15058
15059 fclose (fp1);
15060 fclose (fp2);
15061
15062 data.dictfile = dictfile1;
15063 data.dictfile2 = dictfile2;
15064
15065 if (words1_cnt >= words2_cnt)
15066 {
15067 data.combs_cnt = words2_cnt;
15068 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15069
15070 dictfiles = &data.dictfile;
15071
15072 dictcnt = 1;
15073 }
15074 else
15075 {
15076 data.combs_cnt = words1_cnt;
15077 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15078
15079 dictfiles = &data.dictfile2;
15080
15081 dictcnt = 1;
15082
15083 // we also have to switch wordlist related rules!
15084
15085 char *tmpc = data.rule_buf_l;
15086
15087 data.rule_buf_l = data.rule_buf_r;
15088 data.rule_buf_r = tmpc;
15089
15090 int tmpi = data.rule_len_l;
15091
15092 data.rule_len_l = data.rule_len_r;
15093 data.rule_len_r = tmpi;
15094 }
15095 }
15096 else if (attack_mode == ATTACK_MODE_BF)
15097 {
15098 char *mask = NULL;
15099
15100 maskcnt = 0;
15101
15102 if (benchmark == 0)
15103 {
15104 mask = myargv[optind + 1];
15105
15106 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15107
15108 if ((optind + 2) <= myargc)
15109 {
15110 struct stat file_stat;
15111
15112 if (stat (mask, &file_stat) == -1)
15113 {
15114 maskcnt = 1;
15115
15116 masks[maskcnt - 1] = mystrdup (mask);
15117 }
15118 else
15119 {
15120 int wls_left = myargc - (optind + 1);
15121
15122 uint masks_avail = INCR_MASKS;
15123
15124 for (int i = 0; i < wls_left; i++)
15125 {
15126 if (i != 0)
15127 {
15128 mask = myargv[optind + 1 + i];
15129
15130 if (stat (mask, &file_stat) == -1)
15131 {
15132 log_error ("ERROR: %s: %s", mask, strerror (errno));
15133
15134 return (-1);
15135 }
15136 }
15137
15138 uint is_file = S_ISREG (file_stat.st_mode);
15139
15140 if (is_file == 1)
15141 {
15142 FILE *mask_fp;
15143
15144 if ((mask_fp = fopen (mask, "r")) == NULL)
15145 {
15146 log_error ("ERROR: %s: %s", mask, strerror (errno));
15147
15148 return (-1);
15149 }
15150
15151 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15152
15153 while (!feof (mask_fp))
15154 {
15155 memset (line_buf, 0, HCBUFSIZ);
15156
15157 int line_len = fgetl (mask_fp, line_buf);
15158
15159 if (line_len == 0) continue;
15160
15161 if (line_buf[0] == '#') continue;
15162
15163 if (masks_avail == maskcnt)
15164 {
15165 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15166
15167 masks_avail += INCR_MASKS;
15168 }
15169
15170 masks[maskcnt] = mystrdup (line_buf);
15171
15172 maskcnt++;
15173 }
15174
15175 myfree (line_buf);
15176
15177 fclose (mask_fp);
15178 }
15179 else
15180 {
15181 log_error ("ERROR: %s: unsupported file-type", mask);
15182
15183 return (-1);
15184 }
15185 }
15186
15187 mask_from_file = 1;
15188 }
15189 }
15190 else
15191 {
15192 custom_charset_1 = (char *) "?l?d?u";
15193 custom_charset_2 = (char *) "?l?d";
15194 custom_charset_3 = (char *) "?l?d*!$@_";
15195
15196 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15197 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15198 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15199
15200 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15201
15202 wordlist_mode = WL_MODE_MASK;
15203
15204 data.wordlist_mode = wordlist_mode;
15205
15206 increment = 1;
15207
15208 maskcnt = 1;
15209 }
15210 }
15211 else
15212 {
15213 /**
15214 * generate full masks and charsets
15215 */
15216
15217 masks = (char **) mymalloc (sizeof (char *));
15218
15219 switch (hash_mode)
15220 {
15221 case 1731: pw_min = 5;
15222 pw_max = 5;
15223 mask = mystrdup ("?b?b?b?b?b");
15224 break;
15225 case 12500: pw_min = 5;
15226 pw_max = 5;
15227 mask = mystrdup ("?b?b?b?b?b");
15228 break;
15229 default: pw_min = 7;
15230 pw_max = 7;
15231 mask = mystrdup ("?b?b?b?b?b?b?b");
15232 break;
15233 }
15234
15235 maskcnt = 1;
15236
15237 masks[maskcnt - 1] = mystrdup (mask);
15238
15239 wordlist_mode = WL_MODE_MASK;
15240
15241 data.wordlist_mode = wordlist_mode;
15242
15243 increment = 1;
15244 }
15245
15246 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15247
15248 if (increment)
15249 {
15250 if (increment_min > pw_min) pw_min = increment_min;
15251
15252 if (increment_max < pw_max) pw_max = increment_max;
15253 }
15254 }
15255 else if (attack_mode == ATTACK_MODE_HYBRID1)
15256 {
15257 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15258
15259 // display
15260
15261 char *mask = myargv[myargc - 1];
15262
15263 maskcnt = 0;
15264
15265 masks = (char **) mymalloc (1 * sizeof (char *));
15266
15267 // mod
15268
15269 struct stat file_stat;
15270
15271 if (stat (mask, &file_stat) == -1)
15272 {
15273 maskcnt = 1;
15274
15275 masks[maskcnt - 1] = mystrdup (mask);
15276 }
15277 else
15278 {
15279 uint is_file = S_ISREG (file_stat.st_mode);
15280
15281 if (is_file == 1)
15282 {
15283 FILE *mask_fp;
15284
15285 if ((mask_fp = fopen (mask, "r")) == NULL)
15286 {
15287 log_error ("ERROR: %s: %s", mask, strerror (errno));
15288
15289 return (-1);
15290 }
15291
15292 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15293
15294 uint masks_avail = 1;
15295
15296 while (!feof (mask_fp))
15297 {
15298 memset (line_buf, 0, HCBUFSIZ);
15299
15300 int line_len = fgetl (mask_fp, line_buf);
15301
15302 if (line_len == 0) continue;
15303
15304 if (line_buf[0] == '#') continue;
15305
15306 if (masks_avail == maskcnt)
15307 {
15308 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15309
15310 masks_avail += INCR_MASKS;
15311 }
15312
15313 masks[maskcnt] = mystrdup (line_buf);
15314
15315 maskcnt++;
15316 }
15317
15318 myfree (line_buf);
15319
15320 fclose (mask_fp);
15321
15322 mask_from_file = 1;
15323 }
15324 else
15325 {
15326 maskcnt = 1;
15327
15328 masks[maskcnt - 1] = mystrdup (mask);
15329 }
15330 }
15331
15332 // base
15333
15334 int wls_left = myargc - (optind + 2);
15335
15336 for (int i = 0; i < wls_left; i++)
15337 {
15338 char *filename = myargv[optind + 1 + i];
15339
15340 struct stat file_stat;
15341
15342 if (stat (filename, &file_stat) == -1)
15343 {
15344 log_error ("ERROR: %s: %s", filename, strerror (errno));
15345
15346 return (-1);
15347 }
15348
15349 uint is_dir = S_ISDIR (file_stat.st_mode);
15350
15351 if (is_dir == 0)
15352 {
15353 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15354
15355 dictcnt++;
15356
15357 dictfiles[dictcnt - 1] = filename;
15358 }
15359 else
15360 {
15361 // do not allow --keyspace w/ a directory
15362
15363 if (keyspace == 1)
15364 {
15365 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15366
15367 return (-1);
15368 }
15369
15370 char **dictionary_files = NULL;
15371
15372 dictionary_files = scan_directory (filename);
15373
15374 if (dictionary_files != NULL)
15375 {
15376 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15377
15378 for (int d = 0; dictionary_files[d] != NULL; d++)
15379 {
15380 char *l1_filename = dictionary_files[d];
15381
15382 struct stat l1_stat;
15383
15384 if (stat (l1_filename, &l1_stat) == -1)
15385 {
15386 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15387
15388 return (-1);
15389 }
15390
15391 if (S_ISREG (l1_stat.st_mode))
15392 {
15393 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15394
15395 dictcnt++;
15396
15397 dictfiles[dictcnt - 1] = strdup (l1_filename);
15398 }
15399 }
15400 }
15401
15402 local_free (dictionary_files);
15403 }
15404 }
15405
15406 if (dictcnt < 1)
15407 {
15408 log_error ("ERROR: No usable dictionary file found.");
15409
15410 return (-1);
15411 }
15412
15413 if (increment)
15414 {
15415 maskcnt = 0;
15416
15417 uint mask_min = increment_min; // we can't reject smaller masks here
15418 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15419
15420 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15421 {
15422 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15423
15424 if (cur_mask == NULL) break;
15425
15426 masks[maskcnt] = cur_mask;
15427
15428 maskcnt++;
15429
15430 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15431 }
15432 }
15433 }
15434 else if (attack_mode == ATTACK_MODE_HYBRID2)
15435 {
15436 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15437
15438 // display
15439
15440 char *mask = myargv[optind + 1 + 0];
15441
15442 maskcnt = 0;
15443
15444 masks = (char **) mymalloc (1 * sizeof (char *));
15445
15446 // mod
15447
15448 struct stat file_stat;
15449
15450 if (stat (mask, &file_stat) == -1)
15451 {
15452 maskcnt = 1;
15453
15454 masks[maskcnt - 1] = mystrdup (mask);
15455 }
15456 else
15457 {
15458 uint is_file = S_ISREG (file_stat.st_mode);
15459
15460 if (is_file == 1)
15461 {
15462 FILE *mask_fp;
15463
15464 if ((mask_fp = fopen (mask, "r")) == NULL)
15465 {
15466 log_error ("ERROR: %s: %s", mask, strerror (errno));
15467
15468 return (-1);
15469 }
15470
15471 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15472
15473 uint masks_avail = 1;
15474
15475 while (!feof (mask_fp))
15476 {
15477 memset (line_buf, 0, HCBUFSIZ);
15478
15479 int line_len = fgetl (mask_fp, line_buf);
15480
15481 if (line_len == 0) continue;
15482
15483 if (line_buf[0] == '#') continue;
15484
15485 if (masks_avail == maskcnt)
15486 {
15487 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15488
15489 masks_avail += INCR_MASKS;
15490 }
15491
15492 masks[maskcnt] = mystrdup (line_buf);
15493
15494 maskcnt++;
15495 }
15496
15497 myfree (line_buf);
15498
15499 fclose (mask_fp);
15500
15501 mask_from_file = 1;
15502 }
15503 else
15504 {
15505 maskcnt = 1;
15506
15507 masks[maskcnt - 1] = mystrdup (mask);
15508 }
15509 }
15510
15511 // base
15512
15513 int wls_left = myargc - (optind + 2);
15514
15515 for (int i = 0; i < wls_left; i++)
15516 {
15517 char *filename = myargv[optind + 2 + i];
15518
15519 struct stat file_stat;
15520
15521 if (stat (filename, &file_stat) == -1)
15522 {
15523 log_error ("ERROR: %s: %s", filename, strerror (errno));
15524
15525 return (-1);
15526 }
15527
15528 uint is_dir = S_ISDIR (file_stat.st_mode);
15529
15530 if (is_dir == 0)
15531 {
15532 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15533
15534 dictcnt++;
15535
15536 dictfiles[dictcnt - 1] = filename;
15537 }
15538 else
15539 {
15540 // do not allow --keyspace w/ a directory
15541
15542 if (keyspace == 1)
15543 {
15544 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15545
15546 return (-1);
15547 }
15548
15549 char **dictionary_files = NULL;
15550
15551 dictionary_files = scan_directory (filename);
15552
15553 if (dictionary_files != NULL)
15554 {
15555 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15556
15557 for (int d = 0; dictionary_files[d] != NULL; d++)
15558 {
15559 char *l1_filename = dictionary_files[d];
15560
15561 struct stat l1_stat;
15562
15563 if (stat (l1_filename, &l1_stat) == -1)
15564 {
15565 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15566
15567 return (-1);
15568 }
15569
15570 if (S_ISREG (l1_stat.st_mode))
15571 {
15572 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15573
15574 dictcnt++;
15575
15576 dictfiles[dictcnt - 1] = strdup (l1_filename);
15577 }
15578 }
15579 }
15580
15581 local_free (dictionary_files);
15582 }
15583 }
15584
15585 if (dictcnt < 1)
15586 {
15587 log_error ("ERROR: No usable dictionary file found.");
15588
15589 return (-1);
15590 }
15591
15592 if (increment)
15593 {
15594 maskcnt = 0;
15595
15596 uint mask_min = increment_min; // we can't reject smaller masks here
15597 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15598
15599 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15600 {
15601 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15602
15603 if (cur_mask == NULL) break;
15604
15605 masks[maskcnt] = cur_mask;
15606
15607 maskcnt++;
15608
15609 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15610 }
15611 }
15612 }
15613
15614 data.pw_min = pw_min;
15615 data.pw_max = pw_max;
15616
15617 /**
15618 * weak hash check
15619 */
15620
15621 if (weak_hash_threshold >= salts_cnt)
15622 {
15623 hc_device_param_t *device_param = NULL;
15624
15625 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15626 {
15627 device_param = &data.devices_param[device_id];
15628
15629 if (device_param->skipped) continue;
15630
15631 break;
15632 }
15633
15634 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15635
15636 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15637 {
15638 weak_hash_check (device_param, salt_pos);
15639 }
15640 }
15641
15642 // Display hack, guarantee that there is at least one \r before real start
15643
15644 if (data.quiet == 0) log_info_nn ("");
15645
15646 /**
15647 * status and monitor threads
15648 */
15649
15650 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15651
15652 hc_thread_t i_thread = 0;
15653
15654 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15655 {
15656 hc_thread_create (i_thread, thread_keypress, &benchmark);
15657 }
15658
15659 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15660
15661 uint ni_threads_cnt = 0;
15662
15663 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15664
15665 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15666
15667 ni_threads_cnt++;
15668
15669 /**
15670 * Outfile remove
15671 */
15672
15673 if (keyspace == 0)
15674 {
15675 if (outfile_check_timer != 0)
15676 {
15677 if (data.outfile_check_directory != NULL)
15678 {
15679 if ((hash_mode != 5200) &&
15680 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15681 (hash_mode != 9000))
15682 {
15683 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15684
15685 ni_threads_cnt++;
15686 }
15687 else
15688 {
15689 outfile_check_timer = 0;
15690 }
15691 }
15692 else
15693 {
15694 outfile_check_timer = 0;
15695 }
15696 }
15697 }
15698
15699 /**
15700 * Inform the user if we got some hashes remove because of the pot file remove feature
15701 */
15702
15703 if (data.quiet == 0)
15704 {
15705 if (potfile_remove_cracks > 0)
15706 {
15707 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15708 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15709 }
15710 }
15711
15712 data.outfile_check_timer = outfile_check_timer;
15713
15714 /**
15715 * main loop
15716 */
15717
15718 char **induction_dictionaries = NULL;
15719
15720 int induction_dictionaries_cnt = 0;
15721
15722 hcstat_table_t *root_table_buf = NULL;
15723 hcstat_table_t *markov_table_buf = NULL;
15724
15725 uint initial_restore_done = 0;
15726
15727 data.maskcnt = maskcnt;
15728
15729 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15730 {
15731 if (data.devices_status == STATUS_CRACKED) break;
15732
15733 data.devices_status = STATUS_INIT;
15734
15735 if (maskpos > rd->maskpos)
15736 {
15737 rd->dictpos = 0;
15738 }
15739
15740 rd->maskpos = maskpos;
15741 data.maskpos = maskpos;
15742
15743 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15744 {
15745 char *mask = masks[maskpos];
15746
15747 if (mask_from_file == 1)
15748 {
15749 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15750
15751 char *str_ptr;
15752 uint str_pos;
15753
15754 uint mask_offset = 0;
15755
15756 uint separator_cnt;
15757
15758 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15759 {
15760 str_ptr = strstr (mask + mask_offset, ",");
15761
15762 if (str_ptr == NULL) break;
15763
15764 str_pos = str_ptr - mask;
15765
15766 // escaped separator, i.e. "\,"
15767
15768 if (str_pos > 0)
15769 {
15770 if (mask[str_pos - 1] == '\\')
15771 {
15772 separator_cnt --;
15773
15774 mask_offset = str_pos + 1;
15775
15776 continue;
15777 }
15778 }
15779
15780 // reset the offset
15781
15782 mask_offset = 0;
15783
15784 mask[str_pos] = '\0';
15785
15786 switch (separator_cnt)
15787 {
15788 case 0:
15789 mp_reset_usr (mp_usr, 0);
15790
15791 custom_charset_1 = mask;
15792 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15793 break;
15794
15795 case 1:
15796 mp_reset_usr (mp_usr, 1);
15797
15798 custom_charset_2 = mask;
15799 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15800 break;
15801
15802 case 2:
15803 mp_reset_usr (mp_usr, 2);
15804
15805 custom_charset_3 = mask;
15806 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15807 break;
15808
15809 case 3:
15810 mp_reset_usr (mp_usr, 3);
15811
15812 custom_charset_4 = mask;
15813 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15814 break;
15815 }
15816
15817 mask = mask + str_pos + 1;
15818 }
15819 }
15820
15821 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15822 {
15823 if (maskpos > 0)
15824 {
15825 local_free (css_buf);
15826 local_free (data.root_css_buf);
15827 local_free (data.markov_css_buf);
15828
15829 local_free (masks[maskpos - 1]);
15830 }
15831
15832 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15833
15834 data.mask = mask;
15835 data.css_cnt = css_cnt;
15836 data.css_buf = css_buf;
15837
15838 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15839
15840 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15841
15842 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15843 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15844
15845 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15846
15847 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15848
15849 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15850 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15851
15852 data.root_css_buf = root_css_buf;
15853 data.markov_css_buf = markov_css_buf;
15854
15855 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15856
15857 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15858
15859 local_free (root_table_buf);
15860 local_free (markov_table_buf);
15861
15862 // args
15863
15864 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15865 {
15866 hc_device_param_t *device_param = &data.devices_param[device_id];
15867
15868 if (device_param->skipped) continue;
15869
15870 device_param->kernel_params_mp[0] = &device_param->d_combs;
15871 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15872 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15873
15874 device_param->kernel_params_mp_buf64[3] = 0;
15875 device_param->kernel_params_mp_buf32[4] = css_cnt;
15876 device_param->kernel_params_mp_buf32[5] = 0;
15877 device_param->kernel_params_mp_buf32[6] = 0;
15878 device_param->kernel_params_mp_buf32[7] = 0;
15879
15880 if (attack_mode == ATTACK_MODE_HYBRID1)
15881 {
15882 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15883 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15884 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15885 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15886 }
15887 else if (attack_mode == ATTACK_MODE_HYBRID2)
15888 {
15889 device_param->kernel_params_mp_buf32[5] = 0;
15890 device_param->kernel_params_mp_buf32[6] = 0;
15891 device_param->kernel_params_mp_buf32[7] = 0;
15892 }
15893
15894 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]);
15895 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]);
15896 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]);
15897
15898 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);
15899 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);
15900 }
15901 }
15902 else if (attack_mode == ATTACK_MODE_BF)
15903 {
15904 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15905
15906 if (increment)
15907 {
15908 for (uint i = 0; i < dictcnt; i++)
15909 {
15910 local_free (dictfiles[i]);
15911 }
15912
15913 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15914 {
15915 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15916
15917 if (l1_filename == NULL) break;
15918
15919 dictcnt++;
15920
15921 dictfiles[dictcnt - 1] = l1_filename;
15922 }
15923 }
15924 else
15925 {
15926 dictcnt++;
15927
15928 dictfiles[dictcnt - 1] = mask;
15929 }
15930
15931 if (dictcnt == 0)
15932 {
15933 log_error ("ERROR: Mask is too small");
15934
15935 return (-1);
15936 }
15937 }
15938 }
15939
15940 free (induction_dictionaries);
15941
15942 // induction_dictionaries_cnt = 0; // implied
15943
15944 if (attack_mode != ATTACK_MODE_BF)
15945 {
15946 if (keyspace == 0)
15947 {
15948 induction_dictionaries = scan_directory (induction_directory);
15949
15950 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15951 }
15952 }
15953
15954 if (induction_dictionaries_cnt)
15955 {
15956 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15957 }
15958
15959 /**
15960 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15961 */
15962 if (keyspace == 1)
15963 {
15964 if ((maskcnt > 1) || (dictcnt > 1))
15965 {
15966 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15967
15968 return (-1);
15969 }
15970 }
15971
15972 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15973 {
15974 char *subid = logfile_generate_subid ();
15975
15976 data.subid = subid;
15977
15978 logfile_sub_msg ("START");
15979
15980 data.devices_status = STATUS_INIT;
15981
15982 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15983 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15984 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15985
15986 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15987
15988 data.cpt_pos = 0;
15989
15990 data.cpt_start = time (NULL);
15991
15992 data.cpt_total = 0;
15993
15994 if (data.restore == 0)
15995 {
15996 rd->words_cur = skip;
15997
15998 skip = 0;
15999
16000 data.skip = 0;
16001 }
16002
16003 data.ms_paused = 0;
16004
16005 data.words_cur = rd->words_cur;
16006
16007 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16008 {
16009 hc_device_param_t *device_param = &data.devices_param[device_id];
16010
16011 if (device_param->skipped) continue;
16012
16013 device_param->speed_pos = 0;
16014
16015 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16016 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
16017 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
16018
16019 device_param->exec_pos = 0;
16020
16021 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16022
16023 device_param->kernel_power = device_param->kernel_power_user;
16024
16025 device_param->outerloop_pos = 0;
16026 device_param->outerloop_left = 0;
16027 device_param->innerloop_pos = 0;
16028 device_param->innerloop_left = 0;
16029
16030 // some more resets:
16031
16032 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16033
16034 device_param->pws_cnt = 0;
16035
16036 device_param->words_off = 0;
16037 device_param->words_done = 0;
16038 }
16039
16040 data.kernel_power_div = 0;
16041
16042 // figure out some workload
16043
16044 if (attack_mode == ATTACK_MODE_STRAIGHT)
16045 {
16046 if (data.wordlist_mode == WL_MODE_FILE)
16047 {
16048 char *dictfile = NULL;
16049
16050 if (induction_dictionaries_cnt)
16051 {
16052 dictfile = induction_dictionaries[0];
16053 }
16054 else
16055 {
16056 dictfile = dictfiles[dictpos];
16057 }
16058
16059 data.dictfile = dictfile;
16060
16061 logfile_sub_string (dictfile);
16062
16063 for (uint i = 0; i < rp_files_cnt; i++)
16064 {
16065 logfile_sub_var_string ("rulefile", rp_files[i]);
16066 }
16067
16068 FILE *fd2 = fopen (dictfile, "rb");
16069
16070 if (fd2 == NULL)
16071 {
16072 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16073
16074 return (-1);
16075 }
16076
16077 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16078
16079 fclose (fd2);
16080
16081 if (data.words_cnt == 0)
16082 {
16083 if (data.devices_status == STATUS_CRACKED) break;
16084 if (data.devices_status == STATUS_ABORTED) break;
16085
16086 dictpos++;
16087
16088 continue;
16089 }
16090 }
16091 }
16092 else if (attack_mode == ATTACK_MODE_COMBI)
16093 {
16094 char *dictfile = data.dictfile;
16095 char *dictfile2 = data.dictfile2;
16096
16097 logfile_sub_string (dictfile);
16098 logfile_sub_string (dictfile2);
16099
16100 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16101 {
16102 FILE *fd2 = fopen (dictfile, "rb");
16103
16104 if (fd2 == NULL)
16105 {
16106 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16107
16108 return (-1);
16109 }
16110
16111 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16112
16113 fclose (fd2);
16114 }
16115 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16116 {
16117 FILE *fd2 = fopen (dictfile2, "rb");
16118
16119 if (fd2 == NULL)
16120 {
16121 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16122
16123 return (-1);
16124 }
16125
16126 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16127
16128 fclose (fd2);
16129 }
16130
16131 if (data.words_cnt == 0)
16132 {
16133 if (data.devices_status == STATUS_CRACKED) break;
16134 if (data.devices_status == STATUS_ABORTED) break;
16135
16136 dictpos++;
16137
16138 continue;
16139 }
16140 }
16141 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16142 {
16143 char *dictfile = NULL;
16144
16145 if (induction_dictionaries_cnt)
16146 {
16147 dictfile = induction_dictionaries[0];
16148 }
16149 else
16150 {
16151 dictfile = dictfiles[dictpos];
16152 }
16153
16154 data.dictfile = dictfile;
16155
16156 char *mask = data.mask;
16157
16158 logfile_sub_string (dictfile);
16159 logfile_sub_string (mask);
16160
16161 FILE *fd2 = fopen (dictfile, "rb");
16162
16163 if (fd2 == NULL)
16164 {
16165 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16166
16167 return (-1);
16168 }
16169
16170 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16171
16172 fclose (fd2);
16173
16174 if (data.words_cnt == 0)
16175 {
16176 if (data.devices_status == STATUS_CRACKED) break;
16177 if (data.devices_status == STATUS_ABORTED) break;
16178
16179 dictpos++;
16180
16181 continue;
16182 }
16183 }
16184 else if (attack_mode == ATTACK_MODE_BF)
16185 {
16186 local_free (css_buf);
16187 local_free (data.root_css_buf);
16188 local_free (data.markov_css_buf);
16189
16190 char *mask = dictfiles[dictpos];
16191
16192 logfile_sub_string (mask);
16193
16194 // base
16195
16196 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16197
16198 if (opts_type & OPTS_TYPE_PT_UNICODE)
16199 {
16200 uint css_cnt_unicode = css_cnt * 2;
16201
16202 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16203
16204 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16205 {
16206 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16207
16208 css_buf_unicode[j + 1].cs_buf[0] = 0;
16209 css_buf_unicode[j + 1].cs_len = 1;
16210 }
16211
16212 free (css_buf);
16213
16214 css_buf = css_buf_unicode;
16215 css_cnt = css_cnt_unicode;
16216 }
16217
16218 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16219
16220 uint mask_min = pw_min;
16221 uint mask_max = pw_max;
16222
16223 if (opts_type & OPTS_TYPE_PT_UNICODE)
16224 {
16225 mask_min *= 2;
16226 mask_max *= 2;
16227 }
16228
16229 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16230 {
16231 if (css_cnt < mask_min)
16232 {
16233 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16234 }
16235
16236 if (css_cnt > mask_max)
16237 {
16238 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16239 }
16240
16241 // skip to next mask
16242
16243 dictpos++;
16244
16245 rd->dictpos = dictpos;
16246
16247 logfile_sub_msg ("STOP");
16248
16249 continue;
16250 }
16251
16252 uint save_css_cnt = css_cnt;
16253
16254 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16255 {
16256 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16257 {
16258 uint salt_len = (uint) data.salts_buf[0].salt_len;
16259 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16260
16261 uint css_cnt_salt = css_cnt + salt_len;
16262
16263 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16264
16265 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16266
16267 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16268 {
16269 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16270 css_buf_salt[j].cs_len = 1;
16271 }
16272
16273 free (css_buf);
16274
16275 css_buf = css_buf_salt;
16276 css_cnt = css_cnt_salt;
16277 }
16278 }
16279
16280 data.mask = mask;
16281 data.css_cnt = css_cnt;
16282 data.css_buf = css_buf;
16283
16284 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16285
16286 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16287
16288 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16289
16290 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16291 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16292
16293 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16294
16295 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16296
16297 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16298 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16299
16300 data.root_css_buf = root_css_buf;
16301 data.markov_css_buf = markov_css_buf;
16302
16303 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16304
16305 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16306
16307 local_free (root_table_buf);
16308 local_free (markov_table_buf);
16309
16310 // copy + args
16311
16312 uint css_cnt_l = css_cnt;
16313 uint css_cnt_r;
16314
16315 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16316 {
16317 if (save_css_cnt < 6)
16318 {
16319 css_cnt_r = 1;
16320 }
16321 else if (save_css_cnt == 6)
16322 {
16323 css_cnt_r = 2;
16324 }
16325 else
16326 {
16327 if (opts_type & OPTS_TYPE_PT_UNICODE)
16328 {
16329 if (save_css_cnt == 8 || save_css_cnt == 10)
16330 {
16331 css_cnt_r = 2;
16332 }
16333 else
16334 {
16335 css_cnt_r = 4;
16336 }
16337 }
16338 else
16339 {
16340 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16341 {
16342 css_cnt_r = 3;
16343 }
16344 else
16345 {
16346 css_cnt_r = 4;
16347 }
16348 }
16349 }
16350 }
16351 else
16352 {
16353 css_cnt_r = 1;
16354
16355 /* unfinished code?
16356 int sum = css_buf[css_cnt_r - 1].cs_len;
16357
16358 for (uint i = 1; i < 4 && i < css_cnt; i++)
16359 {
16360 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16361
16362 css_cnt_r++;
16363
16364 sum *= css_buf[css_cnt_r - 1].cs_len;
16365 }
16366 */
16367 }
16368
16369 css_cnt_l -= css_cnt_r;
16370
16371 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16372
16373 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16374 {
16375 hc_device_param_t *device_param = &data.devices_param[device_id];
16376
16377 if (device_param->skipped) continue;
16378
16379 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16380 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16381 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16382
16383 device_param->kernel_params_mp_l_buf64[3] = 0;
16384 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16385 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16386 device_param->kernel_params_mp_l_buf32[6] = 0;
16387 device_param->kernel_params_mp_l_buf32[7] = 0;
16388 device_param->kernel_params_mp_l_buf32[8] = 0;
16389
16390 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16391 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16392 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16393 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16394
16395 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16396 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16397 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16398
16399 device_param->kernel_params_mp_r_buf64[3] = 0;
16400 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16401 device_param->kernel_params_mp_r_buf32[5] = 0;
16402 device_param->kernel_params_mp_r_buf32[6] = 0;
16403 device_param->kernel_params_mp_r_buf32[7] = 0;
16404
16405 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]);
16406 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]);
16407 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]);
16408
16409 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]);
16410 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]);
16411 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]);
16412
16413 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);
16414 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);
16415 }
16416 }
16417
16418 u64 words_base = data.words_cnt;
16419
16420 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16421 {
16422 if (data.kernel_rules_cnt)
16423 {
16424 words_base /= data.kernel_rules_cnt;
16425 }
16426 }
16427 else if (data.attack_kern == ATTACK_KERN_COMBI)
16428 {
16429 if (data.combs_cnt)
16430 {
16431 words_base /= data.combs_cnt;
16432 }
16433 }
16434 else if (data.attack_kern == ATTACK_KERN_BF)
16435 {
16436 if (data.bfs_cnt)
16437 {
16438 words_base /= data.bfs_cnt;
16439 }
16440 }
16441
16442 data.words_base = words_base;
16443
16444 if (keyspace == 1)
16445 {
16446 log_info ("%llu", (unsigned long long int) words_base);
16447
16448 return (0);
16449 }
16450
16451 if (data.words_cur > data.words_base)
16452 {
16453 log_error ("ERROR: restore value greater keyspace");
16454
16455 return (-1);
16456 }
16457
16458 if (data.words_cur)
16459 {
16460 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16461 {
16462 for (uint i = 0; i < data.salts_cnt; i++)
16463 {
16464 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16465 }
16466 }
16467 else if (data.attack_kern == ATTACK_KERN_COMBI)
16468 {
16469 for (uint i = 0; i < data.salts_cnt; i++)
16470 {
16471 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16472 }
16473 }
16474 else if (data.attack_kern == ATTACK_KERN_BF)
16475 {
16476 for (uint i = 0; i < data.salts_cnt; i++)
16477 {
16478 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16479 }
16480 }
16481 }
16482
16483 /*
16484 * Inform user about possible slow speeds
16485 */
16486
16487 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16488 {
16489 if (data.words_base < kernel_power_all)
16490 {
16491 if (quiet == 0)
16492 {
16493 log_info ("");
16494 log_info ("ATTENTION!");
16495 log_info (" The wordlist or mask you are using is too small.");
16496 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16497 log_info (" The cracking speed will drop.");
16498 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16499 log_info ("");
16500 }
16501 }
16502 }
16503
16504 /*
16505 * Update loopback file
16506 */
16507
16508 if (loopback == 1)
16509 {
16510 time_t now;
16511
16512 time (&now);
16513
16514 uint random_num = get_random_num (0, 9999);
16515
16516 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16517
16518 data.loopback_file = loopback_file;
16519 }
16520
16521 /*
16522 * Update dictionary statistic
16523 */
16524
16525 if (keyspace == 0)
16526 {
16527 dictstat_fp = fopen (dictstat, "wb");
16528
16529 if (dictstat_fp)
16530 {
16531 lock_file (dictstat_fp);
16532
16533 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16534
16535 fclose (dictstat_fp);
16536 }
16537 }
16538
16539 data.devices_status = STATUS_RUNNING;
16540
16541 if (initial_restore_done == 0)
16542 {
16543 if (data.restore_disable == 0) cycle_restore ();
16544
16545 initial_restore_done = 1;
16546 }
16547
16548 hc_timer_set (&data.timer_running);
16549
16550 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16551 {
16552 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16553 {
16554 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16555 if (quiet == 0) fflush (stdout);
16556 }
16557 }
16558 else if (wordlist_mode == WL_MODE_STDIN)
16559 {
16560 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16561 if (data.quiet == 0) log_info ("");
16562 }
16563
16564 time_t runtime_start;
16565
16566 time (&runtime_start);
16567
16568 data.runtime_start = runtime_start;
16569
16570 /**
16571 * create cracker threads
16572 */
16573
16574 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16575
16576 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16577 {
16578 hc_device_param_t *device_param = &devices_param[device_id];
16579
16580 if (wordlist_mode == WL_MODE_STDIN)
16581 {
16582 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16583 }
16584 else
16585 {
16586 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16587 }
16588 }
16589
16590 // wait for crack threads to exit
16591
16592 hc_thread_wait (data.devices_cnt, c_threads);
16593
16594 local_free (c_threads);
16595
16596 data.restore = 0;
16597
16598 // finalize task
16599
16600 logfile_sub_var_uint ("status-after-work", data.devices_status);
16601
16602 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16603
16604 if (data.devices_status == STATUS_CRACKED) break;
16605 if (data.devices_status == STATUS_ABORTED) break;
16606
16607 if (data.devices_status == STATUS_BYPASS)
16608 {
16609 data.devices_status = STATUS_RUNNING;
16610 }
16611
16612 if (induction_dictionaries_cnt)
16613 {
16614 unlink (induction_dictionaries[0]);
16615 }
16616
16617 free (induction_dictionaries);
16618
16619 if (attack_mode != ATTACK_MODE_BF)
16620 {
16621 induction_dictionaries = scan_directory (induction_directory);
16622
16623 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16624 }
16625
16626 if (benchmark == 0)
16627 {
16628 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16629 {
16630 if (quiet == 0) clear_prompt ();
16631
16632 if (quiet == 0) log_info ("");
16633
16634 if (status == 1)
16635 {
16636 status_display ();
16637 }
16638 else
16639 {
16640 if (quiet == 0) status_display ();
16641 }
16642
16643 if (quiet == 0) log_info ("");
16644 }
16645 }
16646
16647 if (attack_mode == ATTACK_MODE_BF)
16648 {
16649 dictpos++;
16650
16651 rd->dictpos = dictpos;
16652 }
16653 else
16654 {
16655 if (induction_dictionaries_cnt)
16656 {
16657 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16658 }
16659 else
16660 {
16661 dictpos++;
16662
16663 rd->dictpos = dictpos;
16664 }
16665 }
16666
16667 time_t runtime_stop;
16668
16669 time (&runtime_stop);
16670
16671 data.runtime_stop = runtime_stop;
16672
16673 logfile_sub_uint (runtime_start);
16674 logfile_sub_uint (runtime_stop);
16675
16676 logfile_sub_msg ("STOP");
16677
16678 global_free (subid);
16679 }
16680
16681 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16682
16683 if (data.devices_status == STATUS_CRACKED) break;
16684 if (data.devices_status == STATUS_ABORTED) break;
16685 if (data.devices_status == STATUS_QUIT) break;
16686
16687 if (data.devices_status == STATUS_BYPASS)
16688 {
16689 data.devices_status = STATUS_RUNNING;
16690 }
16691 }
16692
16693 // 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
16694
16695 if (attack_mode == ATTACK_MODE_STRAIGHT)
16696 {
16697 if (data.wordlist_mode == WL_MODE_FILE)
16698 {
16699 if (data.dictfile == NULL)
16700 {
16701 if (dictfiles != NULL)
16702 {
16703 data.dictfile = dictfiles[0];
16704
16705 hc_timer_set (&data.timer_running);
16706 }
16707 }
16708 }
16709 }
16710 // NOTE: combi is okay because it is already set beforehand
16711 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16712 {
16713 if (data.dictfile == NULL)
16714 {
16715 if (dictfiles != NULL)
16716 {
16717 hc_timer_set (&data.timer_running);
16718
16719 data.dictfile = dictfiles[0];
16720 }
16721 }
16722 }
16723 else if (attack_mode == ATTACK_MODE_BF)
16724 {
16725 if (data.mask == NULL)
16726 {
16727 hc_timer_set (&data.timer_running);
16728
16729 data.mask = masks[0];
16730 }
16731 }
16732
16733 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16734 {
16735 data.devices_status = STATUS_EXHAUSTED;
16736 }
16737
16738 // if cracked / aborted remove last induction dictionary
16739
16740 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16741 {
16742 struct stat induct_stat;
16743
16744 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16745 {
16746 unlink (induction_dictionaries[file_pos]);
16747 }
16748 }
16749
16750 // wait for non-interactive threads
16751
16752 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16753 {
16754 hc_thread_wait (1, &ni_threads[thread_idx]);
16755 }
16756
16757 local_free (ni_threads);
16758
16759 // wait for interactive threads
16760
16761 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16762 {
16763 hc_thread_wait (1, &i_thread);
16764 }
16765
16766 // we dont need restore file anymore
16767 if (data.restore_disable == 0)
16768 {
16769 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16770 {
16771 unlink (eff_restore_file);
16772 unlink (new_restore_file);
16773 }
16774 else
16775 {
16776 cycle_restore ();
16777 }
16778 }
16779
16780 // finally save left hashes
16781
16782 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16783 {
16784 save_hash ();
16785 }
16786
16787 /**
16788 * Clean up
16789 */
16790
16791 if (benchmark == 1)
16792 {
16793 status_benchmark ();
16794
16795 log_info ("");
16796 }
16797 else
16798 {
16799 if (quiet == 0) clear_prompt ();
16800
16801 if (quiet == 0) log_info ("");
16802
16803 if (status == 1)
16804 {
16805 status_display ();
16806 }
16807 else
16808 {
16809 if (quiet == 0) status_display ();
16810 }
16811
16812 if (quiet == 0) log_info ("");
16813 }
16814
16815 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16816 {
16817 hc_device_param_t *device_param = &data.devices_param[device_id];
16818
16819 if (device_param->skipped) continue;
16820
16821 local_free (device_param->result);
16822
16823 local_free (device_param->combs_buf);
16824
16825 local_free (device_param->hooks_buf);
16826
16827 local_free (device_param->device_name);
16828
16829 local_free (device_param->device_name_chksum);
16830
16831 local_free (device_param->device_version);
16832
16833 local_free (device_param->driver_version);
16834
16835 if (device_param->pws_buf) myfree (device_param->pws_buf);
16836 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16837 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16838 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16839 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16840 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16841 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16842 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16843 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16844 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16845 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16846 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16847 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16848 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16849 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16850 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16851 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16852 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16853 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16854 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16855 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16856 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16857 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16858 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16859 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16860 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16861 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16862 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16863 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16864
16865 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16866 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16867 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16868 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16869 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16870 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16871 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16872 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16873 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16874 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16875
16876 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16877 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16878 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16879
16880 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16881 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16882 }
16883
16884 // reset default fan speed
16885
16886 #ifdef HAVE_HWMON
16887 if (gpu_temp_disable == 0)
16888 {
16889 #ifdef HAVE_ADL
16890 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16891 {
16892 hc_thread_mutex_lock (mux_adl);
16893
16894 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16895 {
16896 hc_device_param_t *device_param = &data.devices_param[device_id];
16897
16898 if (device_param->skipped) continue;
16899
16900 if (data.hm_device[device_id].fan_supported == 1)
16901 {
16902 int fanspeed = temp_retain_fanspeed_value[device_id];
16903
16904 if (fanspeed == -1) continue;
16905
16906 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16907
16908 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16909 }
16910 }
16911
16912 hc_thread_mutex_unlock (mux_adl);
16913 }
16914 #endif // HAVE_ADL
16915 }
16916
16917 #ifdef HAVE_ADL
16918 // reset power tuning
16919
16920 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16921 {
16922 hc_thread_mutex_lock (mux_adl);
16923
16924 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16925 {
16926 hc_device_param_t *device_param = &data.devices_param[device_id];
16927
16928 if (device_param->skipped) continue;
16929
16930 if (data.hm_device[device_id].od_version == 6)
16931 {
16932 // check powertune capabilities first, if not available then skip device
16933
16934 int powertune_supported = 0;
16935
16936 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16937 {
16938 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16939
16940 return (-1);
16941 }
16942
16943 if (powertune_supported != 0)
16944 {
16945 // powercontrol settings
16946
16947 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)
16948 {
16949 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16950
16951 return (-1);
16952 }
16953
16954 // clocks
16955
16956 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16957
16958 performance_state->iNumberOfPerformanceLevels = 2;
16959
16960 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16961 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16962 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16963 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16964
16965 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)
16966 {
16967 log_info ("ERROR: Failed to restore ADL performance state");
16968
16969 return (-1);
16970 }
16971
16972 local_free (performance_state);
16973 }
16974 }
16975 }
16976
16977 hc_thread_mutex_unlock (mux_adl);
16978 }
16979 #endif // HAVE_ADL
16980
16981 if (gpu_temp_disable == 0)
16982 {
16983 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
16984 if (data.hm_nv)
16985 {
16986 #if defined(LINUX) && defined(HAVE_NVML)
16987
16988 hm_NVML_nvmlShutdown (data.hm_nv);
16989
16990 nvml_close (data.hm_nv);
16991
16992 #elif defined(WIN) && (HAVE_NVAPI)
16993
16994 hm_NvAPI_Unload (data.hm_nv);
16995
16996 nvapi_close (data.hm_nv);
16997
16998 #endif
16999
17000 data.hm_nv = NULL;
17001 }
17002 #endif
17003
17004 #ifdef HAVE_ADL
17005 if (data.hm_amd)
17006 {
17007 hm_ADL_Main_Control_Destroy (data.hm_amd);
17008
17009 adl_close (data.hm_amd);
17010 data.hm_amd = NULL;
17011 }
17012 #endif
17013 }
17014 #endif // HAVE_HWMON
17015
17016 // free memory
17017
17018 local_free (masks);
17019
17020 local_free (dictstat_base);
17021
17022 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17023 {
17024 pot_t *pot_ptr = &pot[pot_pos];
17025
17026 hash_t *hash = &pot_ptr->hash;
17027
17028 local_free (hash->digest);
17029
17030 if (isSalted)
17031 {
17032 local_free (hash->salt);
17033 }
17034 }
17035
17036 local_free (pot);
17037
17038 local_free (all_kernel_rules_cnt);
17039 local_free (all_kernel_rules_buf);
17040
17041 local_free (wl_data->buf);
17042 local_free (wl_data);
17043
17044 local_free (bitmap_s1_a);
17045 local_free (bitmap_s1_b);
17046 local_free (bitmap_s1_c);
17047 local_free (bitmap_s1_d);
17048 local_free (bitmap_s2_a);
17049 local_free (bitmap_s2_b);
17050 local_free (bitmap_s2_c);
17051 local_free (bitmap_s2_d);
17052
17053 #ifdef HAVE_HWMON
17054 local_free (temp_retain_fanspeed_value);
17055 #ifdef HAVE_ADL
17056 local_free (od_clock_mem_status);
17057 local_free (od_power_control_status);
17058 #endif // ADL
17059 #endif
17060
17061 global_free (devices_param);
17062
17063 global_free (kernel_rules_buf);
17064
17065 global_free (root_css_buf);
17066 global_free (markov_css_buf);
17067
17068 global_free (digests_buf);
17069 global_free (digests_shown);
17070 global_free (digests_shown_tmp);
17071
17072 global_free (salts_buf);
17073 global_free (salts_shown);
17074
17075 global_free (esalts_buf);
17076
17077 global_free (words_progress_done);
17078 global_free (words_progress_rejected);
17079 global_free (words_progress_restored);
17080
17081 if (pot_fp) fclose (pot_fp);
17082
17083 if (data.devices_status == STATUS_QUIT) break;
17084 }
17085
17086 // destroy others mutex
17087
17088 hc_thread_mutex_delete (mux_dispatcher);
17089 hc_thread_mutex_delete (mux_counter);
17090 hc_thread_mutex_delete (mux_display);
17091 hc_thread_mutex_delete (mux_adl);
17092
17093 // free memory
17094
17095 local_free (eff_restore_file);
17096 local_free (new_restore_file);
17097
17098 local_free (rd);
17099
17100 // tuning db
17101
17102 tuning_db_destroy (tuning_db);
17103
17104 // loopback
17105
17106 local_free (loopback_file);
17107
17108 if (loopback == 1) unlink (loopback_file);
17109
17110 // induction directory
17111
17112 if (induction_dir == NULL)
17113 {
17114 if (attack_mode != ATTACK_MODE_BF)
17115 {
17116 if (rmdir (induction_directory) == -1)
17117 {
17118 if (errno == ENOENT)
17119 {
17120 // good, we can ignore
17121 }
17122 else if (errno == ENOTEMPTY)
17123 {
17124 // good, we can ignore
17125 }
17126 else
17127 {
17128 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17129
17130 return (-1);
17131 }
17132 }
17133
17134 local_free (induction_directory);
17135 }
17136 }
17137
17138 // outfile-check directory
17139
17140 if (outfile_check_dir == NULL)
17141 {
17142 if (rmdir (outfile_check_directory) == -1)
17143 {
17144 if (errno == ENOENT)
17145 {
17146 // good, we can ignore
17147 }
17148 else if (errno == ENOTEMPTY)
17149 {
17150 // good, we can ignore
17151 }
17152 else
17153 {
17154 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17155
17156 return (-1);
17157 }
17158 }
17159
17160 local_free (outfile_check_directory);
17161 }
17162
17163 time_t proc_stop;
17164
17165 time (&proc_stop);
17166
17167 logfile_top_uint (proc_start);
17168 logfile_top_uint (proc_stop);
17169
17170 logfile_top_msg ("STOP");
17171
17172 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17173 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17174
17175 if (data.ocl) ocl_close (data.ocl);
17176
17177 if (data.devices_status == STATUS_ABORTED) return 2;
17178 if (data.devices_status == STATUS_QUIT) return 2;
17179 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17180 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17181 if (data.devices_status == STATUS_CRACKED) return 0;
17182
17183 return -1;
17184 }
Hashcat additions to support pwdhash