projects / hashcat.git / blob
? search:


ec1f24dd5f320d7184d38f0a92a4b72969d5189f
[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 136
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 13500,
304 125
305 };
306
307 /**
308 * types
309 */
310
311 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
312
313 /**
314 * globals
315 */
316
317 static unsigned int full01 = 0x01010101;
318 static unsigned int full80 = 0x80808080;
319
320 int SUPPRESS_OUTPUT = 0;
321
322 hc_thread_mutex_t mux_adl;
323 hc_thread_mutex_t mux_counter;
324 hc_thread_mutex_t mux_dispatcher;
325 hc_thread_mutex_t mux_display;
326
327 hc_global_data_t data;
328
329 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
330
331 const char *USAGE_MINI[] =
332 {
333 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
334 "",
335 "Try --help for more help.",
336 NULL
337 };
338
339 const char *USAGE_BIG[] =
340 {
341 "%s, advanced password recovery",
342 "",
343 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
344 "",
345 "=======",
346 "Options",
347 "=======",
348 "",
349 "* General:",
350 "",
351 " -m, --hash-type=NUM Hash-type, see references below",
352 " -a, --attack-mode=NUM Attack-mode, see references below",
353 " -V, --version Print version",
354 " -h, --help Print help",
355 " --quiet Suppress output",
356 "",
357 "* Misc:",
358 "",
359 " --hex-charset Assume charset is given in hex",
360 " --hex-salt Assume salt is given in hex",
361 " --hex-wordlist Assume words in wordlist is given in hex",
362 " --force Ignore warnings",
363 " --status Enable automatic update of the status-screen",
364 " --status-timer=NUM Seconds between status-screen update",
365 " --status-automat Display the status view in a machine readable format",
366 " --loopback Add new plains to induct directory",
367 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
368 "",
369 "* Markov:",
370 "",
371 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
372 " --markov-disable Disables markov-chains, emulates classic brute-force",
373 " --markov-classic Enables classic markov-chains, no per-position enhancement",
374 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
375 "",
376 "* Session:",
377 "",
378 " --runtime=NUM Abort session after NUM seconds of runtime",
379 " --session=STR Define specific session name",
380 " --restore Restore session from --session",
381 " --restore-disable Do not write restore file",
382 "",
383 "* Files:",
384 "",
385 " -o, --outfile=FILE Define outfile for recovered hash",
386 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
387 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
388 " --outfile-check-timer=NUM Seconds between outfile checks",
389 " -p, --separator=CHAR Separator char for hashlists and outfile",
390 " --show Show cracked passwords only",
391 " --left Show un-cracked passwords only",
392 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
393 " --remove Enable remove of hash once it is cracked",
394 " --remove-timer=NUM Update input hash file each NUM seconds",
395 " --potfile-disable Do not write potfile",
396 " --potfile-path Specific path to potfile",
397 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
398 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
399 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
400 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
401 " --logfile-disable Disable the logfile",
402 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
403 "",
404 "* Resources:",
405 "",
406 " -b, --benchmark Run benchmark",
407 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
408 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
409 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
410 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
411 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
412 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
413 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
414 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
415 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
416 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
417 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
418 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
419 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
420 #ifdef HAVE_HWMON
421 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
422 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
423 #ifdef HAVE_ADL
424 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
425 #endif
426 #endif
427 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
428 "",
429 "* Distributed:",
430 "",
431 " -s, --skip=NUM Skip number of words",
432 " -l, --limit=NUM Limit number of words",
433 " --keyspace Show keyspace base:mod values and quit",
434 "",
435 "* Rules:",
436 "",
437 " -j, --rule-left=RULE Single rule applied to each word from left dict",
438 " -k, --rule-right=RULE Single rule applied to each word from right dict",
439 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
440 " -g, --generate-rules=NUM Generate NUM random rules",
441 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
442 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
443 " --generate-rules-seed=NUM Force RNG seed to NUM",
444 "",
445 "* Custom charsets:",
446 "",
447 " -1, --custom-charset1=CS User-defined charsets",
448 " -2, --custom-charset2=CS Example:",
449 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
450 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
451 "",
452 "* Increment:",
453 "",
454 " -i, --increment Enable increment mode",
455 " --increment-min=NUM Start incrementing at NUM",
456 " --increment-max=NUM Stop incrementing at NUM",
457 "",
458 "==========",
459 "References",
460 "==========",
461 "",
462 "* Workload Profile:",
463 "",
464 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
465 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
466 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
467 "",
468 "* OpenCL device-types:",
469 "",
470 " 1 = CPU devices",
471 " 2 = GPU devices",
472 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
473 "",
474 "* Outfile Formats:",
475 "",
476 " 1 = hash[:salt]",
477 " 2 = plain",
478 " 3 = hash[:salt]:plain",
479 " 4 = hex_plain",
480 " 5 = hash[:salt]:hex_plain",
481 " 6 = plain:hex_plain",
482 " 7 = hash[:salt]:plain:hex_plain",
483 " 8 = crackpos",
484 " 9 = hash[:salt]:crackpos",
485 " 10 = plain:crackpos",
486 " 11 = hash[:salt]:plain:crackpos",
487 " 12 = hex_plain:crackpos",
488 " 13 = hash[:salt]:hex_plain:crackpos",
489 " 14 = plain:hex_plain:crackpos",
490 " 15 = hash[:salt]:plain:hex_plain:crackpos",
491 "",
492 "* Debug mode output formats (for hybrid mode only, by using rules):",
493 "",
494 " 1 = save finding rule",
495 " 2 = save original word",
496 " 3 = save original word and finding rule",
497 " 4 = save original word, finding rule and modified plain",
498 "",
499 "* Built-in charsets:",
500 "",
501 " ?l = abcdefghijklmnopqrstuvwxyz",
502 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
503 " ?d = 0123456789",
504 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
505 " ?a = ?l?u?d?s",
506 " ?b = 0x00 - 0xff",
507 "",
508 "* Attack modes:",
509 "",
510 " 0 = Straight",
511 " 1 = Combination",
512 " 3 = Brute-force",
513 " 6 = Hybrid dict + mask",
514 " 7 = Hybrid mask + dict",
515 "",
516 "* Hash types:",
517 "",
518 "[[ Roll-your-own: Raw Hashes ]]",
519 "",
520 " 900 = MD4",
521 " 0 = MD5",
522 " 5100 = Half MD5",
523 " 100 = SHA1",
524 " 10800 = SHA-384",
525 " 1400 = SHA-256",
526 " 1700 = SHA-512",
527 " 5000 = SHA-3(Keccak)",
528 " 10100 = SipHash",
529 " 6000 = RipeMD160",
530 " 6100 = Whirlpool",
531 " 6900 = GOST R 34.11-94",
532 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
533 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
534 "",
535 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
536 "",
537 " 10 = md5($pass.$salt)",
538 " 20 = md5($salt.$pass)",
539 " 30 = md5(unicode($pass).$salt)",
540 " 40 = md5($salt.unicode($pass))",
541 " 3800 = md5($salt.$pass.$salt)",
542 " 3710 = md5($salt.md5($pass))",
543 " 2600 = md5(md5($pass)",
544 " 4300 = md5(strtoupper(md5($pass)))",
545 " 4400 = md5(sha1($pass))",
546 " 110 = sha1($pass.$salt)",
547 " 120 = sha1($salt.$pass)",
548 " 130 = sha1(unicode($pass).$salt)",
549 " 140 = sha1($salt.unicode($pass))",
550 " 4500 = sha1(sha1($pass)",
551 " 4700 = sha1(md5($pass))",
552 " 4900 = sha1($salt.$pass.$salt)",
553 " 1410 = sha256($pass.$salt)",
554 " 1420 = sha256($salt.$pass)",
555 " 1430 = sha256(unicode($pass).$salt)",
556 " 1440 = sha256($salt.unicode($pass))",
557 " 1710 = sha512($pass.$salt)",
558 " 1720 = sha512($salt.$pass)",
559 " 1730 = sha512(unicode($pass).$salt)",
560 " 1740 = sha512($salt.unicode($pass))",
561 "",
562 "[[ Roll-your-own: Authenticated Hashes ]]",
563 "",
564 " 50 = HMAC-MD5 (key = $pass)",
565 " 60 = HMAC-MD5 (key = $salt)",
566 " 150 = HMAC-SHA1 (key = $pass)",
567 " 160 = HMAC-SHA1 (key = $salt)",
568 " 1450 = HMAC-SHA256 (key = $pass)",
569 " 1460 = HMAC-SHA256 (key = $salt)",
570 " 1750 = HMAC-SHA512 (key = $pass)",
571 " 1760 = HMAC-SHA512 (key = $salt)",
572 "",
573 "[[ Generic KDF ]]",
574 "",
575 " 400 = phpass",
576 " 8900 = scrypt",
577 " 11900 = PBKDF2-HMAC-MD5",
578 " 12000 = PBKDF2-HMAC-SHA1",
579 " 10900 = PBKDF2-HMAC-SHA256",
580 " 12100 = PBKDF2-HMAC-SHA512",
581 "",
582 "[[ Network protocols, Challenge-Response ]]",
583 "",
584 " 23 = Skype",
585 " 2500 = WPA/WPA2",
586 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
587 " 5300 = IKE-PSK MD5",
588 " 5400 = IKE-PSK SHA1",
589 " 5500 = NetNTLMv1",
590 " 5500 = NetNTLMv1 + ESS",
591 " 5600 = NetNTLMv2",
592 " 7300 = IPMI2 RAKP HMAC-SHA1",
593 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
594 " 8300 = DNSSEC (NSEC3)",
595 " 10200 = Cram MD5",
596 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
597 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
598 " 11400 = SIP digest authentication (MD5)",
599 " 13100 = Kerberos 5 TGS-REP etype 23",
600 "",
601 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
602 "",
603 " 121 = SMF (Simple Machines Forum)",
604 " 400 = phpBB3",
605 " 2611 = vBulletin < v3.8.5",
606 " 2711 = vBulletin > v3.8.5",
607 " 2811 = MyBB",
608 " 2811 = IPB (Invison Power Board)",
609 " 8400 = WBB3 (Woltlab Burning Board)",
610 " 11 = Joomla < 2.5.18",
611 " 400 = Joomla > 2.5.18",
612 " 400 = Wordpress",
613 " 2612 = PHPS",
614 " 7900 = Drupal7",
615 " 21 = osCommerce",
616 " 21 = xt:Commerce",
617 " 11000 = PrestaShop",
618 " 124 = Django (SHA-1)",
619 " 10000 = Django (PBKDF2-SHA256)",
620 " 3711 = Mediawiki B type",
621 " 7600 = Redmine",
622 "",
623 "[[ Database Server ]]",
624 "",
625 " 12 = PostgreSQL",
626 " 131 = MSSQL(2000)",
627 " 132 = MSSQL(2005)",
628 " 1731 = MSSQL(2012)",
629 " 1731 = MSSQL(2014)",
630 " 200 = MySQL323",
631 " 300 = MySQL4.1/MySQL5",
632 " 3100 = Oracle H: Type (Oracle 7+)",
633 " 112 = Oracle S: Type (Oracle 11+)",
634 " 12300 = Oracle T: Type (Oracle 12+)",
635 " 8000 = Sybase ASE",
636 "",
637 "[[ HTTP, SMTP, LDAP Server ]]",
638 "",
639 " 141 = EPiServer 6.x < v4",
640 " 1441 = EPiServer 6.x > v4",
641 " 1600 = Apache $apr1$",
642 " 12600 = ColdFusion 10+",
643 " 1421 = hMailServer",
644 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
645 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
646 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
647 "",
648 "[[ Checksums ]]",
649 "",
650 " 11500 = CRC32",
651 "",
652 "[[ Operating-Systems ]]",
653 "",
654 " 3000 = LM",
655 " 1000 = NTLM",
656 " 1100 = Domain Cached Credentials (DCC), MS Cache",
657 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
658 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
659 " 1500 = descrypt, DES(Unix), Traditional DES",
660 " 12400 = BSDiCrypt, Extended DES",
661 " 500 = md5crypt $1$, MD5(Unix)",
662 " 3200 = bcrypt $2*$, Blowfish(Unix)",
663 " 7400 = sha256crypt $5$, SHA256(Unix)",
664 " 1800 = sha512crypt $6$, SHA512(Unix)",
665 " 122 = OSX v10.4",
666 " 122 = OSX v10.5",
667 " 122 = OSX v10.6",
668 " 1722 = OSX v10.7",
669 " 7100 = OSX v10.8",
670 " 7100 = OSX v10.9",
671 " 7100 = OSX v10.10",
672 " 6300 = AIX {smd5}",
673 " 6700 = AIX {ssha1}",
674 " 6400 = AIX {ssha256}",
675 " 6500 = AIX {ssha512}",
676 " 2400 = Cisco-PIX",
677 " 2410 = Cisco-ASA",
678 " 500 = Cisco-IOS $1$",
679 " 5700 = Cisco-IOS $4$",
680 " 9200 = Cisco-IOS $8$",
681 " 9300 = Cisco-IOS $9$",
682 " 22 = Juniper Netscreen/SSG (ScreenOS)",
683 " 501 = Juniper IVE",
684 " 5800 = Android PIN",
685 " 8100 = Citrix Netscaler",
686 " 8500 = RACF",
687 " 7200 = GRUB 2",
688 " 9900 = Radmin2",
689 " 125 = ArubaOS",
690 "",
691 "[[ Enterprise Application Software (EAS) ]]",
692 "",
693 " 7700 = SAP CODVN B (BCODE)",
694 " 7800 = SAP CODVN F/G (PASSCODE)",
695 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
696 " 8600 = Lotus Notes/Domino 5",
697 " 8700 = Lotus Notes/Domino 6",
698 " 9100 = Lotus Notes/Domino 8",
699 " 133 = PeopleSoft",
700 " 13500 = PeopleSoft Token",
701 "",
702 "[[ Archives ]]",
703 "",
704 " 11600 = 7-Zip",
705 " 12500 = RAR3-hp",
706 " 13000 = RAR5",
707 " 13200 = AxCrypt",
708 " 13300 = AxCrypt in memory SHA1",
709 "",
710 "[[ Full-Disk encryptions (FDE) ]]",
711 "",
712 " 62XY = TrueCrypt 5.0+",
713 " X = 1 = PBKDF2-HMAC-RipeMD160",
714 " X = 2 = PBKDF2-HMAC-SHA512",
715 " X = 3 = PBKDF2-HMAC-Whirlpool",
716 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
717 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
718 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
719 " Y = 3 = XTS 1536 bit (Ciphers: All)",
720 " 8800 = Android FDE < v4.3",
721 " 12900 = Android FDE (Samsung DEK)",
722 " 12200 = eCryptfs",
723 "",
724 "[[ Documents ]]",
725 "",
726 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
727 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
728 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
729 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
730 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
731 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
732 " 9400 = MS Office 2007",
733 " 9500 = MS Office 2010",
734 " 9600 = MS Office 2013",
735 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
736 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
737 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
738 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
739 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
740 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
741 "",
742 "[[ Password Managers ]]",
743 "",
744 " 9000 = Password Safe v2",
745 " 5200 = Password Safe v3",
746 " 6800 = Lastpass",
747 " 6600 = 1Password, agilekeychain",
748 " 8200 = 1Password, cloudkeychain",
749 " 11300 = Bitcoin/Litecoin wallet.dat",
750 " 12700 = Blockchain, My Wallet",
751 " 13400 = Keepass 1 (AES/Twofish) and Keepass 2 (AES)",
752 "",
753 NULL
754 };
755
756 /**
757 * oclHashcat specific functions
758 */
759
760 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
761 {
762 int exec_pos = (int) device_param->exec_pos - last_num_entries;
763
764 if (exec_pos < 0) exec_pos += EXEC_CACHE;
765
766 double exec_ms_sum = 0;
767
768 int exec_ms_cnt = 0;
769
770 for (int i = 0; i < last_num_entries; i++)
771 {
772 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
773
774 if (exec_ms)
775 {
776 exec_ms_sum += exec_ms;
777
778 exec_ms_cnt++;
779 }
780 }
781
782 if (exec_ms_cnt == 0) return 0;
783
784 return exec_ms_sum / exec_ms_cnt;
785 }
786
787 void status_display_automat ()
788 {
789 FILE *out = stdout;
790
791 fprintf (out, "STATUS\t%u\t", data.devices_status);
792
793 /**
794 * speed new
795 */
796
797 fprintf (out, "SPEED\t");
798
799 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
800 {
801 hc_device_param_t *device_param = &data.devices_param[device_id];
802
803 if (device_param->skipped) continue;
804
805 u64 speed_cnt = 0;
806 float speed_ms = 0;
807
808 for (int i = 0; i < SPEED_CACHE; i++)
809 {
810 float rec_ms;
811
812 hc_timer_get (device_param->speed_rec[i], rec_ms);
813
814 if (rec_ms > SPEED_MAXAGE) continue;
815
816 speed_cnt += device_param->speed_cnt[i];
817 speed_ms += device_param->speed_ms[i];
818 }
819
820 speed_cnt /= SPEED_CACHE;
821 speed_ms /= SPEED_CACHE;
822
823 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
824 }
825
826 /**
827 * exec time
828 */
829
830 fprintf (out, "EXEC_RUNTIME\t");
831
832 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
833 {
834 hc_device_param_t *device_param = &data.devices_param[device_id];
835
836 if (device_param->skipped) continue;
837
838 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
839
840 fprintf (out, "%f\t", exec_ms_avg);
841 }
842
843 /**
844 * words_cur
845 */
846
847 u64 words_cur = get_lowest_words_done ();
848
849 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
850
851 /**
852 * counter
853 */
854
855 u64 progress_total = data.words_cnt * data.salts_cnt;
856
857 u64 all_done = 0;
858 u64 all_rejected = 0;
859 u64 all_restored = 0;
860
861 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
862 {
863 all_done += data.words_progress_done[salt_pos];
864 all_rejected += data.words_progress_rejected[salt_pos];
865 all_restored += data.words_progress_restored[salt_pos];
866 }
867
868 u64 progress_cur = all_restored + all_done + all_rejected;
869 u64 progress_end = progress_total;
870
871 u64 progress_skip = 0;
872
873 if (data.skip)
874 {
875 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
876
877 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
878 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
879 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
880 }
881
882 if (data.limit)
883 {
884 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
885
886 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
887 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
888 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
889 }
890
891 u64 progress_cur_relative_skip = progress_cur - progress_skip;
892 u64 progress_end_relative_skip = progress_end - progress_skip;
893
894 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
895
896 /**
897 * cracks
898 */
899
900 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
901 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
902
903 /**
904 * temperature
905 */
906
907 #ifdef HAVE_HWMON
908 if (data.gpu_temp_disable == 0)
909 {
910 fprintf (out, "TEMP\t");
911
912 hc_thread_mutex_lock (mux_adl);
913
914 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
915 {
916 hc_device_param_t *device_param = &data.devices_param[device_id];
917
918 if (device_param->skipped) continue;
919
920 int temp = hm_get_temperature_with_device_id (device_id);
921
922 fprintf (out, "%d\t", temp);
923 }
924
925 hc_thread_mutex_unlock (mux_adl);
926 }
927 #endif // HAVE_HWMON
928
929 /**
930 * flush
931 */
932
933 #ifdef _WIN
934 fputc ('\r', out);
935 fputc ('\n', out);
936 #endif
937
938 #ifdef _POSIX
939 fputc ('\n', out);
940 #endif
941
942 fflush (out);
943 }
944
945 void status_display ()
946 {
947 if (data.devices_status == STATUS_INIT) return;
948 if (data.devices_status == STATUS_STARTING) return;
949 if (data.devices_status == STATUS_BYPASS) return;
950
951 if (data.status_automat == 1)
952 {
953 status_display_automat ();
954
955 return;
956 }
957
958 char tmp_buf[1000] = { 0 };
959
960 uint tmp_len = 0;
961
962 log_info ("Session.Name...: %s", data.session);
963
964 char *status_type = strstatus (data.devices_status);
965
966 uint hash_mode = data.hash_mode;
967
968 char *hash_type = strhashtype (hash_mode); // not a bug
969
970 log_info ("Status.........: %s", status_type);
971
972 /**
973 * show rules
974 */
975
976 if (data.rp_files_cnt)
977 {
978 uint i;
979
980 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
981 {
982 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
983 }
984
985 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
986
987 log_info ("Rules.Type.....: %s", tmp_buf);
988
989 tmp_len = 0;
990 }
991
992 if (data.rp_gen)
993 {
994 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
995
996 if (data.rp_gen_seed)
997 {
998 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
999 }
1000 }
1001
1002 /**
1003 * show input
1004 */
1005
1006 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1007 {
1008 if (data.wordlist_mode == WL_MODE_FILE)
1009 {
1010 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1011 }
1012 else if (data.wordlist_mode == WL_MODE_STDIN)
1013 {
1014 log_info ("Input.Mode.....: Pipe");
1015 }
1016 }
1017 else if (data.attack_mode == ATTACK_MODE_COMBI)
1018 {
1019 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1020 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1021 }
1022 else if (data.attack_mode == ATTACK_MODE_BF)
1023 {
1024 char *mask = data.mask;
1025
1026 if (mask != NULL)
1027 {
1028 uint mask_len = data.css_cnt;
1029
1030 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1031
1032 if (mask_len > 0)
1033 {
1034 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1035 {
1036 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1037 {
1038 mask_len -= data.salts_buf[0].salt_len;
1039 }
1040 }
1041
1042 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1043
1044 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1045 }
1046
1047 if (data.maskcnt > 1)
1048 {
1049 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1050
1051 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1052 }
1053
1054 log_info ("Input.Mode.....: %s", tmp_buf);
1055 }
1056
1057 tmp_len = 0;
1058 }
1059 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1060 {
1061 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1062 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1063 }
1064 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1065 {
1066 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1067 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1068 }
1069
1070 if (data.digests_cnt == 1)
1071 {
1072 if (data.hash_mode == 2500)
1073 {
1074 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1075
1076 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1077 (char *) data.salts_buf[0].salt_buf,
1078 wpa->orig_mac1[0],
1079 wpa->orig_mac1[1],
1080 wpa->orig_mac1[2],
1081 wpa->orig_mac1[3],
1082 wpa->orig_mac1[4],
1083 wpa->orig_mac1[5],
1084 wpa->orig_mac2[0],
1085 wpa->orig_mac2[1],
1086 wpa->orig_mac2[2],
1087 wpa->orig_mac2[3],
1088 wpa->orig_mac2[4],
1089 wpa->orig_mac2[5]);
1090 }
1091 else if (data.hash_mode == 5200)
1092 {
1093 log_info ("Hash.Target....: File (%s)", data.hashfile);
1094 }
1095 else if (data.hash_mode == 9000)
1096 {
1097 log_info ("Hash.Target....: File (%s)", data.hashfile);
1098 }
1099 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1100 {
1101 log_info ("Hash.Target....: File (%s)", data.hashfile);
1102 }
1103 else
1104 {
1105 char out_buf[HCBUFSIZ] = { 0 };
1106
1107 ascii_digest (out_buf, 0, 0);
1108
1109 // limit length
1110 if (strlen (out_buf) > 40)
1111 {
1112 out_buf[41] = '.';
1113 out_buf[42] = '.';
1114 out_buf[43] = '.';
1115 out_buf[44] = 0;
1116 }
1117
1118 log_info ("Hash.Target....: %s", out_buf);
1119 }
1120 }
1121 else
1122 {
1123 if (data.hash_mode == 3000)
1124 {
1125 char out_buf1[32] = { 0 };
1126 char out_buf2[32] = { 0 };
1127
1128 ascii_digest (out_buf1, 0, 0);
1129 ascii_digest (out_buf2, 0, 1);
1130
1131 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1132 }
1133 else
1134 {
1135 log_info ("Hash.Target....: File (%s)", data.hashfile);
1136 }
1137 }
1138
1139 log_info ("Hash.Type......: %s", hash_type);
1140
1141 /**
1142 * speed new
1143 */
1144
1145 u64 speed_cnt[DEVICES_MAX] = { 0 };
1146 float speed_ms[DEVICES_MAX] = { 0 };
1147
1148 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1149 {
1150 hc_device_param_t *device_param = &data.devices_param[device_id];
1151
1152 if (device_param->skipped) continue;
1153
1154 // we need to clear values (set to 0) because in case the device does
1155 // not get new candidates it idles around but speed display would
1156 // show it as working.
1157 // if we instantly set it to 0 after reading it happens that the
1158 // speed can be shown as zero if the users refreshes too fast.
1159 // therefore, we add a timestamp when a stat was recorded and if its
1160 // too old we will not use it
1161
1162 speed_cnt[device_id] = 0;
1163 speed_ms[device_id] = 0;
1164
1165 for (int i = 0; i < SPEED_CACHE; i++)
1166 {
1167 float rec_ms;
1168
1169 hc_timer_get (device_param->speed_rec[i], rec_ms);
1170
1171 if (rec_ms > SPEED_MAXAGE) continue;
1172
1173 speed_cnt[device_id] += device_param->speed_cnt[i];
1174 speed_ms[device_id] += device_param->speed_ms[i];
1175 }
1176
1177 speed_cnt[device_id] /= SPEED_CACHE;
1178 speed_ms[device_id] /= SPEED_CACHE;
1179 }
1180
1181 float hashes_all_ms = 0;
1182
1183 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1184
1185 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1186 {
1187 hc_device_param_t *device_param = &data.devices_param[device_id];
1188
1189 if (device_param->skipped) continue;
1190
1191 hashes_dev_ms[device_id] = 0;
1192
1193 if (speed_ms[device_id])
1194 {
1195 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1196
1197 hashes_all_ms += hashes_dev_ms[device_id];
1198 }
1199 }
1200
1201 /**
1202 * exec time
1203 */
1204
1205 double exec_all_ms[DEVICES_MAX] = { 0 };
1206
1207 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1208 {
1209 hc_device_param_t *device_param = &data.devices_param[device_id];
1210
1211 if (device_param->skipped) continue;
1212
1213 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1214
1215 exec_all_ms[device_id] = exec_ms_avg;
1216 }
1217
1218 /**
1219 * timers
1220 */
1221
1222 float ms_running = 0;
1223
1224 hc_timer_get (data.timer_running, ms_running);
1225
1226 float ms_paused = data.ms_paused;
1227
1228 if (data.devices_status == STATUS_PAUSED)
1229 {
1230 float ms_paused_tmp = 0;
1231
1232 hc_timer_get (data.timer_paused, ms_paused_tmp);
1233
1234 ms_paused += ms_paused_tmp;
1235 }
1236
1237 #ifdef WIN
1238
1239 __time64_t sec_run = ms_running / 1000;
1240
1241 #else
1242
1243 time_t sec_run = ms_running / 1000;
1244
1245 #endif
1246
1247 if (sec_run)
1248 {
1249 char display_run[32] = { 0 };
1250
1251 struct tm tm_run;
1252
1253 struct tm *tmp = NULL;
1254
1255 #ifdef WIN
1256
1257 tmp = _gmtime64 (&sec_run);
1258
1259 #else
1260
1261 tmp = gmtime (&sec_run);
1262
1263 #endif
1264
1265 if (tmp != NULL)
1266 {
1267 memset (&tm_run, 0, sizeof (tm_run));
1268
1269 memcpy (&tm_run, tmp, sizeof (tm_run));
1270
1271 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1272
1273 char *start = ctime (&data.proc_start);
1274
1275 size_t start_len = strlen (start);
1276
1277 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1278 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1279
1280 log_info ("Time.Started...: %s (%s)", start, display_run);
1281 }
1282 }
1283 else
1284 {
1285 log_info ("Time.Started...: 0 secs");
1286 }
1287
1288 /**
1289 * counters
1290 */
1291
1292 u64 progress_total = data.words_cnt * data.salts_cnt;
1293
1294 u64 all_done = 0;
1295 u64 all_rejected = 0;
1296 u64 all_restored = 0;
1297
1298 u64 progress_noneed = 0;
1299
1300 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1301 {
1302 all_done += data.words_progress_done[salt_pos];
1303 all_rejected += data.words_progress_rejected[salt_pos];
1304 all_restored += data.words_progress_restored[salt_pos];
1305
1306 // Important for ETA only
1307
1308 if (data.salts_shown[salt_pos] == 1)
1309 {
1310 const u64 all = data.words_progress_done[salt_pos]
1311 + data.words_progress_rejected[salt_pos]
1312 + data.words_progress_restored[salt_pos];
1313
1314 const u64 left = data.words_cnt - all;
1315
1316 progress_noneed += left;
1317 }
1318 }
1319
1320 u64 progress_cur = all_restored + all_done + all_rejected;
1321 u64 progress_end = progress_total;
1322
1323 u64 progress_skip = 0;
1324
1325 if (data.skip)
1326 {
1327 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1328
1329 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1330 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1331 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1332 }
1333
1334 if (data.limit)
1335 {
1336 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1337
1338 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1339 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1340 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1341 }
1342
1343 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1344 u64 progress_end_relative_skip = progress_end - progress_skip;
1345
1346 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1347 {
1348 if (data.devices_status != STATUS_CRACKED)
1349 {
1350 #ifdef WIN
1351 __time64_t sec_etc = 0;
1352 #else
1353 time_t sec_etc = 0;
1354 #endif
1355
1356 if (hashes_all_ms)
1357 {
1358 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1359
1360 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1361
1362 sec_etc = ms_left / 1000;
1363 }
1364
1365 if (sec_etc == 0)
1366 {
1367 //log_info ("Time.Estimated.: 0 secs");
1368 }
1369 else if ((u64) sec_etc > ETC_MAX)
1370 {
1371 log_info ("Time.Estimated.: > 10 Years");
1372 }
1373 else
1374 {
1375 char display_etc[32] = { 0 };
1376
1377 struct tm tm_etc;
1378
1379 struct tm *tmp = NULL;
1380
1381 #ifdef WIN
1382
1383 tmp = _gmtime64 (&sec_etc);
1384
1385 #else
1386
1387 tmp = gmtime (&sec_etc);
1388
1389 #endif
1390
1391 if (tmp != NULL)
1392 {
1393 memset (&tm_etc, 0, sizeof (tm_etc));
1394
1395 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1396
1397 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1398
1399 time_t now;
1400
1401 time (&now);
1402
1403 now += sec_etc;
1404
1405 char *etc = ctime (&now);
1406
1407 size_t etc_len = strlen (etc);
1408
1409 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1410 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1411
1412 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1413 }
1414 }
1415 }
1416 }
1417
1418 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1419 {
1420 hc_device_param_t *device_param = &data.devices_param[device_id];
1421
1422 if (device_param->skipped) continue;
1423
1424 char display_dev_cur[16] = { 0 };
1425
1426 strncpy (display_dev_cur, "0.00", 4);
1427
1428 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1429
1430 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1431 }
1432
1433 char display_all_cur[16] = { 0 };
1434
1435 strncpy (display_all_cur, "0.00", 4);
1436
1437 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1438
1439 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1440
1441 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1442 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1443
1444 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);
1445
1446 // crack-per-time
1447
1448 if (data.digests_cnt > 100)
1449 {
1450 time_t now = time (NULL);
1451
1452 int cpt_cur_min = 0;
1453 int cpt_cur_hour = 0;
1454 int cpt_cur_day = 0;
1455
1456 for (int i = 0; i < CPT_BUF; i++)
1457 {
1458 const uint cracked = data.cpt_buf[i].cracked;
1459 const time_t timestamp = data.cpt_buf[i].timestamp;
1460
1461 if ((timestamp + 60) > now)
1462 {
1463 cpt_cur_min += cracked;
1464 }
1465
1466 if ((timestamp + 3600) > now)
1467 {
1468 cpt_cur_hour += cracked;
1469 }
1470
1471 if ((timestamp + 86400) > now)
1472 {
1473 cpt_cur_day += cracked;
1474 }
1475 }
1476
1477 float ms_real = ms_running - ms_paused;
1478
1479 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1480 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1481 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1482
1483 if ((data.cpt_start + 86400) < now)
1484 {
1485 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1486 cpt_cur_min,
1487 cpt_cur_hour,
1488 cpt_cur_day,
1489 cpt_avg_min,
1490 cpt_avg_hour,
1491 cpt_avg_day);
1492 }
1493 else if ((data.cpt_start + 3600) < now)
1494 {
1495 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1496 cpt_cur_min,
1497 cpt_cur_hour,
1498 cpt_avg_min,
1499 cpt_avg_hour,
1500 cpt_avg_day);
1501 }
1502 else if ((data.cpt_start + 60) < now)
1503 {
1504 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1505 cpt_cur_min,
1506 cpt_avg_min,
1507 cpt_avg_hour,
1508 cpt_avg_day);
1509 }
1510 else
1511 {
1512 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1513 cpt_avg_min,
1514 cpt_avg_hour,
1515 cpt_avg_day);
1516 }
1517 }
1518
1519 // Restore point
1520
1521 u64 restore_point = get_lowest_words_done ();
1522
1523 u64 restore_total = data.words_base;
1524
1525 float percent_restore = 0;
1526
1527 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1528
1529 if (progress_end_relative_skip)
1530 {
1531 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1532 {
1533 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1534 float percent_rejected = 0.0;
1535
1536 if (progress_cur)
1537 {
1538 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1539 }
1540
1541 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);
1542 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1543
1544 if (data.restore_disable == 0)
1545 {
1546 if (percent_finished != 1)
1547 {
1548 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1549 }
1550 }
1551 }
1552 }
1553 else
1554 {
1555 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1556 {
1557 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1558 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1559
1560 if (data.restore_disable == 0)
1561 {
1562 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1563 }
1564 }
1565 else
1566 {
1567 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1568 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1569
1570 // --restore not allowed if stdin is used -- really? why?
1571
1572 //if (data.restore_disable == 0)
1573 //{
1574 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1575 //}
1576 }
1577 }
1578
1579 #ifdef HAVE_HWMON
1580 if (data.gpu_temp_disable == 0)
1581 {
1582 hc_thread_mutex_lock (mux_adl);
1583
1584 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1585 {
1586 hc_device_param_t *device_param = &data.devices_param[device_id];
1587
1588 if (device_param->skipped) continue;
1589
1590 #define HM_STR_BUF_SIZE 255
1591
1592 if (data.hm_device[device_id].fan_supported == 1)
1593 {
1594 char utilization[HM_STR_BUF_SIZE] = { 0 };
1595 char temperature[HM_STR_BUF_SIZE] = { 0 };
1596 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1597
1598 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1599 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1600
1601 if (device_param->vendor_id == VENDOR_ID_AMD)
1602 {
1603 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1604 }
1605 else if (device_param->vendor_id == VENDOR_ID_NV)
1606 {
1607 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1608 }
1609
1610 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1611 }
1612 else
1613 {
1614 char utilization[HM_STR_BUF_SIZE] = { 0 };
1615 char temperature[HM_STR_BUF_SIZE] = { 0 };
1616
1617 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1618 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1619
1620 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1621 }
1622 }
1623
1624 hc_thread_mutex_unlock (mux_adl);
1625 }
1626 #endif // HAVE_HWMON
1627 }
1628
1629 static void status_benchmark ()
1630 {
1631 if (data.devices_status == STATUS_INIT) return;
1632 if (data.devices_status == STATUS_STARTING) return;
1633
1634 if (data.words_cnt == 0) return;
1635
1636 u64 speed_cnt[DEVICES_MAX] = { 0 };
1637 float speed_ms[DEVICES_MAX] = { 0 };
1638
1639 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1640 {
1641 hc_device_param_t *device_param = &data.devices_param[device_id];
1642
1643 if (device_param->skipped) continue;
1644
1645 speed_cnt[device_id] = 0;
1646 speed_ms[device_id] = 0;
1647
1648 for (int i = 0; i < SPEED_CACHE; i++)
1649 {
1650 speed_cnt[device_id] += device_param->speed_cnt[i];
1651 speed_ms[device_id] += device_param->speed_ms[i];
1652 }
1653
1654 speed_cnt[device_id] /= SPEED_CACHE;
1655 speed_ms[device_id] /= SPEED_CACHE;
1656 }
1657
1658 float hashes_all_ms = 0;
1659
1660 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1661
1662 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1663 {
1664 hc_device_param_t *device_param = &data.devices_param[device_id];
1665
1666 if (device_param->skipped) continue;
1667
1668 hashes_dev_ms[device_id] = 0;
1669
1670 if (speed_ms[device_id])
1671 {
1672 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1673
1674 hashes_all_ms += hashes_dev_ms[device_id];
1675 }
1676 }
1677
1678 /**
1679 * exec time
1680 */
1681
1682 double exec_all_ms[DEVICES_MAX] = { 0 };
1683
1684 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1685 {
1686 hc_device_param_t *device_param = &data.devices_param[device_id];
1687
1688 if (device_param->skipped) continue;
1689
1690 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1691
1692 exec_all_ms[device_id] = exec_ms_avg;
1693 }
1694
1695 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1696 {
1697 hc_device_param_t *device_param = &data.devices_param[device_id];
1698
1699 if (device_param->skipped) continue;
1700
1701 char display_dev_cur[16] = { 0 };
1702
1703 strncpy (display_dev_cur, "0.00", 4);
1704
1705 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1706
1707 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1708 }
1709
1710 char display_all_cur[16] = { 0 };
1711
1712 strncpy (display_all_cur, "0.00", 4);
1713
1714 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1715
1716 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1717 }
1718
1719 /**
1720 * oclHashcat -only- functions
1721 */
1722
1723 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1724 {
1725 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1726 {
1727 if (attack_kern == ATTACK_KERN_STRAIGHT)
1728 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1729 else if (attack_kern == ATTACK_KERN_COMBI)
1730 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1731 else if (attack_kern == ATTACK_KERN_BF)
1732 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1733 }
1734 else
1735 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1736 }
1737
1738 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)
1739 {
1740 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1741 {
1742 if (attack_kern == ATTACK_KERN_STRAIGHT)
1743 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1744 else if (attack_kern == ATTACK_KERN_COMBI)
1745 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1746 else if (attack_kern == ATTACK_KERN_BF)
1747 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1748 }
1749 else
1750 {
1751 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1752 }
1753 }
1754
1755 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1756 {
1757 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1758 {
1759 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1760 }
1761 else
1762 {
1763 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1764 }
1765 }
1766
1767 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)
1768 {
1769 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1770 {
1771 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1772 }
1773 else
1774 {
1775 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1776 }
1777 }
1778
1779 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1780 {
1781 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1782 }
1783
1784 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1785 {
1786 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1787 }
1788
1789 static uint convert_from_hex (char *line_buf, const uint line_len)
1790 {
1791 if (line_len & 1) return (line_len); // not in hex
1792
1793 if (data.hex_wordlist == 1)
1794 {
1795 uint i;
1796 uint j;
1797
1798 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1799 {
1800 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1801 }
1802
1803 memset (line_buf + i, 0, line_len - i);
1804
1805 return (i);
1806 }
1807 else if (line_len >= 6) // $HEX[] = 6
1808 {
1809 if (line_buf[0] != '$') return (line_len);
1810 if (line_buf[1] != 'H') return (line_len);
1811 if (line_buf[2] != 'E') return (line_len);
1812 if (line_buf[3] != 'X') return (line_len);
1813 if (line_buf[4] != '[') return (line_len);
1814 if (line_buf[line_len - 1] != ']') return (line_len);
1815
1816 uint i;
1817 uint j;
1818
1819 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1820 {
1821 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1822 }
1823
1824 memset (line_buf + i, 0, line_len - i);
1825
1826 return (i);
1827 }
1828
1829 return (line_len);
1830 }
1831
1832 static void clear_prompt ()
1833 {
1834 fputc ('\r', stdout);
1835
1836 for (size_t i = 0; i < strlen (PROMPT); i++)
1837 {
1838 fputc (' ', stdout);
1839 }
1840
1841 fputc ('\r', stdout);
1842
1843 fflush (stdout);
1844 }
1845
1846 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1847 {
1848 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);
1849 }
1850
1851 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1852 {
1853 char *outfile = data.outfile;
1854 uint quiet = data.quiet;
1855 FILE *pot_fp = data.pot_fp;
1856 uint loopback = data.loopback;
1857 uint debug_mode = data.debug_mode;
1858 char *debug_file = data.debug_file;
1859
1860 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1861 int debug_rule_len = 0; // -1 error
1862 uint debug_plain_len = 0;
1863
1864 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1865
1866 // hash
1867
1868 char out_buf[HCBUFSIZ] = { 0 };
1869
1870 ascii_digest (out_buf, salt_pos, digest_pos);
1871
1872 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1873
1874 // plain
1875
1876 plain_t plain;
1877
1878 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);
1879
1880 uint gidvid = plain.gidvid;
1881 uint il_pos = plain.il_pos;
1882
1883 u64 crackpos = device_param->words_off;
1884
1885 uint plain_buf[16] = { 0 };
1886
1887 u8 *plain_ptr = (u8 *) plain_buf;
1888 unsigned int plain_len = 0;
1889
1890 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1891 {
1892 u64 gidd = gidvid;
1893 u64 gidm = 0;
1894
1895 pw_t pw;
1896
1897 gidd_to_pw_t (device_param, gidd, &pw);
1898
1899 for (int i = 0, j = gidm; i < 16; i++, j++)
1900 {
1901 plain_buf[i] = pw.i[j];
1902 }
1903
1904 plain_len = pw.pw_len;
1905
1906 const uint off = device_param->innerloop_pos + il_pos;
1907
1908 if (debug_mode > 0)
1909 {
1910 debug_rule_len = 0;
1911
1912 // save rule
1913 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1914 {
1915 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1916
1917 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1918 }
1919
1920 // save plain
1921 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1922 {
1923 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1924
1925 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1926
1927 debug_plain_len = plain_len;
1928 }
1929 }
1930
1931 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1932
1933 crackpos += gidvid;
1934 crackpos *= data.kernel_rules_cnt;
1935 crackpos += device_param->innerloop_pos + il_pos;
1936
1937 if (plain_len > data.pw_max) plain_len = data.pw_max;
1938 }
1939 else if (data.attack_mode == ATTACK_MODE_COMBI)
1940 {
1941 u64 gidd = gidvid;
1942 u64 gidm = 0;
1943
1944 pw_t pw;
1945
1946 gidd_to_pw_t (device_param, gidd, &pw);
1947
1948 for (int i = 0, j = gidm; i < 16; i++, j++)
1949 {
1950 plain_buf[i] = pw.i[j];
1951 }
1952
1953 plain_len = pw.pw_len;
1954
1955 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1956 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1957
1958 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1959 {
1960 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1961 }
1962 else
1963 {
1964 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1965
1966 memcpy (plain_ptr, comb_buf, comb_len);
1967 }
1968
1969 plain_len += comb_len;
1970
1971 crackpos += gidvid;
1972 crackpos *= data.combs_cnt;
1973 crackpos += device_param->innerloop_pos + il_pos;
1974
1975 if (data.pw_max != PW_DICTMAX1)
1976 {
1977 if (plain_len > data.pw_max) plain_len = data.pw_max;
1978 }
1979 }
1980 else if (data.attack_mode == ATTACK_MODE_BF)
1981 {
1982 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1983 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1984
1985 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1986 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1987
1988 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1989 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1990
1991 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1992 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1993
1994 plain_len = data.css_cnt;
1995
1996 crackpos += gidvid;
1997 crackpos *= data.bfs_cnt;
1998 crackpos += device_param->innerloop_pos + il_pos;
1999 }
2000 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2001 {
2002 u64 gidd = gidvid;
2003 u64 gidm = 0;
2004
2005 pw_t pw;
2006
2007 gidd_to_pw_t (device_param, gidd, &pw);
2008
2009 for (int i = 0, j = gidm; i < 16; i++, j++)
2010 {
2011 plain_buf[i] = pw.i[j];
2012 }
2013
2014 plain_len = pw.pw_len;
2015
2016 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2017
2018 uint start = 0;
2019 uint stop = device_param->kernel_params_mp_buf32[4];
2020
2021 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2022
2023 plain_len += start + stop;
2024
2025 crackpos += gidvid;
2026 crackpos *= data.combs_cnt;
2027 crackpos += device_param->innerloop_pos + il_pos;
2028
2029 if (data.pw_max != PW_DICTMAX1)
2030 {
2031 if (plain_len > data.pw_max) plain_len = data.pw_max;
2032 }
2033 }
2034 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2035 {
2036 u64 gidd = gidvid;
2037 u64 gidm = 0;
2038
2039 pw_t pw;
2040
2041 gidd_to_pw_t (device_param, gidd, &pw);
2042
2043 for (int i = 0, j = gidm; i < 16; i++, j++)
2044 {
2045 plain_buf[i] = pw.i[j];
2046 }
2047
2048 plain_len = pw.pw_len;
2049
2050 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2051
2052 uint start = 0;
2053 uint stop = device_param->kernel_params_mp_buf32[4];
2054
2055 memmove (plain_ptr + stop, plain_ptr, plain_len);
2056
2057 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2058
2059 plain_len += start + stop;
2060
2061 crackpos += gidvid;
2062 crackpos *= data.combs_cnt;
2063 crackpos += device_param->innerloop_pos + il_pos;
2064
2065 if (data.pw_max != PW_DICTMAX1)
2066 {
2067 if (plain_len > data.pw_max) plain_len = data.pw_max;
2068 }
2069 }
2070
2071 if (data.attack_mode == ATTACK_MODE_BF)
2072 {
2073 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2074 {
2075 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2076 {
2077 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2078 {
2079 plain_len = plain_len - data.salts_buf[0].salt_len;
2080 }
2081 }
2082
2083 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2084 {
2085 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2086 {
2087 plain_ptr[j] = plain_ptr[i];
2088 }
2089
2090 plain_len = plain_len / 2;
2091 }
2092 }
2093 }
2094
2095 // if enabled, update also the potfile
2096
2097 if (pot_fp)
2098 {
2099 lock_file (pot_fp);
2100
2101 fprintf (pot_fp, "%s:", out_buf);
2102
2103 format_plain (pot_fp, plain_ptr, plain_len, 1);
2104
2105 fputc ('\n', pot_fp);
2106
2107 fflush (pot_fp);
2108
2109 unlock_file (pot_fp);
2110 }
2111
2112 // outfile
2113
2114 FILE *out_fp = NULL;
2115
2116 if (outfile != NULL)
2117 {
2118 if ((out_fp = fopen (outfile, "ab")) == NULL)
2119 {
2120 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2121
2122 out_fp = stdout;
2123 }
2124 lock_file (out_fp);
2125 }
2126 else
2127 {
2128 out_fp = stdout;
2129
2130 if (quiet == 0) clear_prompt ();
2131 }
2132
2133 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2134
2135 if (outfile != NULL)
2136 {
2137 if (out_fp != stdout)
2138 {
2139 fclose (out_fp);
2140 }
2141 }
2142 else
2143 {
2144 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2145 {
2146 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2147 {
2148 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2149 if (quiet == 0) fflush (stdout);
2150 }
2151 }
2152 }
2153
2154 // loopback
2155
2156 if (loopback)
2157 {
2158 char *loopback_file = data.loopback_file;
2159
2160 FILE *fb_fp = NULL;
2161
2162 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2163 {
2164 lock_file (fb_fp);
2165
2166 format_plain (fb_fp, plain_ptr, plain_len, 1);
2167
2168 fputc ('\n', fb_fp);
2169
2170 fclose (fb_fp);
2171 }
2172 }
2173
2174 // (rule) debug mode
2175
2176 // the next check implies that:
2177 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2178 // - debug_mode > 0
2179
2180 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2181 {
2182 if (debug_rule_len < 0) debug_rule_len = 0;
2183
2184 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2185
2186 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2187
2188 if ((quiet == 0) && (debug_file == NULL))
2189 {
2190 fprintf (stdout, "%s", PROMPT);
2191 fflush (stdout);
2192 }
2193 }
2194 }
2195
2196 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2197 {
2198 salt_t *salt_buf = &data.salts_buf[salt_pos];
2199
2200 int found = 0;
2201
2202 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);
2203
2204 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2205
2206 if (found == 1)
2207 {
2208 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2209
2210 log_info_nn ("");
2211
2212 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);
2213
2214 uint cpt_cracked = 0;
2215
2216 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2217 {
2218 uint idx = salt_buf->digests_offset + digest_pos;
2219
2220 if (data.digests_shown_tmp[idx] == 0) continue;
2221
2222 if (data.digests_shown[idx] == 1) continue;
2223
2224 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2225 {
2226 data.digests_shown[idx] = 1;
2227
2228 data.digests_done++;
2229
2230 cpt_cracked++;
2231
2232 salt_buf->digests_done++;
2233
2234 if (salt_buf->digests_done == salt_buf->digests_cnt)
2235 {
2236 data.salts_shown[salt_pos] = 1;
2237
2238 data.salts_done++;
2239 }
2240 }
2241
2242 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2243
2244 check_hash (device_param, salt_pos, digest_pos);
2245 }
2246
2247 if (cpt_cracked > 0)
2248 {
2249 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2250 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2251
2252 data.cpt_pos++;
2253
2254 data.cpt_total += cpt_cracked;
2255
2256 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2257 }
2258
2259 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2260 {
2261 // we need to reset cracked state on the device
2262 // otherwise host thinks again and again the hash was cracked
2263 // and returns invalid password each time
2264
2265 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2266
2267 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);
2268 }
2269
2270 memset (device_param->result, 0, device_param->size_results);
2271
2272 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);
2273 }
2274 }
2275
2276 static void save_hash ()
2277 {
2278 char *hashfile = data.hashfile;
2279
2280 char new_hashfile[256] = { 0 };
2281 char old_hashfile[256] = { 0 };
2282
2283 snprintf (new_hashfile, 255, "%s.new", hashfile);
2284 snprintf (old_hashfile, 255, "%s.old", hashfile);
2285
2286 unlink (new_hashfile);
2287
2288 char separator = data.separator;
2289
2290 FILE *fp = fopen (new_hashfile, "wb");
2291
2292 if (fp == NULL)
2293 {
2294 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2295
2296 exit (-1);
2297 }
2298
2299 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2300 {
2301 if (data.salts_shown[salt_pos] == 1) continue;
2302
2303 salt_t *salt_buf = &data.salts_buf[salt_pos];
2304
2305 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2306 {
2307 uint idx = salt_buf->digests_offset + digest_pos;
2308
2309 if (data.digests_shown[idx] == 1) continue;
2310
2311 if (data.hash_mode != 2500)
2312 {
2313 char out_buf[HCBUFSIZ] = { 0 };
2314
2315 if (data.username == 1)
2316 {
2317 user_t *user = data.hash_info[idx]->user;
2318
2319 uint i;
2320
2321 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2322
2323 fputc (separator, fp);
2324 }
2325
2326 ascii_digest (out_buf, salt_pos, digest_pos);
2327
2328 fputs (out_buf, fp);
2329
2330 log_out (fp, "");
2331 }
2332 else
2333 {
2334 hccap_t hccap;
2335
2336 to_hccap_t (&hccap, salt_pos, digest_pos);
2337
2338 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2339 }
2340 }
2341 }
2342
2343 fflush (fp);
2344
2345 fclose (fp);
2346
2347 unlink (old_hashfile);
2348
2349 if (rename (hashfile, old_hashfile) != 0)
2350 {
2351 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2352
2353 exit (-1);
2354 }
2355
2356 unlink (hashfile);
2357
2358 if (rename (new_hashfile, hashfile) != 0)
2359 {
2360 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2361
2362 exit (-1);
2363 }
2364
2365 unlink (old_hashfile);
2366 }
2367
2368 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2369 {
2370 // function called only in case kernel_power_all > words_left
2371
2372 float kernel_power_div = (float) (total_left) / kernel_power_all;
2373
2374 kernel_power_div += kernel_power_div / 100;
2375
2376 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2377
2378 while (kernel_power_new < total_left)
2379 {
2380 kernel_power_div += kernel_power_div / 100;
2381
2382 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2383 }
2384
2385 if (data.quiet == 0)
2386 {
2387 clear_prompt ();
2388
2389 log_info ("");
2390
2391 log_info ("INFO: approaching final keyspace, workload adjusted");
2392
2393 log_info ("");
2394
2395 fprintf (stdout, "%s", PROMPT);
2396
2397 fflush (stdout);
2398 }
2399
2400 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2401
2402 return kernel_power_div;
2403 }
2404
2405 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2406 {
2407 uint num_elements = num;
2408
2409 device_param->kernel_params_buf32[30] = data.combs_mode;
2410 device_param->kernel_params_buf32[31] = num;
2411
2412 uint kernel_threads = device_param->kernel_threads;
2413
2414 while (num_elements % kernel_threads) num_elements++;
2415
2416 cl_kernel kernel = NULL;
2417
2418 switch (kern_run)
2419 {
2420 case KERN_RUN_1: kernel = device_param->kernel1; break;
2421 case KERN_RUN_12: kernel = device_param->kernel12; break;
2422 case KERN_RUN_2: kernel = device_param->kernel2; break;
2423 case KERN_RUN_23: kernel = device_param->kernel23; break;
2424 case KERN_RUN_3: kernel = device_param->kernel3; break;
2425 }
2426
2427 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2428 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2429 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2430 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2431 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2432 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2433 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2434 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2435 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2436 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2437 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2438
2439 hc_timer_t timer;
2440
2441 hc_timer_set (&timer);
2442
2443 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2444 {
2445 const size_t global_work_size[3] = { num_elements, 32, 1 };
2446 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2447
2448 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2449 }
2450 else
2451 {
2452 size_t workgroup_size = 0;
2453
2454 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2455
2456 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2457
2458 const size_t global_work_size[3] = { num_elements, 1, 1 };
2459 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2460
2461 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2462 }
2463
2464 hc_clFlush (data.ocl, device_param->command_queue);
2465
2466 hc_clFinish (data.ocl, device_param->command_queue);
2467
2468 if (event_update)
2469 {
2470 float exec_time;
2471
2472 hc_timer_get (timer, exec_time);
2473
2474 uint exec_pos = device_param->exec_pos;
2475
2476 device_param->exec_ms[exec_pos] = exec_time;
2477
2478 exec_pos++;
2479
2480 if (exec_pos == EXEC_CACHE)
2481 {
2482 exec_pos = 0;
2483 }
2484
2485 device_param->exec_pos = exec_pos;
2486 }
2487 }
2488
2489 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2490 {
2491 uint num_elements = num;
2492
2493 switch (kern_run)
2494 {
2495 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2496 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2497 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2498 }
2499
2500 // causes problems with special threads like in bcrypt
2501 // const uint kernel_threads = device_param->kernel_threads;
2502
2503 uint kernel_threads = KERNEL_THREADS;
2504
2505 while (num_elements % kernel_threads) num_elements++;
2506
2507 cl_kernel kernel = NULL;
2508
2509 switch (kern_run)
2510 {
2511 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2512 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2513 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2514 }
2515
2516 switch (kern_run)
2517 {
2518 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2519 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2520 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2521 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2522 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2523 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2524 break;
2525 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2526 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2527 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2528 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2529 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2530 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2531 break;
2532 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2533 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2534 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2535 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2536 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2537 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2538 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2539 break;
2540 }
2541
2542 size_t workgroup_size = 0;
2543 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
2544 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2545
2546 const size_t global_work_size[3] = { num_elements, 1, 1 };
2547 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2548
2549 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2550
2551 hc_clFlush (data.ocl, device_param->command_queue);
2552
2553 hc_clFinish (data.ocl, device_param->command_queue);
2554 }
2555
2556 static void run_kernel_tm (hc_device_param_t *device_param)
2557 {
2558 const uint num_elements = 1024; // fixed
2559
2560 uint kernel_threads = 32;
2561
2562 cl_kernel kernel = device_param->kernel_tm;
2563
2564 size_t workgroup_size = 0;
2565 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2566 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2567
2568 const size_t global_work_size[3] = { num_elements, 1, 1 };
2569 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2570
2571 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2572
2573 hc_clFlush (data.ocl, device_param->command_queue);
2574
2575 hc_clFinish (data.ocl, device_param->command_queue);
2576 }
2577
2578 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2579 {
2580 uint num_elements = num;
2581
2582 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2583 device_param->kernel_params_amp_buf32[6] = num_elements;
2584
2585 // causes problems with special threads like in bcrypt
2586 // const uint kernel_threads = device_param->kernel_threads;
2587
2588 uint kernel_threads = KERNEL_THREADS;
2589
2590 while (num_elements % kernel_threads) num_elements++;
2591
2592 cl_kernel kernel = device_param->kernel_amp;
2593
2594 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2595 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2596
2597 size_t workgroup_size = 0;
2598 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2599 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2600
2601 const size_t global_work_size[3] = { num_elements, 1, 1 };
2602 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2603
2604 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2605
2606 hc_clFlush (data.ocl, device_param->command_queue);
2607
2608 hc_clFinish (data.ocl, device_param->command_queue);
2609 }
2610
2611 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2612 {
2613 int rc = -1;
2614
2615 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2616 {
2617 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2618
2619 const cl_uchar zero = 0;
2620
2621 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2622 }
2623
2624 if (rc != 0)
2625 {
2626 // NOTE: clEnqueueFillBuffer () always fails with -59
2627 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2628 // How's that possible, OpenCL 1.2 support is advertised??
2629 // We need to workaround...
2630
2631 #define FILLSZ 0x100000
2632
2633 char *tmp = (char *) mymalloc (FILLSZ);
2634
2635 for (uint i = 0; i < size; i += FILLSZ)
2636 {
2637 const int left = size - i;
2638
2639 const int fillsz = MIN (FILLSZ, left);
2640
2641 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2642 }
2643
2644 myfree (tmp);
2645 }
2646 }
2647
2648 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)
2649 {
2650 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2651 {
2652 if (attack_mode == ATTACK_MODE_BF)
2653 {
2654 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2655 {
2656 const uint size_tm = 32 * sizeof (bs_word_t);
2657
2658 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2659
2660 run_kernel_tm (device_param);
2661
2662 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);
2663 }
2664 }
2665
2666 if (highest_pw_len < 16)
2667 {
2668 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2669 }
2670 else if (highest_pw_len < 32)
2671 {
2672 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2673 }
2674 else
2675 {
2676 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2677 }
2678 }
2679 else
2680 {
2681 run_kernel_amp (device_param, pws_cnt);
2682
2683 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2684
2685 if (opts_type & OPTS_TYPE_HOOK12)
2686 {
2687 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2688 }
2689
2690 uint iter = salt_buf->salt_iter;
2691
2692 uint loop_step = device_param->kernel_loops;
2693
2694 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2695 {
2696 uint loop_left = iter - loop_pos;
2697
2698 loop_left = MIN (loop_left, loop_step);
2699
2700 device_param->kernel_params_buf32[25] = loop_pos;
2701 device_param->kernel_params_buf32[26] = loop_left;
2702
2703 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2704
2705 if (data.devices_status == STATUS_CRACKED) break;
2706 if (data.devices_status == STATUS_ABORTED) break;
2707 if (data.devices_status == STATUS_QUIT) break;
2708 }
2709
2710 if (opts_type & OPTS_TYPE_HOOK23)
2711 {
2712 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2713
2714 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);
2715
2716 // do something with data
2717
2718 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);
2719 }
2720
2721 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2722 }
2723 }
2724
2725 static int run_rule_engine (const int rule_len, const char *rule_buf)
2726 {
2727 if (rule_len == 0)
2728 {
2729 return 0;
2730 }
2731 else if (rule_len == 1)
2732 {
2733 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2734 }
2735
2736 return 1;
2737 }
2738
2739 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2740 {
2741 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2742 {
2743 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);
2744 }
2745 else if (data.attack_kern == ATTACK_KERN_COMBI)
2746 {
2747 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2748 {
2749 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2750 {
2751 for (u32 i = 0; i < pws_cnt; i++)
2752 {
2753 const u32 pw_len = device_param->pws_buf[i].pw_len;
2754
2755 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2756
2757 ptr[pw_len] = 0x01;
2758 }
2759 }
2760 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2761 {
2762 for (u32 i = 0; i < pws_cnt; i++)
2763 {
2764 const u32 pw_len = device_param->pws_buf[i].pw_len;
2765
2766 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2767
2768 ptr[pw_len] = 0x80;
2769 }
2770 }
2771 }
2772
2773 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);
2774 }
2775 else if (data.attack_kern == ATTACK_KERN_BF)
2776 {
2777 const u64 off = device_param->words_off;
2778
2779 device_param->kernel_params_mp_l_buf64[3] = off;
2780
2781 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2782 }
2783 }
2784
2785 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops, const int repeat)
2786 {
2787 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2788
2789 device_param->kernel_params_buf32[26] = kernel_loops;
2790 device_param->kernel_params_buf32[27] = kernel_loops;
2791
2792 // init some fake words
2793
2794 for (u32 i = 0; i < kernel_power; i++)
2795 {
2796 device_param->pws_buf[i].i[0] = i;
2797 device_param->pws_buf[i].i[1] = 0x01234567;
2798 device_param->pws_buf[i].pw_len = 4 + (i & 3);
2799 }
2800
2801 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);
2802
2803 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2804 {
2805 run_kernel_amp (device_param, kernel_power);
2806 }
2807
2808 // caching run
2809
2810 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2811 {
2812 run_kernel (KERN_RUN_1, device_param, kernel_power, false);
2813 }
2814 else
2815 {
2816 run_kernel (KERN_RUN_2, device_param, kernel_power, false);
2817 }
2818
2819 // now user repeats
2820
2821 for (int i = 0; i < repeat; i++)
2822 {
2823 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2824 {
2825 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2826 }
2827 else
2828 {
2829 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2830 }
2831 }
2832
2833 const double exec_ms_prev = get_avg_exec_time (device_param, repeat);
2834
2835 // reset fake words
2836
2837 memset (device_param->pws_buf, 0, kernel_power * sizeof (pw_t));
2838
2839 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);
2840 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);
2841
2842 return exec_ms_prev;
2843 }
2844
2845 static void autotune (hc_device_param_t *device_param)
2846 {
2847 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2848
2849 const u32 kernel_accel_min = device_param->kernel_accel_min;
2850 const u32 kernel_accel_max = device_param->kernel_accel_max;
2851
2852 const u32 kernel_loops_min = device_param->kernel_loops_min;
2853 const u32 kernel_loops_max = device_param->kernel_loops_max;
2854
2855 u32 kernel_accel = kernel_accel_min;
2856 u32 kernel_loops = kernel_loops_min;
2857
2858 // steps
2859
2860 #define STEPS_CNT 10
2861
2862 #define STEPS_ACCEL_CNT (STEPS_CNT + 2)
2863 #define STEPS_LOOPS_CNT (STEPS_CNT + 2)
2864
2865 u32 steps_accel[STEPS_ACCEL_CNT];
2866 u32 steps_loops[STEPS_LOOPS_CNT];
2867
2868 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2869 {
2870 steps_accel[i] = 1 << i;
2871 }
2872
2873 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2874 {
2875 steps_loops[i] = 1 << i;
2876 }
2877
2878 steps_accel[STEPS_CNT + 0] = kernel_accel_min;
2879 steps_accel[STEPS_CNT + 1] = kernel_accel_max;
2880
2881 steps_loops[STEPS_CNT + 0] = kernel_loops_min;
2882 steps_loops[STEPS_CNT + 1] = kernel_loops_max;
2883
2884 qsort (steps_accel, STEPS_ACCEL_CNT, sizeof (u32), sort_by_u32);
2885 qsort (steps_loops, STEPS_LOOPS_CNT, sizeof (u32), sort_by_u32);
2886
2887 // find out highest kernel-loops that stays below target_ms, we can use it later for multiplication as this is a linear function
2888
2889 u32 kernel_loops_tmp;
2890
2891 for (kernel_loops_tmp = kernel_loops_max; kernel_loops_tmp > kernel_loops_min; kernel_loops_tmp >>= 1)
2892 {
2893 const double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops_tmp, 1);
2894
2895 if (exec_ms < target_ms) break;
2896 }
2897
2898 // kernel-accel
2899
2900 if (kernel_accel_min < kernel_accel_max)
2901 {
2902 double e_best = 0;
2903
2904 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2905 {
2906 const u32 kernel_accel_try = steps_accel[i];
2907
2908 if (kernel_accel_try < kernel_accel_min) continue;
2909 if (kernel_accel_try > kernel_accel_max) break;
2910
2911 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_tmp, 1);
2912
2913 if (exec_ms > target_ms) break;
2914
2915 const double e = kernel_accel_try / exec_ms;
2916
2917 if (e > e_best)
2918 {
2919 kernel_accel = kernel_accel_try;
2920
2921 e_best = e;
2922 }
2923 }
2924 }
2925
2926 // kernel-loops final
2927
2928 if (kernel_loops_min < kernel_loops_max)
2929 {
2930 double e_best = 0;
2931
2932 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2933 {
2934 const u32 kernel_loops_try = steps_loops[i];
2935
2936 if (kernel_loops_try < kernel_loops_min) continue;
2937 if (kernel_loops_try > kernel_loops_max) break;
2938
2939 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops_try, 1);
2940
2941 if (exec_ms > target_ms) break;
2942
2943 const double e = kernel_loops_try / exec_ms;
2944
2945 if (e > e_best)
2946 {
2947 kernel_loops = kernel_loops_try;
2948
2949 e_best = e;
2950 }
2951 }
2952 }
2953
2954 // final balance
2955
2956 u32 kernel_accel_best = kernel_accel;
2957 u32 kernel_loops_best = kernel_loops;
2958
2959 u32 exec_best = -1;
2960
2961 if ((kernel_accel_min < kernel_accel_max) || (kernel_loops_min < kernel_loops_max))
2962 {
2963 const double exec_ms = try_run (device_param, kernel_accel_best, kernel_loops_best, 1);
2964
2965 exec_best = exec_ms;
2966 }
2967
2968 // reset
2969
2970 if (kernel_accel_min < kernel_accel_max)
2971 {
2972 u32 kernel_accel_try = kernel_accel;
2973 u32 kernel_loops_try = kernel_loops;
2974
2975 for (int i = 0; i < 2; i++)
2976 {
2977 kernel_accel_try >>= 1;
2978 kernel_loops_try <<= 1;
2979
2980 if (kernel_accel_try < kernel_accel_min) break;
2981 if (kernel_loops_try > kernel_loops_max) break;
2982
2983 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
2984
2985 if (exec_ms < exec_best)
2986 {
2987 kernel_accel_best = kernel_accel_try;
2988 kernel_loops_best = kernel_loops_try;
2989
2990 exec_best = exec_ms;
2991 }
2992 }
2993 }
2994
2995 // reset
2996
2997 if (kernel_loops_min < kernel_loops_max)
2998 {
2999 u32 kernel_accel_try = kernel_accel;
3000 u32 kernel_loops_try = kernel_loops;
3001
3002 for (int i = 0; i < 2; i++)
3003 {
3004 kernel_accel_try <<= 1;
3005 kernel_loops_try >>= 1;
3006
3007 if (kernel_accel_try > kernel_accel_max) break;
3008 if (kernel_loops_try < kernel_loops_min) break;
3009
3010 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
3011
3012 if (exec_ms < exec_best)
3013 {
3014 kernel_accel_best = kernel_accel_try;
3015 kernel_loops_best = kernel_loops_try;
3016
3017 exec_best = exec_ms;
3018 }
3019 }
3020 }
3021
3022 // reset timer
3023
3024 device_param->exec_pos = 0;
3025
3026 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3027
3028 // store
3029
3030 kernel_accel = kernel_accel_best;
3031 kernel_loops = kernel_loops_best;
3032
3033 device_param->kernel_accel = kernel_accel;
3034 device_param->kernel_loops = kernel_loops;
3035
3036 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3037
3038 device_param->kernel_power = kernel_power;
3039
3040 #ifdef DEBUG
3041
3042 if (data.quiet == 0)
3043 {
3044 clear_prompt ();
3045
3046 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3047 "Device #%u: autotuned kernel-loops to %u\n",
3048 device_param->device_id + 1,
3049 kernel_accel,
3050 device_param->device_id + 1,
3051 kernel_loops);
3052
3053 fprintf (stdout, "%s", PROMPT);
3054 fflush (stdout);
3055 }
3056
3057 #endif
3058 }
3059
3060 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3061 {
3062 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3063
3064 // init speed timer
3065
3066 uint speed_pos = device_param->speed_pos;
3067
3068 #ifdef _POSIX
3069 if (device_param->timer_speed.tv_sec == 0)
3070 {
3071 hc_timer_set (&device_param->timer_speed);
3072 }
3073 #endif
3074
3075 #ifdef _WIN
3076 if (device_param->timer_speed.QuadPart == 0)
3077 {
3078 hc_timer_set (&device_param->timer_speed);
3079 }
3080 #endif
3081
3082 // find higest password length, this is for optimization stuff
3083
3084 uint highest_pw_len = 0;
3085
3086 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3087 {
3088 }
3089 else if (data.attack_kern == ATTACK_KERN_COMBI)
3090 {
3091 }
3092 else if (data.attack_kern == ATTACK_KERN_BF)
3093 {
3094 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3095 + device_param->kernel_params_mp_l_buf32[5];
3096 }
3097
3098 // iteration type
3099
3100 uint innerloop_step = 0;
3101 uint innerloop_cnt = 0;
3102
3103 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3104 else innerloop_step = 1;
3105
3106 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3107 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3108 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3109
3110 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3111
3112 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3113 {
3114 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3115
3116 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3117
3118 if (data.devices_status == STATUS_CRACKED) break;
3119 if (data.devices_status == STATUS_ABORTED) break;
3120 if (data.devices_status == STATUS_QUIT) break;
3121 if (data.devices_status == STATUS_BYPASS) break;
3122
3123 salt_t *salt_buf = &data.salts_buf[salt_pos];
3124
3125 device_param->kernel_params_buf32[24] = salt_pos;
3126 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3127 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3128
3129 FILE *combs_fp = device_param->combs_fp;
3130
3131 if (data.attack_mode == ATTACK_MODE_COMBI)
3132 {
3133 rewind (combs_fp);
3134 }
3135
3136 // innerloops
3137
3138 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3139 {
3140 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3141
3142 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3143
3144 if (data.devices_status == STATUS_CRACKED) break;
3145 if (data.devices_status == STATUS_ABORTED) break;
3146 if (data.devices_status == STATUS_QUIT) break;
3147 if (data.devices_status == STATUS_BYPASS) break;
3148
3149 uint innerloop_left = innerloop_cnt - innerloop_pos;
3150
3151 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3152
3153 device_param->innerloop_pos = innerloop_pos;
3154 device_param->innerloop_left = innerloop_left;
3155
3156 device_param->kernel_params_buf32[27] = innerloop_left;
3157
3158 // i think we can get rid of this
3159 if (innerloop_left == 0)
3160 {
3161 puts ("bug, how should this happen????\n");
3162
3163 continue;
3164 }
3165
3166 if (data.salts_shown[salt_pos] == 1)
3167 {
3168 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3169
3170 continue;
3171 }
3172
3173 // initialize amplifiers
3174
3175 if (data.attack_mode == ATTACK_MODE_COMBI)
3176 {
3177 uint i = 0;
3178
3179 while (i < innerloop_left)
3180 {
3181 if (feof (combs_fp)) break;
3182
3183 int line_len = fgetl (combs_fp, line_buf);
3184
3185 if (line_len >= PW_MAX1) continue;
3186
3187 line_len = convert_from_hex (line_buf, line_len);
3188
3189 char *line_buf_new = line_buf;
3190
3191 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3192 {
3193 char rule_buf_out[BLOCK_SIZE] = { 0 };
3194
3195 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3196
3197 if (rule_len_out < 0)
3198 {
3199 data.words_progress_rejected[salt_pos] += pws_cnt;
3200
3201 continue;
3202 }
3203
3204 line_len = rule_len_out;
3205
3206 line_buf_new = rule_buf_out;
3207 }
3208
3209 line_len = MIN (line_len, PW_DICTMAX);
3210
3211 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3212
3213 memcpy (ptr, line_buf_new, line_len);
3214
3215 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3216
3217 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3218 {
3219 uppercase (ptr, line_len);
3220 }
3221
3222 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3223 {
3224 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3225 {
3226 ptr[line_len] = 0x80;
3227 }
3228
3229 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3230 {
3231 ptr[line_len] = 0x01;
3232 }
3233 }
3234
3235 device_param->combs_buf[i].pw_len = line_len;
3236
3237 i++;
3238 }
3239
3240 for (uint j = i; j < innerloop_left; j++)
3241 {
3242 device_param->combs_buf[j].i[0] = 0;
3243 device_param->combs_buf[j].i[1] = 0;
3244 device_param->combs_buf[j].i[2] = 0;
3245 device_param->combs_buf[j].i[3] = 0;
3246 device_param->combs_buf[j].i[4] = 0;
3247 device_param->combs_buf[j].i[5] = 0;
3248 device_param->combs_buf[j].i[6] = 0;
3249 device_param->combs_buf[j].i[7] = 0;
3250
3251 device_param->combs_buf[j].pw_len = 0;
3252 }
3253
3254 innerloop_left = i;
3255 }
3256 else if (data.attack_mode == ATTACK_MODE_BF)
3257 {
3258 u64 off = innerloop_pos;
3259
3260 device_param->kernel_params_mp_r_buf64[3] = off;
3261
3262 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3263 }
3264 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3265 {
3266 u64 off = innerloop_pos;
3267
3268 device_param->kernel_params_mp_buf64[3] = off;
3269
3270 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3271 }
3272 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3273 {
3274 u64 off = innerloop_pos;
3275
3276 device_param->kernel_params_mp_buf64[3] = off;
3277
3278 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3279 }
3280
3281 // copy amplifiers
3282
3283 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3284 {
3285 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);
3286 }
3287 else if (data.attack_mode == ATTACK_MODE_COMBI)
3288 {
3289 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);
3290 }
3291 else if (data.attack_mode == ATTACK_MODE_BF)
3292 {
3293 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);
3294 }
3295 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3296 {
3297 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);
3298 }
3299 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3300 {
3301 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);
3302 }
3303
3304 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3305
3306 if (data.benchmark == 1)
3307 {
3308 for (u32 i = 0; i < data.benchmark_repeats; i++)
3309 {
3310 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3311 }
3312 }
3313
3314 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3315
3316 if (data.devices_status == STATUS_CRACKED) break;
3317 if (data.devices_status == STATUS_ABORTED) break;
3318 if (data.devices_status == STATUS_QUIT) break;
3319
3320 /**
3321 * result
3322 */
3323
3324 hc_thread_mutex_lock (mux_display);
3325
3326 check_cracked (device_param, salt_pos);
3327
3328 hc_thread_mutex_unlock (mux_display);
3329
3330 /**
3331 * progress
3332 */
3333
3334 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3335
3336 if (data.benchmark == 1)
3337 {
3338 perf_sum_all = (perf_sum_all * data.benchmark_repeats) + perf_sum_all;
3339 }
3340
3341 hc_thread_mutex_lock (mux_counter);
3342
3343 data.words_progress_done[salt_pos] += perf_sum_all;
3344
3345 hc_thread_mutex_unlock (mux_counter);
3346
3347 /**
3348 * speed
3349 */
3350
3351 float speed_ms;
3352
3353 hc_timer_get (device_param->timer_speed, speed_ms);
3354
3355 hc_timer_set (&device_param->timer_speed);
3356
3357 hc_thread_mutex_lock (mux_display);
3358
3359 device_param->speed_cnt[speed_pos] = perf_sum_all;
3360
3361 device_param->speed_ms[speed_pos] = speed_ms;
3362
3363 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3364
3365 hc_thread_mutex_unlock (mux_display);
3366
3367 speed_pos++;
3368
3369 if (speed_pos == SPEED_CACHE)
3370 {
3371 speed_pos = 0;
3372 }
3373
3374 /**
3375 * benchmark
3376 */
3377
3378 if (data.benchmark == 1) break;
3379 }
3380 }
3381
3382 device_param->speed_pos = speed_pos;
3383
3384 myfree (line_buf);
3385 }
3386
3387 static void load_segment (wl_data_t *wl_data, FILE *fd)
3388 {
3389 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3390
3391 wl_data->pos = 0;
3392
3393 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3394
3395 wl_data->buf[wl_data->cnt] = 0;
3396
3397 if (wl_data->cnt == 0) return;
3398
3399 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3400
3401 while (!feof (fd))
3402 {
3403 if (wl_data->cnt == wl_data->avail)
3404 {
3405 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3406
3407 wl_data->avail += wl_data->incr;
3408 }
3409
3410 const int c = fgetc (fd);
3411
3412 if (c == EOF) break;
3413
3414 wl_data->buf[wl_data->cnt] = (char) c;
3415
3416 wl_data->cnt++;
3417
3418 if (c == '\n') break;
3419 }
3420
3421 // ensure stream ends with a newline
3422
3423 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3424 {
3425 wl_data->cnt++;
3426
3427 wl_data->buf[wl_data->cnt - 1] = '\n';
3428 }
3429
3430 return;
3431 }
3432
3433 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3434 {
3435 char *ptr = buf;
3436
3437 for (u32 i = 0; i < sz; i++, ptr++)
3438 {
3439 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3440
3441 if (i == 7)
3442 {
3443 *off = i;
3444 *len = i;
3445
3446 return;
3447 }
3448
3449 if (*ptr != '\n') continue;
3450
3451 *off = i + 1;
3452
3453 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3454
3455 *len = i;
3456
3457 return;
3458 }
3459
3460 *off = sz;
3461 *len = sz;
3462 }
3463
3464 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3465 {
3466 char *ptr = buf;
3467
3468 for (u32 i = 0; i < sz; i++, ptr++)
3469 {
3470 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3471
3472 if (*ptr != '\n') continue;
3473
3474 *off = i + 1;
3475
3476 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3477
3478 *len = i;
3479
3480 return;
3481 }
3482
3483 *off = sz;
3484 *len = sz;
3485 }
3486
3487 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3488 {
3489 char *ptr = buf;
3490
3491 for (u32 i = 0; i < sz; i++, ptr++)
3492 {
3493 if (*ptr != '\n') continue;
3494
3495 *off = i + 1;
3496
3497 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3498
3499 *len = i;
3500
3501 return;
3502 }
3503
3504 *off = sz;
3505 *len = sz;
3506 }
3507
3508 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3509 {
3510 while (wl_data->pos < wl_data->cnt)
3511 {
3512 uint off;
3513 uint len;
3514
3515 char *ptr = wl_data->buf + wl_data->pos;
3516
3517 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3518
3519 wl_data->pos += off;
3520
3521 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3522 {
3523 char rule_buf_out[BLOCK_SIZE] = { 0 };
3524
3525 int rule_len_out = -1;
3526
3527 if (len < BLOCK_SIZE)
3528 {
3529 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3530 }
3531
3532 if (rule_len_out < 0)
3533 {
3534 continue;
3535 }
3536
3537 if (rule_len_out > PW_MAX)
3538 {
3539 continue;
3540 }
3541 }
3542 else
3543 {
3544 if (len > PW_MAX)
3545 {
3546 continue;
3547 }
3548 }
3549
3550 *out_buf = ptr;
3551 *out_len = len;
3552
3553 return;
3554 }
3555
3556 if (feof (fd))
3557 {
3558 fprintf (stderr, "BUG feof()!!\n");
3559
3560 return;
3561 }
3562
3563 load_segment (wl_data, fd);
3564
3565 get_next_word (wl_data, fd, out_buf, out_len);
3566 }
3567
3568 #ifdef _POSIX
3569 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3570 #endif
3571
3572 #ifdef _WIN
3573 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3574 #endif
3575 {
3576 hc_signal (NULL);
3577
3578 dictstat_t d;
3579
3580 d.cnt = 0;
3581
3582 #ifdef _POSIX
3583 fstat (fileno (fd), &d.stat);
3584 #endif
3585
3586 #ifdef _WIN
3587 _fstat64 (fileno (fd), &d.stat);
3588 #endif
3589
3590 d.stat.st_mode = 0;
3591 d.stat.st_nlink = 0;
3592 d.stat.st_uid = 0;
3593 d.stat.st_gid = 0;
3594 d.stat.st_rdev = 0;
3595 d.stat.st_atime = 0;
3596
3597 #ifdef _POSIX
3598 d.stat.st_blksize = 0;
3599 d.stat.st_blocks = 0;
3600 #endif
3601
3602 if (d.stat.st_size == 0) return 0;
3603
3604 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3605
3606 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3607 {
3608 if (d_cache)
3609 {
3610 u64 cnt = d_cache->cnt;
3611
3612 u64 keyspace = cnt;
3613
3614 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3615 {
3616 keyspace *= data.kernel_rules_cnt;
3617 }
3618 else if (data.attack_kern == ATTACK_KERN_COMBI)
3619 {
3620 keyspace *= data.combs_cnt;
3621 }
3622
3623 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);
3624 if (data.quiet == 0) log_info ("");
3625
3626 hc_signal (sigHandler_default);
3627
3628 return (keyspace);
3629 }
3630 }
3631
3632 time_t now = 0;
3633 time_t prev = 0;
3634
3635 u64 comp = 0;
3636 u64 cnt = 0;
3637 u64 cnt2 = 0;
3638
3639 while (!feof (fd))
3640 {
3641 load_segment (wl_data, fd);
3642
3643 comp += wl_data->cnt;
3644
3645 u32 i = 0;
3646
3647 while (i < wl_data->cnt)
3648 {
3649 u32 len;
3650 u32 off;
3651
3652 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3653
3654 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3655 {
3656 char rule_buf_out[BLOCK_SIZE] = { 0 };
3657
3658 int rule_len_out = -1;
3659
3660 if (len < BLOCK_SIZE)
3661 {
3662 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3663 }
3664
3665 if (rule_len_out < 0)
3666 {
3667 len = PW_MAX1;
3668 }
3669 else
3670 {
3671 len = rule_len_out;
3672 }
3673 }
3674
3675 if (len < PW_MAX1)
3676 {
3677 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3678 {
3679 cnt += data.kernel_rules_cnt;
3680 }
3681 else if (data.attack_kern == ATTACK_KERN_COMBI)
3682 {
3683 cnt += data.combs_cnt;
3684 }
3685
3686 d.cnt++;
3687 }
3688
3689 i += off;
3690
3691 cnt2++;
3692 }
3693
3694 time (&now);
3695
3696 if ((now - prev) == 0) continue;
3697
3698 float percent = (float) comp / (float) d.stat.st_size;
3699
3700 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);
3701
3702 time (&prev);
3703 }
3704
3705 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);
3706 if (data.quiet == 0) log_info ("");
3707
3708 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3709
3710 hc_signal (sigHandler_default);
3711
3712 return (cnt);
3713 }
3714
3715 static void *thread_monitor (void *p)
3716 {
3717 uint runtime_check = 0;
3718 uint remove_check = 0;
3719 uint status_check = 0;
3720 uint restore_check = 0;
3721
3722 uint restore_left = data.restore_timer;
3723 uint remove_left = data.remove_timer;
3724 uint status_left = data.status_timer;
3725
3726 #ifdef HAVE_HWMON
3727 uint hwmon_check = 0;
3728
3729 // these variables are mainly used for fan control (AMD only)
3730
3731 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3732
3733 // temperature controller "loopback" values
3734
3735 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3736 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3737
3738 #ifdef HAVE_ADL
3739 int temp_threshold = 1; // degrees celcius
3740
3741 int fan_speed_min = 15; // in percentage
3742 int fan_speed_max = 100;
3743 #endif // HAVE_ADL
3744
3745 time_t last_temp_check_time;
3746 #endif // HAVE_HWMON
3747
3748 uint sleep_time = 1;
3749
3750 if (data.runtime)
3751 {
3752 runtime_check = 1;
3753 }
3754
3755 if (data.restore_timer)
3756 {
3757 restore_check = 1;
3758 }
3759
3760 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3761 {
3762 remove_check = 1;
3763 }
3764
3765 if (data.status == 1)
3766 {
3767 status_check = 1;
3768 }
3769
3770 #ifdef HAVE_HWMON
3771 if (data.gpu_temp_disable == 0)
3772 {
3773 time (&last_temp_check_time);
3774
3775 hwmon_check = 1;
3776 }
3777 #endif
3778
3779 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3780 {
3781 #ifdef HAVE_HWMON
3782 if (hwmon_check == 0)
3783 #endif
3784 return (p);
3785 }
3786
3787 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3788 {
3789 hc_sleep (sleep_time);
3790
3791 if (data.devices_status != STATUS_RUNNING) continue;
3792
3793 #ifdef HAVE_HWMON
3794 if (hwmon_check == 1)
3795 {
3796 hc_thread_mutex_lock (mux_adl);
3797
3798 time_t temp_check_time;
3799
3800 time (&temp_check_time);
3801
3802 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3803
3804 if (Ta == 0) Ta = 1;
3805
3806 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3807 {
3808 hc_device_param_t *device_param = &data.devices_param[device_id];
3809
3810 if (device_param->skipped) continue;
3811
3812 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3813
3814 const int temperature = hm_get_temperature_with_device_id (device_id);
3815
3816 if (temperature > (int) data.gpu_temp_abort)
3817 {
3818 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3819
3820 if (data.devices_status != STATUS_QUIT) myabort ();
3821
3822 break;
3823 }
3824
3825 #ifdef HAVE_ADL
3826 const int gpu_temp_retain = data.gpu_temp_retain;
3827
3828 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3829 {
3830 if (data.hm_device[device_id].fan_supported == 1)
3831 {
3832 int temp_cur = temperature;
3833
3834 int temp_diff_new = gpu_temp_retain - temp_cur;
3835
3836 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3837
3838 // calculate Ta value (time difference in seconds between the last check and this check)
3839
3840 last_temp_check_time = temp_check_time;
3841
3842 float Kp = 1.8;
3843 float Ki = 0.005;
3844 float Kd = 6;
3845
3846 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3847
3848 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);
3849
3850 if (abs (fan_diff_required) >= temp_threshold)
3851 {
3852 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3853
3854 int fan_speed_level = fan_speed_cur;
3855
3856 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3857
3858 int fan_speed_new = fan_speed_level - fan_diff_required;
3859
3860 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3861 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3862
3863 if (fan_speed_new != fan_speed_cur)
3864 {
3865 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3866 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3867
3868 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3869 {
3870 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3871
3872 fan_speed_chgd[device_id] = 1;
3873 }
3874
3875 temp_diff_old[device_id] = temp_diff_new;
3876 }
3877 }
3878 }
3879 }
3880 #endif // HAVE_ADL
3881 }
3882
3883 hc_thread_mutex_unlock (mux_adl);
3884 }
3885 #endif // HAVE_HWMON
3886
3887 if (restore_check == 1)
3888 {
3889 restore_left--;
3890
3891 if (restore_left == 0)
3892 {
3893 if (data.restore_disable == 0) cycle_restore ();
3894
3895 restore_left = data.restore_timer;
3896 }
3897 }
3898
3899 if ((runtime_check == 1) && (data.runtime_start > 0))
3900 {
3901 time_t runtime_cur;
3902
3903 time (&runtime_cur);
3904
3905 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3906
3907 if (runtime_left <= 0)
3908 {
3909 if (data.benchmark == 0)
3910 {
3911 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3912 }
3913
3914 if (data.devices_status != STATUS_QUIT) myabort ();
3915 }
3916 }
3917
3918 if (remove_check == 1)
3919 {
3920 remove_left--;
3921
3922 if (remove_left == 0)
3923 {
3924 if (data.digests_saved != data.digests_done)
3925 {
3926 data.digests_saved = data.digests_done;
3927
3928 save_hash ();
3929 }
3930
3931 remove_left = data.remove_timer;
3932 }
3933 }
3934
3935 if (status_check == 1)
3936 {
3937 status_left--;
3938
3939 if (status_left == 0)
3940 {
3941 hc_thread_mutex_lock (mux_display);
3942
3943 if (data.quiet == 0) clear_prompt ();
3944
3945 if (data.quiet == 0) log_info ("");
3946
3947 status_display ();
3948
3949 if (data.quiet == 0) log_info ("");
3950
3951 hc_thread_mutex_unlock (mux_display);
3952
3953 status_left = data.status_timer;
3954 }
3955 }
3956 }
3957
3958 #ifdef HAVE_HWMON
3959 myfree (fan_speed_chgd);
3960
3961 myfree (temp_diff_old);
3962 myfree (temp_diff_sum);
3963 #endif
3964
3965 p = NULL;
3966
3967 return (p);
3968 }
3969
3970 static void *thread_outfile_remove (void *p)
3971 {
3972 // some hash-dependent constants
3973 char *outfile_dir = data.outfile_check_directory;
3974 uint dgst_size = data.dgst_size;
3975 uint isSalted = data.isSalted;
3976 uint esalt_size = data.esalt_size;
3977 uint hash_mode = data.hash_mode;
3978
3979 uint outfile_check_timer = data.outfile_check_timer;
3980
3981 char separator = data.separator;
3982
3983 // some hash-dependent functions
3984 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3985 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3986
3987 // buffers
3988 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3989
3990 hash_buf.digest = mymalloc (dgst_size);
3991
3992 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3993
3994 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3995
3996 uint digest_buf[64] = { 0 };
3997
3998 outfile_data_t *out_info = NULL;
3999
4000 char **out_files = NULL;
4001
4002 time_t folder_mtime = 0;
4003
4004 int out_cnt = 0;
4005
4006 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4007
4008 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4009 {
4010 hc_sleep (1);
4011
4012 if (data.devices_status != STATUS_RUNNING) continue;
4013
4014 check_left--;
4015
4016 if (check_left == 0)
4017 {
4018 struct stat outfile_check_stat;
4019
4020 if (stat (outfile_dir, &outfile_check_stat) == 0)
4021 {
4022 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4023
4024 if (is_dir == 1)
4025 {
4026 if (outfile_check_stat.st_mtime > folder_mtime)
4027 {
4028 char **out_files_new = scan_directory (outfile_dir);
4029
4030 int out_cnt_new = count_dictionaries (out_files_new);
4031
4032 outfile_data_t *out_info_new = NULL;
4033
4034 if (out_cnt_new > 0)
4035 {
4036 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4037
4038 for (int i = 0; i < out_cnt_new; i++)
4039 {
4040 out_info_new[i].file_name = out_files_new[i];
4041
4042 // check if there are files that we have seen/checked before (and not changed)
4043
4044 for (int j = 0; j < out_cnt; j++)
4045 {
4046 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4047 {
4048 struct stat outfile_stat;
4049
4050 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4051 {
4052 if (outfile_stat.st_ctime == out_info[j].ctime)
4053 {
4054 out_info_new[i].ctime = out_info[j].ctime;
4055 out_info_new[i].seek = out_info[j].seek;
4056 }
4057 }
4058 }
4059 }
4060 }
4061 }
4062
4063 local_free (out_info);
4064 local_free (out_files);
4065
4066 out_files = out_files_new;
4067 out_cnt = out_cnt_new;
4068 out_info = out_info_new;
4069
4070 folder_mtime = outfile_check_stat.st_mtime;
4071 }
4072
4073 for (int j = 0; j < out_cnt; j++)
4074 {
4075 FILE *fp = fopen (out_info[j].file_name, "rb");
4076
4077 if (fp != NULL)
4078 {
4079 //hc_thread_mutex_lock (mux_display);
4080
4081 #ifdef _POSIX
4082 struct stat outfile_stat;
4083
4084 fstat (fileno (fp), &outfile_stat);
4085 #endif
4086
4087 #ifdef _WIN
4088 struct stat64 outfile_stat;
4089
4090 _fstat64 (fileno (fp), &outfile_stat);
4091 #endif
4092
4093 if (outfile_stat.st_ctime > out_info[j].ctime)
4094 {
4095 out_info[j].ctime = outfile_stat.st_ctime;
4096 out_info[j].seek = 0;
4097 }
4098
4099 fseek (fp, out_info[j].seek, SEEK_SET);
4100
4101 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4102
4103 while (!feof (fp))
4104 {
4105 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4106
4107 if (ptr == NULL) break;
4108
4109 int line_len = strlen (line_buf);
4110
4111 if (line_len <= 0) continue;
4112
4113 int iter = MAX_CUT_TRIES;
4114
4115 for (uint i = line_len - 1; i && iter; i--, line_len--)
4116 {
4117 if (line_buf[i] != separator) continue;
4118
4119 int parser_status = PARSER_OK;
4120
4121 if ((hash_mode != 2500) && (hash_mode != 6800))
4122 {
4123 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4124 }
4125
4126 uint found = 0;
4127
4128 if (parser_status == PARSER_OK)
4129 {
4130 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4131 {
4132 if (data.salts_shown[salt_pos] == 1) continue;
4133
4134 salt_t *salt_buf = &data.salts_buf[salt_pos];
4135
4136 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4137 {
4138 uint idx = salt_buf->digests_offset + digest_pos;
4139
4140 if (data.digests_shown[idx] == 1) continue;
4141
4142 uint cracked = 0;
4143
4144 if (hash_mode == 6800)
4145 {
4146 if (i == salt_buf->salt_len)
4147 {
4148 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4149 }
4150 }
4151 else if (hash_mode == 2500)
4152 {
4153 // BSSID : MAC1 : MAC2 (:plain)
4154 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4155 {
4156 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4157
4158 if (!cracked) continue;
4159
4160 // now compare MAC1 and MAC2 too, since we have this additional info
4161 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4162 char *mac2_pos = mac1_pos + 12 + 1;
4163
4164 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4165 wpa_t *wpa = &wpas[salt_pos];
4166
4167 // compare hex string(s) vs binary MAC address(es)
4168
4169 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4170 {
4171 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4172 {
4173 cracked = 0;
4174
4175 break;
4176 }
4177 }
4178
4179 // early skip ;)
4180 if (!cracked) continue;
4181
4182 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4183 {
4184 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4185 {
4186 cracked = 0;
4187
4188 break;
4189 }
4190 }
4191 }
4192 }
4193 else
4194 {
4195 char *digests_buf_ptr = (char *) data.digests_buf;
4196
4197 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4198
4199 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4200 }
4201
4202 if (cracked == 1)
4203 {
4204 found = 1;
4205
4206 data.digests_shown[idx] = 1;
4207
4208 data.digests_done++;
4209
4210 salt_buf->digests_done++;
4211
4212 if (salt_buf->digests_done == salt_buf->digests_cnt)
4213 {
4214 data.salts_shown[salt_pos] = 1;
4215
4216 data.salts_done++;
4217
4218 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4219 }
4220 }
4221 }
4222
4223 if (data.devices_status == STATUS_CRACKED) break;
4224 }
4225 }
4226
4227 if (found) break;
4228
4229 if (data.devices_status == STATUS_CRACKED) break;
4230
4231 iter--;
4232 }
4233
4234 if (data.devices_status == STATUS_CRACKED) break;
4235 }
4236
4237 myfree (line_buf);
4238
4239 out_info[j].seek = ftell (fp);
4240
4241 //hc_thread_mutex_unlock (mux_display);
4242
4243 fclose (fp);
4244 }
4245 }
4246 }
4247 }
4248
4249 check_left = outfile_check_timer;
4250 }
4251 }
4252
4253 if (esalt_size) local_free (hash_buf.esalt);
4254
4255 if (isSalted) local_free (hash_buf.salt);
4256
4257 local_free (hash_buf.digest);
4258
4259 local_free (out_info);
4260
4261 local_free (out_files);
4262
4263 p = NULL;
4264
4265 return (p);
4266 }
4267
4268 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4269 {
4270 if (device_param->pws_cnt < device_param->kernel_power)
4271 {
4272 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4273
4274 u8 *ptr = (u8 *) pw->i;
4275
4276 memcpy (ptr, pw_buf, pw_len);
4277
4278 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4279
4280 pw->pw_len = pw_len;
4281
4282 device_param->pws_cnt++;
4283 }
4284 else
4285 {
4286 fprintf (stderr, "BUG pw_add()!!\n");
4287
4288 return;
4289 }
4290 }
4291
4292 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4293 {
4294 hc_thread_mutex_lock (mux_dispatcher);
4295
4296 const u64 words_cur = data.words_cur;
4297 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4298
4299 device_param->words_off = words_cur;
4300
4301 const u64 words_left = words_base - words_cur;
4302
4303 if (allow_div)
4304 {
4305 if (data.kernel_power_all > words_left)
4306 {
4307 if (data.kernel_power_div == 0)
4308 {
4309 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4310 }
4311 }
4312
4313 if (data.kernel_power_div)
4314 {
4315 if (device_param->kernel_power == device_param->kernel_power_user)
4316 {
4317 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4318
4319 if (kernel_power_new < device_param->kernel_power)
4320 {
4321 device_param->kernel_power = kernel_power_new;
4322 }
4323 }
4324 }
4325 }
4326
4327 const uint kernel_power = device_param->kernel_power;
4328
4329 uint work = MIN (words_left, kernel_power);
4330
4331 work = MIN (work, max);
4332
4333 data.words_cur += work;
4334
4335 hc_thread_mutex_unlock (mux_dispatcher);
4336
4337 return work;
4338 }
4339
4340 static void *thread_calc_stdin (void *p)
4341 {
4342 hc_device_param_t *device_param = (hc_device_param_t *) p;
4343
4344 if (device_param->skipped) return NULL;
4345
4346 autotune (device_param);
4347
4348 char *buf = (char *) mymalloc (HCBUFSIZ);
4349
4350 const uint attack_kern = data.attack_kern;
4351
4352 const uint kernel_power = device_param->kernel_power;
4353
4354 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4355 {
4356 hc_thread_mutex_lock (mux_dispatcher);
4357
4358 if (feof (stdin) != 0)
4359 {
4360 hc_thread_mutex_unlock (mux_dispatcher);
4361
4362 break;
4363 }
4364
4365 uint words_cur = 0;
4366
4367 while (words_cur < kernel_power)
4368 {
4369 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4370
4371 if (line_buf == NULL) break;
4372
4373 uint line_len = in_superchop (line_buf);
4374
4375 line_len = convert_from_hex (line_buf, line_len);
4376
4377 // post-process rule engine
4378
4379 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4380 {
4381 char rule_buf_out[BLOCK_SIZE] = { 0 };
4382
4383 int rule_len_out = -1;
4384
4385 if (line_len < BLOCK_SIZE)
4386 {
4387 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4388 }
4389
4390 if (rule_len_out < 0) continue;
4391
4392 line_buf = rule_buf_out;
4393 line_len = rule_len_out;
4394 }
4395
4396 if (line_len > PW_MAX)
4397 {
4398 continue;
4399 }
4400
4401 if (attack_kern == ATTACK_KERN_STRAIGHT)
4402 {
4403 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4404 {
4405 hc_thread_mutex_lock (mux_counter);
4406
4407 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4408 {
4409 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4410 }
4411
4412 hc_thread_mutex_unlock (mux_counter);
4413
4414 continue;
4415 }
4416 }
4417 else if (attack_kern == ATTACK_KERN_COMBI)
4418 {
4419 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4420 // since we still need to combine the plains
4421
4422 if (line_len > data.pw_max)
4423 {
4424 hc_thread_mutex_lock (mux_counter);
4425
4426 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4427 {
4428 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4429 }
4430
4431 hc_thread_mutex_unlock (mux_counter);
4432
4433 continue;
4434 }
4435 }
4436
4437 pw_add (device_param, (u8 *) line_buf, line_len);
4438
4439 words_cur++;
4440
4441 if (data.devices_status == STATUS_CRACKED) break;
4442 if (data.devices_status == STATUS_ABORTED) break;
4443 if (data.devices_status == STATUS_QUIT) break;
4444 if (data.devices_status == STATUS_BYPASS) break;
4445 }
4446
4447 hc_thread_mutex_unlock (mux_dispatcher);
4448
4449 if (data.devices_status == STATUS_CRACKED) break;
4450 if (data.devices_status == STATUS_ABORTED) break;
4451 if (data.devices_status == STATUS_QUIT) break;
4452 if (data.devices_status == STATUS_BYPASS) break;
4453
4454 // flush
4455
4456 const uint pws_cnt = device_param->pws_cnt;
4457
4458 if (pws_cnt)
4459 {
4460 run_copy (device_param, pws_cnt);
4461
4462 run_cracker (device_param, pws_cnt);
4463
4464 device_param->pws_cnt = 0;
4465
4466 if (attack_kern == ATTACK_KERN_STRAIGHT)
4467 {
4468 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4469 }
4470 else if (attack_kern == ATTACK_KERN_COMBI)
4471 {
4472 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4473 }
4474 }
4475 }
4476
4477 device_param->kernel_accel = 0;
4478 device_param->kernel_loops = 0;
4479
4480 myfree (buf);
4481
4482 return NULL;
4483 }
4484
4485 static void *thread_calc (void *p)
4486 {
4487 hc_device_param_t *device_param = (hc_device_param_t *) p;
4488
4489 if (device_param->skipped) return NULL;
4490
4491 autotune (device_param);
4492
4493 const uint attack_mode = data.attack_mode;
4494 const uint attack_kern = data.attack_kern;
4495
4496 if (attack_mode == ATTACK_MODE_BF)
4497 {
4498 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4499 {
4500 const uint work = get_work (device_param, -1, true);
4501
4502 if (work == 0) break;
4503
4504 const u64 words_off = device_param->words_off;
4505 const u64 words_fin = words_off + work;
4506
4507 const uint pws_cnt = work;
4508
4509 device_param->pws_cnt = pws_cnt;
4510
4511 if (pws_cnt)
4512 {
4513 run_copy (device_param, pws_cnt);
4514
4515 run_cracker (device_param, pws_cnt);
4516
4517 device_param->pws_cnt = 0;
4518
4519 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4520 }
4521
4522 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4523
4524 if (data.devices_status == STATUS_CRACKED) break;
4525 if (data.devices_status == STATUS_ABORTED) break;
4526 if (data.devices_status == STATUS_QUIT) break;
4527 if (data.devices_status == STATUS_BYPASS) break;
4528
4529 if (data.benchmark == 1) break;
4530
4531 device_param->words_done = words_fin;
4532 }
4533 }
4534 else
4535 {
4536 const uint segment_size = data.segment_size;
4537
4538 char *dictfile = data.dictfile;
4539
4540 if (attack_mode == ATTACK_MODE_COMBI)
4541 {
4542 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4543 {
4544 dictfile = data.dictfile2;
4545 }
4546 }
4547
4548 FILE *fd = fopen (dictfile, "rb");
4549
4550 if (fd == NULL)
4551 {
4552 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4553
4554 return NULL;
4555 }
4556
4557 if (attack_mode == ATTACK_MODE_COMBI)
4558 {
4559 const uint combs_mode = data.combs_mode;
4560
4561 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4562 {
4563 const char *dictfilec = data.dictfile2;
4564
4565 FILE *combs_fp = fopen (dictfilec, "rb");
4566
4567 if (combs_fp == NULL)
4568 {
4569 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4570
4571 fclose (fd);
4572
4573 return NULL;
4574 }
4575
4576 device_param->combs_fp = combs_fp;
4577 }
4578 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4579 {
4580 const char *dictfilec = data.dictfile;
4581
4582 FILE *combs_fp = fopen (dictfilec, "rb");
4583
4584 if (combs_fp == NULL)
4585 {
4586 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4587
4588 fclose (fd);
4589
4590 return NULL;
4591 }
4592
4593 device_param->combs_fp = combs_fp;
4594 }
4595 }
4596
4597 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4598
4599 wl_data->buf = (char *) mymalloc (segment_size);
4600 wl_data->avail = segment_size;
4601 wl_data->incr = segment_size;
4602 wl_data->cnt = 0;
4603 wl_data->pos = 0;
4604
4605 u64 words_cur = 0;
4606
4607 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4608 {
4609 u64 words_off = 0;
4610 u64 words_fin = 0;
4611
4612 bool allow_div = true;
4613
4614 u64 max = -1;
4615
4616 while (max)
4617 {
4618 const uint work = get_work (device_param, max, allow_div);
4619
4620 allow_div = false;
4621
4622 if (work == 0) break;
4623
4624 words_off = device_param->words_off;
4625 words_fin = words_off + work;
4626
4627 char *line_buf;
4628 uint line_len;
4629
4630 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4631
4632 max = 0;
4633
4634 for ( ; words_cur < words_fin; words_cur++)
4635 {
4636 get_next_word (wl_data, fd, &line_buf, &line_len);
4637
4638 line_len = convert_from_hex (line_buf, line_len);
4639
4640 // post-process rule engine
4641
4642 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4643 {
4644 char rule_buf_out[BLOCK_SIZE] = { 0 };
4645
4646 int rule_len_out = -1;
4647
4648 if (line_len < BLOCK_SIZE)
4649 {
4650 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4651 }
4652
4653 if (rule_len_out < 0) continue;
4654
4655 line_buf = rule_buf_out;
4656 line_len = rule_len_out;
4657 }
4658
4659 if (attack_kern == ATTACK_KERN_STRAIGHT)
4660 {
4661 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4662 {
4663 max++;
4664
4665 hc_thread_mutex_lock (mux_counter);
4666
4667 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4668 {
4669 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4670 }
4671
4672 hc_thread_mutex_unlock (mux_counter);
4673
4674 continue;
4675 }
4676 }
4677 else if (attack_kern == ATTACK_KERN_COMBI)
4678 {
4679 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4680 // since we still need to combine the plains
4681
4682 if (line_len > data.pw_max)
4683 {
4684 max++;
4685
4686 hc_thread_mutex_lock (mux_counter);
4687
4688 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4689 {
4690 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4691 }
4692
4693 hc_thread_mutex_unlock (mux_counter);
4694
4695 continue;
4696 }
4697 }
4698
4699 pw_add (device_param, (u8 *) line_buf, line_len);
4700
4701 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4702
4703 if (data.devices_status == STATUS_CRACKED) break;
4704 if (data.devices_status == STATUS_ABORTED) break;
4705 if (data.devices_status == STATUS_QUIT) break;
4706 if (data.devices_status == STATUS_BYPASS) break;
4707 }
4708
4709 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4710
4711 if (data.devices_status == STATUS_CRACKED) break;
4712 if (data.devices_status == STATUS_ABORTED) break;
4713 if (data.devices_status == STATUS_QUIT) break;
4714 if (data.devices_status == STATUS_BYPASS) break;
4715 }
4716
4717 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4718
4719 if (data.devices_status == STATUS_CRACKED) break;
4720 if (data.devices_status == STATUS_ABORTED) break;
4721 if (data.devices_status == STATUS_QUIT) break;
4722 if (data.devices_status == STATUS_BYPASS) break;
4723
4724 //
4725 // flush
4726 //
4727
4728 const uint pws_cnt = device_param->pws_cnt;
4729
4730 if (pws_cnt)
4731 {
4732 run_copy (device_param, pws_cnt);
4733
4734 run_cracker (device_param, pws_cnt);
4735
4736 device_param->pws_cnt = 0;
4737
4738 if (attack_kern == ATTACK_KERN_STRAIGHT)
4739 {
4740 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4741 }
4742 else if (attack_kern == ATTACK_KERN_COMBI)
4743 {
4744 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4745 }
4746 }
4747
4748 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4749
4750 if (data.devices_status == STATUS_CRACKED) break;
4751 if (data.devices_status == STATUS_ABORTED) break;
4752 if (data.devices_status == STATUS_QUIT) break;
4753 if (data.devices_status == STATUS_BYPASS) break;
4754
4755 if (words_fin == 0) break;
4756
4757 device_param->words_done = words_fin;
4758 }
4759
4760 if (attack_mode == ATTACK_MODE_COMBI)
4761 {
4762 fclose (device_param->combs_fp);
4763 }
4764
4765 free (wl_data->buf);
4766 free (wl_data);
4767
4768 fclose (fd);
4769 }
4770
4771 device_param->kernel_accel = 0;
4772 device_param->kernel_loops = 0;
4773
4774 return NULL;
4775 }
4776
4777 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4778 {
4779 if (!device_param)
4780 {
4781 log_error ("ERROR: %s : Invalid argument", __func__);
4782
4783 exit (-1);
4784 }
4785
4786 salt_t *salt_buf = &data.salts_buf[salt_pos];
4787
4788 device_param->kernel_params_buf32[24] = salt_pos;
4789 device_param->kernel_params_buf32[27] = 1;
4790 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4791 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4792 device_param->kernel_params_buf32[30] = 0;
4793 device_param->kernel_params_buf32[31] = 1;
4794
4795 char *dictfile_old = data.dictfile;
4796
4797 const char *weak_hash_check = "weak-hash-check";
4798
4799 data.dictfile = (char *) weak_hash_check;
4800
4801 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4802
4803 data.kernel_rules_buf[0].cmds[0] = 0;
4804
4805 /**
4806 * run the kernel
4807 */
4808
4809 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4810 {
4811 run_kernel (KERN_RUN_1, device_param, 1, false);
4812 }
4813 else
4814 {
4815 run_kernel (KERN_RUN_1, device_param, 1, false);
4816
4817 uint loop_step = 16;
4818
4819 const uint iter = salt_buf->salt_iter;
4820
4821 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4822 {
4823 uint loop_left = iter - loop_pos;
4824
4825 loop_left = MIN (loop_left, loop_step);
4826
4827 device_param->kernel_params_buf32[25] = loop_pos;
4828 device_param->kernel_params_buf32[26] = loop_left;
4829
4830 run_kernel (KERN_RUN_2, device_param, 1, false);
4831 }
4832
4833 run_kernel (KERN_RUN_3, device_param, 1, false);
4834 }
4835
4836 /**
4837 * result
4838 */
4839
4840 check_cracked (device_param, salt_pos);
4841
4842 /**
4843 * cleanup
4844 */
4845
4846 device_param->kernel_params_buf32[24] = 0;
4847 device_param->kernel_params_buf32[25] = 0;
4848 device_param->kernel_params_buf32[26] = 0;
4849 device_param->kernel_params_buf32[27] = 0;
4850 device_param->kernel_params_buf32[28] = 0;
4851 device_param->kernel_params_buf32[29] = 0;
4852 device_param->kernel_params_buf32[30] = 0;
4853 device_param->kernel_params_buf32[31] = 0;
4854
4855 data.dictfile = dictfile_old;
4856
4857 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4858 }
4859
4860 // hlfmt hashcat
4861
4862 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4863 {
4864 if (data.username == 0)
4865 {
4866 *hashbuf_pos = line_buf;
4867 *hashbuf_len = line_len;
4868 }
4869 else
4870 {
4871 char *pos = line_buf;
4872 int len = line_len;
4873
4874 for (int i = 0; i < line_len; i++, pos++, len--)
4875 {
4876 if (line_buf[i] == data.separator)
4877 {
4878 pos++;
4879
4880 len--;
4881
4882 break;
4883 }
4884 }
4885
4886 *hashbuf_pos = pos;
4887 *hashbuf_len = len;
4888 }
4889 }
4890
4891 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4892 {
4893 char *pos = NULL;
4894 int len = 0;
4895
4896 int sep_cnt = 0;
4897
4898 for (int i = 0; i < line_len; i++)
4899 {
4900 if (line_buf[i] == data.separator)
4901 {
4902 sep_cnt++;
4903
4904 continue;
4905 }
4906
4907 if (sep_cnt == 0)
4908 {
4909 if (pos == NULL) pos = line_buf + i;
4910
4911 len++;
4912 }
4913 }
4914
4915 *userbuf_pos = pos;
4916 *userbuf_len = len;
4917 }
4918
4919 // hlfmt pwdump
4920
4921 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4922 {
4923 int sep_cnt = 0;
4924
4925 int sep2_len = 0;
4926 int sep3_len = 0;
4927
4928 for (int i = 0; i < line_len; i++)
4929 {
4930 if (line_buf[i] == ':')
4931 {
4932 sep_cnt++;
4933
4934 continue;
4935 }
4936
4937 if (sep_cnt == 2) sep2_len++;
4938 if (sep_cnt == 3) sep3_len++;
4939 }
4940
4941 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4942
4943 return 0;
4944 }
4945
4946 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4947 {
4948 char *pos = NULL;
4949 int len = 0;
4950
4951 int sep_cnt = 0;
4952
4953 for (int i = 0; i < line_len; i++)
4954 {
4955 if (line_buf[i] == ':')
4956 {
4957 sep_cnt++;
4958
4959 continue;
4960 }
4961
4962 if (data.hash_mode == 1000)
4963 {
4964 if (sep_cnt == 3)
4965 {
4966 if (pos == NULL) pos = line_buf + i;
4967
4968 len++;
4969 }
4970 }
4971 else if (data.hash_mode == 3000)
4972 {
4973 if (sep_cnt == 2)
4974 {
4975 if (pos == NULL) pos = line_buf + i;
4976
4977 len++;
4978 }
4979 }
4980 }
4981
4982 *hashbuf_pos = pos;
4983 *hashbuf_len = len;
4984 }
4985
4986 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4987 {
4988 char *pos = NULL;
4989 int len = 0;
4990
4991 int sep_cnt = 0;
4992
4993 for (int i = 0; i < line_len; i++)
4994 {
4995 if (line_buf[i] == ':')
4996 {
4997 sep_cnt++;
4998
4999 continue;
5000 }
5001
5002 if (sep_cnt == 0)
5003 {
5004 if (pos == NULL) pos = line_buf + i;
5005
5006 len++;
5007 }
5008 }
5009
5010 *userbuf_pos = pos;
5011 *userbuf_len = len;
5012 }
5013
5014 // hlfmt passwd
5015
5016 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5017 {
5018 int sep_cnt = 0;
5019
5020 char sep5_first = 0;
5021 char sep6_first = 0;
5022
5023 for (int i = 0; i < line_len; i++)
5024 {
5025 if (line_buf[i] == ':')
5026 {
5027 sep_cnt++;
5028
5029 continue;
5030 }
5031
5032 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5033 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5034 }
5035
5036 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5037
5038 return 0;
5039 }
5040
5041 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5042 {
5043 char *pos = NULL;
5044 int len = 0;
5045
5046 int sep_cnt = 0;
5047
5048 for (int i = 0; i < line_len; i++)
5049 {
5050 if (line_buf[i] == ':')
5051 {
5052 sep_cnt++;
5053
5054 continue;
5055 }
5056
5057 if (sep_cnt == 1)
5058 {
5059 if (pos == NULL) pos = line_buf + i;
5060
5061 len++;
5062 }
5063 }
5064
5065 *hashbuf_pos = pos;
5066 *hashbuf_len = len;
5067 }
5068
5069 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5070 {
5071 char *pos = NULL;
5072 int len = 0;
5073
5074 int sep_cnt = 0;
5075
5076 for (int i = 0; i < line_len; i++)
5077 {
5078 if (line_buf[i] == ':')
5079 {
5080 sep_cnt++;
5081
5082 continue;
5083 }
5084
5085 if (sep_cnt == 0)
5086 {
5087 if (pos == NULL) pos = line_buf + i;
5088
5089 len++;
5090 }
5091 }
5092
5093 *userbuf_pos = pos;
5094 *userbuf_len = len;
5095 }
5096
5097 // hlfmt shadow
5098
5099 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5100 {
5101 int sep_cnt = 0;
5102
5103 for (int i = 0; i < line_len; i++)
5104 {
5105 if (line_buf[i] == ':') sep_cnt++;
5106 }
5107
5108 if (sep_cnt == 8) return 1;
5109
5110 return 0;
5111 }
5112
5113 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5114 {
5115 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5116 }
5117
5118 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5119 {
5120 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5121 }
5122
5123 // hlfmt main
5124
5125 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5126 {
5127 switch (hashfile_format)
5128 {
5129 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5130 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5131 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5132 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5133 }
5134 }
5135
5136 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5137 {
5138 switch (hashfile_format)
5139 {
5140 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5141 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5142 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5143 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5144 }
5145 }
5146
5147 char *strhlfmt (const uint hashfile_format)
5148 {
5149 switch (hashfile_format)
5150 {
5151 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5152 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5153 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5154 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5155 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5156 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5157 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5158 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5159 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5160 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5161 }
5162
5163 return ((char *) "Unknown");
5164 }
5165
5166 static uint hlfmt_detect (FILE *fp, uint max_check)
5167 {
5168 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5169
5170 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5171 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5172
5173 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5174
5175 uint num_check = 0;
5176
5177 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5178
5179 while (!feof (fp))
5180 {
5181 int line_len = fgetl (fp, line_buf);
5182
5183 if (line_len == 0) continue;
5184
5185 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5186 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5187 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5188
5189 if (num_check == max_check) break;
5190
5191 num_check++;
5192 }
5193
5194 myfree (line_buf);
5195
5196 uint hashlist_format = HLFMT_HASHCAT;
5197
5198 for (int i = 1; i < HLFMTS_CNT; i++)
5199 {
5200 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5201
5202 hashlist_format = i;
5203 }
5204
5205 free (formats_cnt);
5206
5207 return hashlist_format;
5208 }
5209
5210 /**
5211 * some further helper function
5212 */
5213
5214 // wrapper around mymalloc for ADL
5215
5216 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5217 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5218 {
5219 return mymalloc (iSize);
5220 }
5221 #endif
5222
5223 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)
5224 {
5225 u64 collisions = 0;
5226
5227 const uint dgst_pos0 = data.dgst_pos0;
5228 const uint dgst_pos1 = data.dgst_pos1;
5229 const uint dgst_pos2 = data.dgst_pos2;
5230 const uint dgst_pos3 = data.dgst_pos3;
5231
5232 memset (bitmap_a, 0, bitmap_size);
5233 memset (bitmap_b, 0, bitmap_size);
5234 memset (bitmap_c, 0, bitmap_size);
5235 memset (bitmap_d, 0, bitmap_size);
5236
5237 for (uint i = 0; i < digests_cnt; i++)
5238 {
5239 uint *digest_ptr = (uint *) digests_buf_ptr;
5240
5241 digests_buf_ptr += dgst_size;
5242
5243 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5244 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5245 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5246 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5247
5248 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5249 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5250 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5251 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5252
5253 if (bitmap_a[idx0] & val0) collisions++;
5254 if (bitmap_b[idx1] & val1) collisions++;
5255 if (bitmap_c[idx2] & val2) collisions++;
5256 if (bitmap_d[idx3] & val3) collisions++;
5257
5258 bitmap_a[idx0] |= val0;
5259 bitmap_b[idx1] |= val1;
5260 bitmap_c[idx2] |= val2;
5261 bitmap_d[idx3] |= val3;
5262
5263 if (collisions >= collisions_max) return 0x7fffffff;
5264 }
5265
5266 return collisions;
5267 }
5268
5269 /**
5270 * main
5271 */
5272
5273 int main (int argc, char **argv)
5274 {
5275 /**
5276 * To help users a bit
5277 */
5278
5279 char *compute = getenv ("COMPUTE");
5280
5281 if (compute)
5282 {
5283 static char display[100];
5284
5285 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5286
5287 putenv (display);
5288 }
5289 else
5290 {
5291 if (getenv ("DISPLAY") == NULL)
5292 putenv ((char *) "DISPLAY=:0");
5293 }
5294
5295 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5296 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5297
5298 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5299 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5300
5301 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5302 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5303
5304 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5305 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5306
5307 /**
5308 * Real init
5309 */
5310
5311 memset (&data, 0, sizeof (hc_global_data_t));
5312
5313 time_t proc_start;
5314
5315 time (&proc_start);
5316
5317 data.proc_start = proc_start;
5318
5319 int myargc = argc;
5320 char **myargv = argv;
5321
5322 hc_thread_mutex_init (mux_dispatcher);
5323 hc_thread_mutex_init (mux_counter);
5324 hc_thread_mutex_init (mux_display);
5325 hc_thread_mutex_init (mux_adl);
5326
5327 /**
5328 * commandline parameters
5329 */
5330
5331 uint usage = USAGE;
5332 uint version = VERSION;
5333 uint quiet = QUIET;
5334 uint benchmark = BENCHMARK;
5335 uint benchmark_repeats = BENCHMARK_REPEATS;
5336 uint show = SHOW;
5337 uint left = LEFT;
5338 uint username = USERNAME;
5339 uint remove = REMOVE;
5340 uint remove_timer = REMOVE_TIMER;
5341 u64 skip = SKIP;
5342 u64 limit = LIMIT;
5343 uint keyspace = KEYSPACE;
5344 uint potfile_disable = POTFILE_DISABLE;
5345 char *potfile_path = NULL;
5346 uint debug_mode = DEBUG_MODE;
5347 char *debug_file = NULL;
5348 char *induction_dir = NULL;
5349 char *outfile_check_dir = NULL;
5350 uint force = FORCE;
5351 uint runtime = RUNTIME;
5352 uint hash_mode = HASH_MODE;
5353 uint attack_mode = ATTACK_MODE;
5354 uint markov_disable = MARKOV_DISABLE;
5355 uint markov_classic = MARKOV_CLASSIC;
5356 uint markov_threshold = MARKOV_THRESHOLD;
5357 char *markov_hcstat = NULL;
5358 char *outfile = NULL;
5359 uint outfile_format = OUTFILE_FORMAT;
5360 uint outfile_autohex = OUTFILE_AUTOHEX;
5361 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5362 uint restore = RESTORE;
5363 uint restore_timer = RESTORE_TIMER;
5364 uint restore_disable = RESTORE_DISABLE;
5365 uint status = STATUS;
5366 uint status_timer = STATUS_TIMER;
5367 uint status_automat = STATUS_AUTOMAT;
5368 uint loopback = LOOPBACK;
5369 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5370 char *session = NULL;
5371 uint hex_charset = HEX_CHARSET;
5372 uint hex_salt = HEX_SALT;
5373 uint hex_wordlist = HEX_WORDLIST;
5374 uint rp_gen = RP_GEN;
5375 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5376 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5377 uint rp_gen_seed = RP_GEN_SEED;
5378 char *rule_buf_l = (char *) RULE_BUF_L;
5379 char *rule_buf_r = (char *) RULE_BUF_R;
5380 uint increment = INCREMENT;
5381 uint increment_min = INCREMENT_MIN;
5382 uint increment_max = INCREMENT_MAX;
5383 char *cpu_affinity = NULL;
5384 OCL_PTR *ocl = NULL;
5385 char *opencl_devices = NULL;
5386 char *opencl_platforms = NULL;
5387 char *opencl_device_types = NULL;
5388 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5389 char *truecrypt_keyfiles = NULL;
5390 uint workload_profile = WORKLOAD_PROFILE;
5391 uint kernel_accel = KERNEL_ACCEL;
5392 uint kernel_loops = KERNEL_LOOPS;
5393 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5394 #ifdef HAVE_HWMON
5395 uint gpu_temp_abort = GPU_TEMP_ABORT;
5396 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5397 #ifdef HAVE_ADL
5398 uint powertune_enable = POWERTUNE_ENABLE;
5399 #endif
5400 #endif
5401 uint logfile_disable = LOGFILE_DISABLE;
5402 uint segment_size = SEGMENT_SIZE;
5403 uint scrypt_tmto = SCRYPT_TMTO;
5404 char separator = SEPARATOR;
5405 uint bitmap_min = BITMAP_MIN;
5406 uint bitmap_max = BITMAP_MAX;
5407 char *custom_charset_1 = NULL;
5408 char *custom_charset_2 = NULL;
5409 char *custom_charset_3 = NULL;
5410 char *custom_charset_4 = NULL;
5411
5412 #define IDX_HELP 'h'
5413 #define IDX_VERSION 'V'
5414 #define IDX_VERSION_LOWER 'v'
5415 #define IDX_QUIET 0xff02
5416 #define IDX_SHOW 0xff03
5417 #define IDX_LEFT 0xff04
5418 #define IDX_REMOVE 0xff05
5419 #define IDX_REMOVE_TIMER 0xff37
5420 #define IDX_SKIP 's'
5421 #define IDX_LIMIT 'l'
5422 #define IDX_KEYSPACE 0xff35
5423 #define IDX_POTFILE_DISABLE 0xff06
5424 #define IDX_POTFILE_PATH 0xffe0
5425 #define IDX_DEBUG_MODE 0xff43
5426 #define IDX_DEBUG_FILE 0xff44
5427 #define IDX_INDUCTION_DIR 0xff46
5428 #define IDX_OUTFILE_CHECK_DIR 0xff47
5429 #define IDX_USERNAME 0xff07
5430 #define IDX_FORCE 0xff08
5431 #define IDX_RUNTIME 0xff09
5432 #define IDX_BENCHMARK 'b'
5433 #define IDX_BENCHMARK_REPEATS 0xff78
5434 #define IDX_HASH_MODE 'm'
5435 #define IDX_ATTACK_MODE 'a'
5436 #define IDX_RP_FILE 'r'
5437 #define IDX_RP_GEN 'g'
5438 #define IDX_RP_GEN_FUNC_MIN 0xff10
5439 #define IDX_RP_GEN_FUNC_MAX 0xff11
5440 #define IDX_RP_GEN_SEED 0xff34
5441 #define IDX_RULE_BUF_L 'j'
5442 #define IDX_RULE_BUF_R 'k'
5443 #define IDX_INCREMENT 'i'
5444 #define IDX_INCREMENT_MIN 0xff12
5445 #define IDX_INCREMENT_MAX 0xff13
5446 #define IDX_OUTFILE 'o'
5447 #define IDX_OUTFILE_FORMAT 0xff14
5448 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5449 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5450 #define IDX_RESTORE 0xff15
5451 #define IDX_RESTORE_DISABLE 0xff27
5452 #define IDX_STATUS 0xff17
5453 #define IDX_STATUS_TIMER 0xff18
5454 #define IDX_STATUS_AUTOMAT 0xff50
5455 #define IDX_LOOPBACK 0xff38
5456 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5457 #define IDX_SESSION 0xff19
5458 #define IDX_HEX_CHARSET 0xff20
5459 #define IDX_HEX_SALT 0xff21
5460 #define IDX_HEX_WORDLIST 0xff40
5461 #define IDX_MARKOV_DISABLE 0xff22
5462 #define IDX_MARKOV_CLASSIC 0xff23
5463 #define IDX_MARKOV_THRESHOLD 't'
5464 #define IDX_MARKOV_HCSTAT 0xff24
5465 #define IDX_CPU_AFFINITY 0xff25
5466 #define IDX_OPENCL_DEVICES 'd'
5467 #define IDX_OPENCL_PLATFORMS 0xff72
5468 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5469 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5470 #define IDX_WORKLOAD_PROFILE 'w'
5471 #define IDX_KERNEL_ACCEL 'n'
5472 #define IDX_KERNEL_LOOPS 'u'
5473 #define IDX_GPU_TEMP_DISABLE 0xff29
5474 #define IDX_GPU_TEMP_ABORT 0xff30
5475 #define IDX_GPU_TEMP_RETAIN 0xff31
5476 #define IDX_POWERTUNE_ENABLE 0xff41
5477 #define IDX_LOGFILE_DISABLE 0xff51
5478 #define IDX_TRUECRYPT_KEYFILES 0xff52
5479 #define IDX_SCRYPT_TMTO 0xff61
5480 #define IDX_SEGMENT_SIZE 'c'
5481 #define IDX_SEPARATOR 'p'
5482 #define IDX_BITMAP_MIN 0xff70
5483 #define IDX_BITMAP_MAX 0xff71
5484 #define IDX_CUSTOM_CHARSET_1 '1'
5485 #define IDX_CUSTOM_CHARSET_2 '2'
5486 #define IDX_CUSTOM_CHARSET_3 '3'
5487 #define IDX_CUSTOM_CHARSET_4 '4'
5488
5489 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5490
5491 struct option long_options[] =
5492 {
5493 {"help", no_argument, 0, IDX_HELP},
5494 {"version", no_argument, 0, IDX_VERSION},
5495 {"quiet", no_argument, 0, IDX_QUIET},
5496 {"show", no_argument, 0, IDX_SHOW},
5497 {"left", no_argument, 0, IDX_LEFT},
5498 {"username", no_argument, 0, IDX_USERNAME},
5499 {"remove", no_argument, 0, IDX_REMOVE},
5500 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5501 {"skip", required_argument, 0, IDX_SKIP},
5502 {"limit", required_argument, 0, IDX_LIMIT},
5503 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5504 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5505 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5506 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5507 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5508 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5509 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5510 {"force", no_argument, 0, IDX_FORCE},
5511 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5512 {"benchmark-repeats", required_argument, 0, IDX_BENCHMARK_REPEATS},
5513 {"restore", no_argument, 0, IDX_RESTORE},
5514 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5515 {"status", no_argument, 0, IDX_STATUS},
5516 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5517 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5518 {"loopback", no_argument, 0, IDX_LOOPBACK},
5519 {"weak-hash-threshold",
5520 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5521 {"session", required_argument, 0, IDX_SESSION},
5522 {"runtime", required_argument, 0, IDX_RUNTIME},
5523 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5524 {"generate-rules-func-min",
5525 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5526 {"generate-rules-func-max",
5527 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5528 {"generate-rules-seed",
5529 required_argument, 0, IDX_RP_GEN_SEED},
5530 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5531 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5532 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5533 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5534 {"rules-file", required_argument, 0, IDX_RP_FILE},
5535 {"outfile", required_argument, 0, IDX_OUTFILE},
5536 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5537 {"outfile-autohex-disable",
5538 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5539 {"outfile-check-timer",
5540 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5541 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5542 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5543 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5544 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5545 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5546 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5547 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5548 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5549 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5550 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5551 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5552 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5553 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5554 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5555 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5556 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5557 #ifdef HAVE_HWMON
5558 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5559 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5560 #ifdef HAVE_ADL
5561 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5562 #endif
5563 #endif // HAVE_HWMON
5564 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5565 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5566 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5567 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5568 // deprecated
5569 {"seperator", required_argument, 0, IDX_SEPARATOR},
5570 {"separator", required_argument, 0, IDX_SEPARATOR},
5571 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5572 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5573 {"increment", no_argument, 0, IDX_INCREMENT},
5574 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5575 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5576 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5577 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5578 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5579 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5580
5581 {0, 0, 0, 0}
5582 };
5583
5584 uint rp_files_cnt = 0;
5585
5586 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5587
5588 int option_index = 0;
5589 int c = -1;
5590
5591 optind = 1;
5592 optopt = 0;
5593
5594 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5595 {
5596 switch (c)
5597 {
5598 case IDX_HELP: usage = 1; break;
5599 case IDX_VERSION:
5600 case IDX_VERSION_LOWER: version = 1; break;
5601 case IDX_RESTORE: restore = 1; break;
5602 case IDX_SESSION: session = optarg; break;
5603 case IDX_SHOW: show = 1; break;
5604 case IDX_LEFT: left = 1; break;
5605 case '?': return (-1);
5606 }
5607 }
5608
5609 if (optopt != 0)
5610 {
5611 log_error ("ERROR: Invalid argument specified");
5612
5613 return (-1);
5614 }
5615
5616 /**
5617 * exit functions
5618 */
5619
5620 if (version)
5621 {
5622 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5623
5624 return (0);
5625 }
5626
5627 if (usage)
5628 {
5629 usage_big_print (PROGNAME);
5630
5631 return (0);
5632 }
5633
5634 /**
5635 * session needs to be set, always!
5636 */
5637
5638 if (session == NULL) session = (char *) PROGNAME;
5639
5640 /**
5641 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5642 */
5643
5644 char *exec_path = get_exec_path ();
5645
5646 #ifdef LINUX
5647
5648 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5649 char *resolved_exec_path = realpath (exec_path, NULL);
5650
5651 char *install_dir = get_install_dir (resolved_exec_path);
5652 char *profile_dir = NULL;
5653 char *session_dir = NULL;
5654 char *shared_dir = NULL;
5655
5656 if (strcmp (install_dir, resolved_install_folder) == 0)
5657 {
5658 struct passwd *pw = getpwuid (getuid ());
5659
5660 const char *homedir = pw->pw_dir;
5661
5662 profile_dir = get_profile_dir (homedir);
5663 session_dir = get_session_dir (profile_dir);
5664 shared_dir = strdup (SHARED_FOLDER);
5665
5666 mkdir (profile_dir, 0700);
5667 mkdir (session_dir, 0700);
5668 }
5669 else
5670 {
5671 profile_dir = install_dir;
5672 session_dir = install_dir;
5673 shared_dir = install_dir;
5674 }
5675
5676 myfree (resolved_install_folder);
5677 myfree (resolved_exec_path);
5678
5679 #else
5680
5681 char *install_dir = get_install_dir (exec_path);
5682 char *profile_dir = install_dir;
5683 char *session_dir = install_dir;
5684 char *shared_dir = install_dir;
5685
5686 #endif
5687
5688 data.install_dir = install_dir;
5689 data.profile_dir = profile_dir;
5690 data.session_dir = session_dir;
5691 data.shared_dir = shared_dir;
5692
5693 myfree (exec_path);
5694
5695 /**
5696 * kernel cache, we need to make sure folder exist
5697 */
5698
5699 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5700
5701 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5702
5703 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5704
5705 mkdir (kernels_folder, 0700);
5706
5707 myfree (kernels_folder);
5708
5709 /**
5710 * session
5711 */
5712
5713 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5714
5715 data.session = session;
5716
5717 char *eff_restore_file = (char *) mymalloc (session_size);
5718 char *new_restore_file = (char *) mymalloc (session_size);
5719
5720 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5721 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5722
5723 data.eff_restore_file = eff_restore_file;
5724 data.new_restore_file = new_restore_file;
5725
5726 if (((show == 1) || (left == 1)) && (restore == 1))
5727 {
5728 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5729 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5730
5731 return (-1);
5732 }
5733
5734 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5735 if ((show == 1) || (left == 1))
5736 {
5737 restore_disable = 1;
5738
5739 restore = 0;
5740 }
5741
5742 data.restore_disable = restore_disable;
5743
5744 restore_data_t *rd = init_restore (argc, argv);
5745
5746 data.rd = rd;
5747
5748 /**
5749 * restore file
5750 */
5751
5752 if (restore == 1)
5753 {
5754 read_restore (eff_restore_file, rd);
5755
5756 if (rd->version_bin < RESTORE_MIN)
5757 {
5758 log_error ("ERROR: Incompatible restore-file version");
5759
5760 return (-1);
5761 }
5762
5763 myargc = rd->argc;
5764 myargv = rd->argv;
5765
5766 #ifdef _POSIX
5767 rd->pid = getpid ();
5768 #elif _WIN
5769 rd->pid = GetCurrentProcessId ();
5770 #endif
5771 }
5772
5773 uint hash_mode_chgd = 0;
5774 uint runtime_chgd = 0;
5775 uint kernel_loops_chgd = 0;
5776 uint kernel_accel_chgd = 0;
5777 uint attack_mode_chgd = 0;
5778 uint outfile_format_chgd = 0;
5779 uint rp_gen_seed_chgd = 0;
5780 uint remove_timer_chgd = 0;
5781 uint increment_min_chgd = 0;
5782 uint increment_max_chgd = 0;
5783 uint workload_profile_chgd = 0;
5784 uint opencl_vector_width_chgd = 0;
5785
5786 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5787 uint gpu_temp_retain_chgd = 0;
5788 uint gpu_temp_abort_chgd = 0;
5789 #endif
5790
5791 optind = 1;
5792 optopt = 0;
5793 option_index = 0;
5794
5795 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5796 {
5797 switch (c)
5798 {
5799 //case IDX_HELP: usage = 1; break;
5800 //case IDX_VERSION: version = 1; break;
5801 //case IDX_RESTORE: restore = 1; break;
5802 case IDX_QUIET: quiet = 1; break;
5803 //case IDX_SHOW: show = 1; break;
5804 case IDX_SHOW: break;
5805 //case IDX_LEFT: left = 1; break;
5806 case IDX_LEFT: break;
5807 case IDX_USERNAME: username = 1; break;
5808 case IDX_REMOVE: remove = 1; break;
5809 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5810 remove_timer_chgd = 1; break;
5811 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5812 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5813 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5814 case IDX_DEBUG_FILE: debug_file = optarg; break;
5815 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5816 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5817 case IDX_FORCE: force = 1; break;
5818 case IDX_SKIP: skip = atoll (optarg); break;
5819 case IDX_LIMIT: limit = atoll (optarg); break;
5820 case IDX_KEYSPACE: keyspace = 1; break;
5821 case IDX_BENCHMARK: benchmark = 1; break;
5822 case IDX_BENCHMARK_REPEATS: benchmark_repeats = atoi (optarg); break;
5823 case IDX_RESTORE: break;
5824 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5825 case IDX_STATUS: status = 1; break;
5826 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5827 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5828 case IDX_LOOPBACK: loopback = 1; break;
5829 case IDX_WEAK_HASH_THRESHOLD:
5830 weak_hash_threshold = atoi (optarg); break;
5831 //case IDX_SESSION: session = optarg; break;
5832 case IDX_SESSION: break;
5833 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5834 hash_mode_chgd = 1; break;
5835 case IDX_RUNTIME: runtime = atoi (optarg);
5836 runtime_chgd = 1; break;
5837 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5838 attack_mode_chgd = 1; break;
5839 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5840 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5841 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5842 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5843 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5844 rp_gen_seed_chgd = 1; break;
5845 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5846 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5847 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5848 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5849 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5850 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5851 case IDX_OUTFILE: outfile = optarg; break;
5852 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5853 outfile_format_chgd = 1; break;
5854 case IDX_OUTFILE_AUTOHEX_DISABLE:
5855 outfile_autohex = 0; break;
5856 case IDX_OUTFILE_CHECK_TIMER:
5857 outfile_check_timer = atoi (optarg); break;
5858 case IDX_HEX_CHARSET: hex_charset = 1; break;
5859 case IDX_HEX_SALT: hex_salt = 1; break;
5860 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5861 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5862 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5863 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5864 case IDX_OPENCL_DEVICE_TYPES:
5865 opencl_device_types = optarg; break;
5866 case IDX_OPENCL_VECTOR_WIDTH:
5867 opencl_vector_width = atoi (optarg);
5868 opencl_vector_width_chgd = 1; break;
5869 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5870 workload_profile_chgd = 1; break;
5871 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5872 kernel_accel_chgd = 1; break;
5873 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5874 kernel_loops_chgd = 1; break;
5875 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5876 #ifdef HAVE_HWMON
5877 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5878 #ifdef HAVE_ADL
5879 gpu_temp_abort_chgd = 1;
5880 #endif
5881 break;
5882 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5883 #ifdef HAVE_ADL
5884 gpu_temp_retain_chgd = 1;
5885 #endif
5886 break;
5887 #ifdef HAVE_ADL
5888 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5889 #endif
5890 #endif // HAVE_HWMON
5891 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5892 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5893 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5894 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5895 case IDX_SEPARATOR: separator = optarg[0]; break;
5896 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5897 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5898 case IDX_INCREMENT: increment = 1; break;
5899 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5900 increment_min_chgd = 1; break;
5901 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5902 increment_max_chgd = 1; break;
5903 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5904 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5905 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5906 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5907
5908 default:
5909 log_error ("ERROR: Invalid argument specified");
5910 return (-1);
5911 }
5912 }
5913
5914 if (optopt != 0)
5915 {
5916 log_error ("ERROR: Invalid argument specified");
5917
5918 return (-1);
5919 }
5920
5921 /**
5922 * Inform user things getting started,
5923 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5924 * - we do not need to check algorithm_pos
5925 */
5926
5927 if (quiet == 0)
5928 {
5929 if (benchmark == 1)
5930 {
5931 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5932
5933 log_info ("");
5934 }
5935 else if (restore == 1)
5936 {
5937 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5938
5939 log_info ("");
5940 }
5941 else
5942 {
5943 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5944
5945 log_info ("");
5946 }
5947 }
5948
5949 /**
5950 * sanity check
5951 */
5952
5953 if (attack_mode > 7)
5954 {
5955 log_error ("ERROR: Invalid attack-mode specified");
5956
5957 return (-1);
5958 }
5959
5960 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5961 {
5962 log_error ("ERROR: Invalid runtime specified");
5963
5964 return (-1);
5965 }
5966
5967 if (hash_mode_chgd && hash_mode > 13500) // just added to remove compiler warnings for hash_mode_chgd
5968 {
5969 log_error ("ERROR: Invalid hash-type specified");
5970
5971 return (-1);
5972 }
5973
5974 // renamed hash modes
5975
5976 if (hash_mode_chgd)
5977 {
5978 int n = -1;
5979
5980 switch (hash_mode)
5981 {
5982 case 123: n = 124;
5983 break;
5984 }
5985
5986 if (n >= 0)
5987 {
5988 log_error ("Old -m specified, use -m %d instead", n);
5989
5990 return (-1);
5991 }
5992 }
5993
5994 if (username == 1)
5995 {
5996 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5997 {
5998 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5999
6000 return (-1);
6001 }
6002 }
6003
6004 if (outfile_format > 16)
6005 {
6006 log_error ("ERROR: Invalid outfile-format specified");
6007
6008 return (-1);
6009 }
6010
6011 if (left == 1)
6012 {
6013 if (outfile_format_chgd == 1)
6014 {
6015 if (outfile_format > 1)
6016 {
6017 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6018
6019 return (-1);
6020 }
6021 }
6022 else
6023 {
6024 outfile_format = OUTFILE_FMT_HASH;
6025 }
6026 }
6027
6028 if (show == 1)
6029 {
6030 if (outfile_format_chgd == 1)
6031 {
6032 if ((outfile_format > 7) && (outfile_format < 16))
6033 {
6034 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6035
6036 return (-1);
6037 }
6038 }
6039 }
6040
6041 if (increment_min < INCREMENT_MIN)
6042 {
6043 log_error ("ERROR: Invalid increment-min specified");
6044
6045 return (-1);
6046 }
6047
6048 if (increment_max > INCREMENT_MAX)
6049 {
6050 log_error ("ERROR: Invalid increment-max specified");
6051
6052 return (-1);
6053 }
6054
6055 if (increment_min > increment_max)
6056 {
6057 log_error ("ERROR: Invalid increment-min specified");
6058
6059 return (-1);
6060 }
6061
6062 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6063 {
6064 log_error ("ERROR: increment is not allowed in attack-mode 0");
6065
6066 return (-1);
6067 }
6068
6069 if ((increment == 0) && (increment_min_chgd == 1))
6070 {
6071 log_error ("ERROR: increment-min is only supported together with increment switch");
6072
6073 return (-1);
6074 }
6075
6076 if ((increment == 0) && (increment_max_chgd == 1))
6077 {
6078 log_error ("ERROR: increment-max is only supported together with increment switch");
6079
6080 return (-1);
6081 }
6082
6083 if (rp_files_cnt && rp_gen)
6084 {
6085 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6086
6087 return (-1);
6088 }
6089
6090 if (rp_files_cnt || rp_gen)
6091 {
6092 if (attack_mode != ATTACK_MODE_STRAIGHT)
6093 {
6094 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6095
6096 return (-1);
6097 }
6098 }
6099
6100 if (rp_gen_func_min > rp_gen_func_max)
6101 {
6102 log_error ("ERROR: Invalid rp-gen-func-min specified");
6103
6104 return (-1);
6105 }
6106
6107 if (kernel_accel_chgd == 1)
6108 {
6109 if (kernel_accel < 1)
6110 {
6111 log_error ("ERROR: Invalid kernel-accel specified");
6112
6113 return (-1);
6114 }
6115
6116 if (kernel_accel > 1024)
6117 {
6118 log_error ("ERROR: Invalid kernel-accel specified");
6119
6120 return (-1);
6121 }
6122 }
6123
6124 if (kernel_loops_chgd == 1)
6125 {
6126 if (kernel_loops < 1)
6127 {
6128 log_error ("ERROR: Invalid kernel-loops specified");
6129
6130 return (-1);
6131 }
6132
6133 if (kernel_loops > 1024)
6134 {
6135 log_error ("ERROR: Invalid kernel-loops specified");
6136
6137 return (-1);
6138 }
6139 }
6140
6141 if ((workload_profile < 1) || (workload_profile > 3))
6142 {
6143 log_error ("ERROR: workload-profile %i not available", workload_profile);
6144
6145 return (-1);
6146 }
6147
6148 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6149 {
6150 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6151
6152 return (-1);
6153 }
6154
6155 if (show == 1 || left == 1)
6156 {
6157 attack_mode = ATTACK_MODE_NONE;
6158
6159 if (remove == 1)
6160 {
6161 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6162
6163 return (-1);
6164 }
6165
6166 if (potfile_disable == 1)
6167 {
6168 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6169
6170 return (-1);
6171 }
6172 }
6173
6174 uint attack_kern = ATTACK_KERN_NONE;
6175
6176 switch (attack_mode)
6177 {
6178 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6179 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6180 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6181 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6182 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6183 }
6184
6185 if (benchmark == 0)
6186 {
6187 if (keyspace == 1)
6188 {
6189 int num_additional_params = 1;
6190
6191 if (attack_kern == ATTACK_KERN_COMBI)
6192 {
6193 num_additional_params = 2;
6194 }
6195
6196 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6197
6198 if (keyspace_wordlist_specified == 0) optind--;
6199 }
6200
6201 if (attack_kern == ATTACK_KERN_NONE)
6202 {
6203 if ((optind + 1) != myargc)
6204 {
6205 usage_mini_print (myargv[0]);
6206
6207 return (-1);
6208 }
6209 }
6210 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6211 {
6212 if ((optind + 1) > myargc)
6213 {
6214 usage_mini_print (myargv[0]);
6215
6216 return (-1);
6217 }
6218 }
6219 else if (attack_kern == ATTACK_KERN_COMBI)
6220 {
6221 if ((optind + 3) != myargc)
6222 {
6223 usage_mini_print (myargv[0]);
6224
6225 return (-1);
6226 }
6227 }
6228 else if (attack_kern == ATTACK_KERN_BF)
6229 {
6230 if ((optind + 1) > myargc)
6231 {
6232 usage_mini_print (myargv[0]);
6233
6234 return (-1);
6235 }
6236 }
6237 else
6238 {
6239 usage_mini_print (myargv[0]);
6240
6241 return (-1);
6242 }
6243 }
6244 else
6245 {
6246 if (myargv[optind] != 0)
6247 {
6248 log_error ("ERROR: Invalid argument for benchmark mode specified");
6249
6250 return (-1);
6251 }
6252
6253 if (attack_mode_chgd == 1)
6254 {
6255 if (attack_mode != ATTACK_MODE_BF)
6256 {
6257 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6258
6259 return (-1);
6260 }
6261 }
6262 }
6263
6264 if (skip != 0 && limit != 0)
6265 {
6266 limit += skip;
6267 }
6268
6269 if (keyspace == 1)
6270 {
6271 if (show == 1)
6272 {
6273 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6274
6275 return (-1);
6276 }
6277 else if (left == 1)
6278 {
6279 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6280
6281 return (-1);
6282 }
6283
6284 potfile_disable = 1;
6285
6286 restore_disable = 1;
6287
6288 restore = 0;
6289
6290 weak_hash_threshold = 0;
6291
6292 quiet = 1;
6293 }
6294
6295 if (remove_timer_chgd == 1)
6296 {
6297 if (remove == 0)
6298 {
6299 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6300
6301 return (-1);
6302 }
6303
6304 if (remove_timer < 1)
6305 {
6306 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6307
6308 return (-1);
6309 }
6310 }
6311
6312 if (loopback == 1)
6313 {
6314 if (attack_mode == ATTACK_MODE_BF)
6315 {
6316 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6317
6318 return (-1);
6319 }
6320 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6321 {
6322 if ((rp_files_cnt == 0) && (rp_gen == 0))
6323 {
6324 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6325
6326 return (-1);
6327 }
6328 }
6329 }
6330
6331 if (debug_mode > 0)
6332 {
6333 if (attack_mode != ATTACK_MODE_STRAIGHT)
6334 {
6335 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6336
6337 return (-1);
6338 }
6339
6340 if ((rp_files_cnt == 0) && (rp_gen == 0))
6341 {
6342 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6343
6344 return (-1);
6345 }
6346 }
6347
6348 if (debug_mode > 4)
6349 {
6350 log_error ("ERROR: Invalid debug-mode specified");
6351
6352 return (-1);
6353 }
6354
6355 if (debug_file != NULL)
6356 {
6357 if (debug_mode < 1)
6358 {
6359 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6360
6361 return (-1);
6362 }
6363 }
6364
6365 if (induction_dir != NULL)
6366 {
6367 if (attack_mode == ATTACK_MODE_BF)
6368 {
6369 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6370
6371 return (-1);
6372 }
6373 }
6374
6375 if (attack_mode != ATTACK_MODE_STRAIGHT)
6376 {
6377 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6378 {
6379 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6380
6381 return (-1);
6382 }
6383
6384 weak_hash_threshold = 0;
6385 }
6386
6387 /**
6388 * induction directory
6389 */
6390
6391 char *induction_directory = NULL;
6392
6393 if (attack_mode != ATTACK_MODE_BF)
6394 {
6395 if (induction_dir == NULL)
6396 {
6397 induction_directory = (char *) mymalloc (session_size);
6398
6399 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6400
6401 // create induction folder if it does not already exist
6402
6403 if (keyspace == 0)
6404 {
6405 if (rmdir (induction_directory) == -1)
6406 {
6407 if (errno == ENOENT)
6408 {
6409 // good, we can ignore
6410 }
6411 else if (errno == ENOTEMPTY)
6412 {
6413 char *induction_directory_mv = (char *) mymalloc (session_size);
6414
6415 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6416
6417 if (rename (induction_directory, induction_directory_mv) != 0)
6418 {
6419 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6420
6421 return (-1);
6422 }
6423 }
6424 else
6425 {
6426 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6427
6428 return (-1);
6429 }
6430 }
6431
6432 if (mkdir (induction_directory, 0700) == -1)
6433 {
6434 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6435
6436 return (-1);
6437 }
6438 }
6439 }
6440 else
6441 {
6442 induction_directory = induction_dir;
6443 }
6444 }
6445
6446 data.induction_directory = induction_directory;
6447
6448 /**
6449 * loopback
6450 */
6451
6452 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6453
6454 char *loopback_file = (char *) mymalloc (loopback_size);
6455
6456 /**
6457 * tuning db
6458 */
6459
6460 char tuning_db_file[256] = { 0 };
6461
6462 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6463
6464 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6465
6466 /**
6467 * outfile-check directory
6468 */
6469
6470 char *outfile_check_directory = NULL;
6471
6472 if (outfile_check_dir == NULL)
6473 {
6474 outfile_check_directory = (char *) mymalloc (session_size);
6475
6476 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6477 }
6478 else
6479 {
6480 outfile_check_directory = outfile_check_dir;
6481 }
6482
6483 data.outfile_check_directory = outfile_check_directory;
6484
6485 if (keyspace == 0)
6486 {
6487 struct stat outfile_check_stat;
6488
6489 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6490 {
6491 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6492
6493 if (is_dir == 0)
6494 {
6495 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6496
6497 return (-1);
6498 }
6499 }
6500 else if (outfile_check_dir == NULL)
6501 {
6502 if (mkdir (outfile_check_directory, 0700) == -1)
6503 {
6504 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6505
6506 return (-1);
6507 }
6508 }
6509 }
6510
6511 /**
6512 * special other stuff
6513 */
6514
6515 if (hash_mode == 9710)
6516 {
6517 outfile_format = 5;
6518 outfile_format_chgd = 1;
6519 }
6520
6521 if (hash_mode == 9810)
6522 {
6523 outfile_format = 5;
6524 outfile_format_chgd = 1;
6525 }
6526
6527 if (hash_mode == 10410)
6528 {
6529 outfile_format = 5;
6530 outfile_format_chgd = 1;
6531 }
6532
6533 /**
6534 * store stuff
6535 */
6536
6537 data.hash_mode = hash_mode;
6538 data.restore = restore;
6539 data.restore_timer = restore_timer;
6540 data.restore_disable = restore_disable;
6541 data.status = status;
6542 data.status_timer = status_timer;
6543 data.status_automat = status_automat;
6544 data.loopback = loopback;
6545 data.runtime = runtime;
6546 data.remove = remove;
6547 data.remove_timer = remove_timer;
6548 data.debug_mode = debug_mode;
6549 data.debug_file = debug_file;
6550 data.username = username;
6551 data.quiet = quiet;
6552 data.outfile = outfile;
6553 data.outfile_format = outfile_format;
6554 data.outfile_autohex = outfile_autohex;
6555 data.hex_charset = hex_charset;
6556 data.hex_salt = hex_salt;
6557 data.hex_wordlist = hex_wordlist;
6558 data.separator = separator;
6559 data.rp_files = rp_files;
6560 data.rp_files_cnt = rp_files_cnt;
6561 data.rp_gen = rp_gen;
6562 data.rp_gen_seed = rp_gen_seed;
6563 data.force = force;
6564 data.benchmark = benchmark;
6565 data.benchmark_repeats = benchmark_repeats;
6566 data.skip = skip;
6567 data.limit = limit;
6568 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6569 data.powertune_enable = powertune_enable;
6570 #endif
6571 data.logfile_disable = logfile_disable;
6572 data.truecrypt_keyfiles = truecrypt_keyfiles;
6573 data.scrypt_tmto = scrypt_tmto;
6574 data.workload_profile = workload_profile;
6575
6576 /**
6577 * cpu affinity
6578 */
6579
6580 if (cpu_affinity)
6581 {
6582 set_cpu_affinity (cpu_affinity);
6583 }
6584
6585 if (rp_gen_seed_chgd == 0)
6586 {
6587 srand (proc_start);
6588 }
6589 else
6590 {
6591 srand (rp_gen_seed);
6592 }
6593
6594 /**
6595 * logfile init
6596 */
6597
6598 if (logfile_disable == 0)
6599 {
6600 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6601
6602 char *logfile = (char *) mymalloc (logfile_size);
6603
6604 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6605
6606 data.logfile = logfile;
6607
6608 char *topid = logfile_generate_topid ();
6609
6610 data.topid = topid;
6611 }
6612
6613 // logfile_append() checks for logfile_disable internally to make it easier from here
6614
6615 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6616 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6617 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6618 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6619 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6620 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6621 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6622 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6623 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6624 #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));
6625
6626 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6627 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6628 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6629 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6630 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6631 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6632 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6633 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6634
6635 logfile_top_msg ("START");
6636
6637 logfile_top_uint (attack_mode);
6638 logfile_top_uint (attack_kern);
6639 logfile_top_uint (benchmark);
6640 logfile_top_uint (benchmark_repeats);
6641 logfile_top_uint (bitmap_min);
6642 logfile_top_uint (bitmap_max);
6643 logfile_top_uint (debug_mode);
6644 logfile_top_uint (force);
6645 logfile_top_uint (kernel_accel);
6646 logfile_top_uint (kernel_loops);
6647 logfile_top_uint (gpu_temp_disable);
6648 #ifdef HAVE_HWMON
6649 logfile_top_uint (gpu_temp_abort);
6650 logfile_top_uint (gpu_temp_retain);
6651 #endif
6652 logfile_top_uint (hash_mode);
6653 logfile_top_uint (hex_charset);
6654 logfile_top_uint (hex_salt);
6655 logfile_top_uint (hex_wordlist);
6656 logfile_top_uint (increment);
6657 logfile_top_uint (increment_max);
6658 logfile_top_uint (increment_min);
6659 logfile_top_uint (keyspace);
6660 logfile_top_uint (left);
6661 logfile_top_uint (logfile_disable);
6662 logfile_top_uint (loopback);
6663 logfile_top_uint (markov_classic);
6664 logfile_top_uint (markov_disable);
6665 logfile_top_uint (markov_threshold);
6666 logfile_top_uint (outfile_autohex);
6667 logfile_top_uint (outfile_check_timer);
6668 logfile_top_uint (outfile_format);
6669 logfile_top_uint (potfile_disable);
6670 logfile_top_string (potfile_path);
6671 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6672 logfile_top_uint (powertune_enable);
6673 #endif
6674 logfile_top_uint (scrypt_tmto);
6675 logfile_top_uint (quiet);
6676 logfile_top_uint (remove);
6677 logfile_top_uint (remove_timer);
6678 logfile_top_uint (restore);
6679 logfile_top_uint (restore_disable);
6680 logfile_top_uint (restore_timer);
6681 logfile_top_uint (rp_gen);
6682 logfile_top_uint (rp_gen_func_max);
6683 logfile_top_uint (rp_gen_func_min);
6684 logfile_top_uint (rp_gen_seed);
6685 logfile_top_uint (runtime);
6686 logfile_top_uint (segment_size);
6687 logfile_top_uint (show);
6688 logfile_top_uint (status);
6689 logfile_top_uint (status_automat);
6690 logfile_top_uint (status_timer);
6691 logfile_top_uint (usage);
6692 logfile_top_uint (username);
6693 logfile_top_uint (version);
6694 logfile_top_uint (weak_hash_threshold);
6695 logfile_top_uint (workload_profile);
6696 logfile_top_uint64 (limit);
6697 logfile_top_uint64 (skip);
6698 logfile_top_char (separator);
6699 logfile_top_string (cpu_affinity);
6700 logfile_top_string (custom_charset_1);
6701 logfile_top_string (custom_charset_2);
6702 logfile_top_string (custom_charset_3);
6703 logfile_top_string (custom_charset_4);
6704 logfile_top_string (debug_file);
6705 logfile_top_string (opencl_devices);
6706 logfile_top_string (opencl_platforms);
6707 logfile_top_string (opencl_device_types);
6708 logfile_top_uint (opencl_vector_width);
6709 logfile_top_string (induction_dir);
6710 logfile_top_string (markov_hcstat);
6711 logfile_top_string (outfile);
6712 logfile_top_string (outfile_check_dir);
6713 logfile_top_string (rule_buf_l);
6714 logfile_top_string (rule_buf_r);
6715 logfile_top_string (session);
6716 logfile_top_string (truecrypt_keyfiles);
6717
6718 /**
6719 * Init OpenCL library loader
6720 */
6721
6722 if (keyspace == 0)
6723 {
6724 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6725
6726 ocl_init (ocl);
6727
6728 data.ocl = ocl;
6729 }
6730
6731 /**
6732 * OpenCL platform selection
6733 */
6734
6735 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6736
6737 /**
6738 * OpenCL device selection
6739 */
6740
6741 u32 devices_filter = setup_devices_filter (opencl_devices);
6742
6743 /**
6744 * OpenCL device type selection
6745 */
6746
6747 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6748
6749 /**
6750 * benchmark
6751 */
6752
6753 if (benchmark == 1)
6754 {
6755 /**
6756 * disable useless stuff for benchmark
6757 */
6758
6759 status_timer = 0;
6760 restore_timer = 0;
6761 restore_disable = 1;
6762 potfile_disable = 1;
6763 weak_hash_threshold = 0;
6764 gpu_temp_disable = 1;
6765
6766 data.status_timer = status_timer;
6767 data.restore_timer = restore_timer;
6768 data.restore_disable = restore_disable;
6769
6770 /**
6771 * force attack mode to be bruteforce
6772 */
6773
6774 attack_mode = ATTACK_MODE_BF;
6775 attack_kern = ATTACK_KERN_BF;
6776
6777 if (workload_profile_chgd == 0)
6778 {
6779 workload_profile = 3;
6780
6781 data.workload_profile = workload_profile;
6782 }
6783 }
6784
6785 /**
6786 * config
6787 */
6788
6789 uint hash_type = 0;
6790 uint salt_type = 0;
6791 uint attack_exec = 0;
6792 uint opts_type = 0;
6793 uint kern_type = 0;
6794 uint dgst_size = 0;
6795 uint esalt_size = 0;
6796 uint opti_type = 0;
6797 uint dgst_pos0 = -1;
6798 uint dgst_pos1 = -1;
6799 uint dgst_pos2 = -1;
6800 uint dgst_pos3 = -1;
6801
6802 int (*parse_func) (char *, uint, hash_t *);
6803 int (*sort_by_digest) (const void *, const void *);
6804
6805 uint algorithm_pos = 0;
6806 uint algorithm_max = 1;
6807
6808 uint *algorithms = default_benchmark_algorithms;
6809
6810 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6811
6812 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6813 {
6814 /*
6815 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6816 * the following algos are skipped entirely
6817 */
6818
6819 if (algorithm_pos > 0)
6820 {
6821 local_free (rd);
6822
6823 rd = init_restore (argc, argv);
6824
6825 data.rd = rd;
6826 }
6827
6828 /**
6829 * update hash_mode in case of multihash benchmark
6830 */
6831
6832 if (benchmark == 1)
6833 {
6834 if (hash_mode_chgd == 0)
6835 {
6836 hash_mode = algorithms[algorithm_pos];
6837
6838 data.hash_mode = hash_mode;
6839 }
6840
6841 quiet = 1;
6842
6843 data.quiet = quiet;
6844 }
6845
6846 switch (hash_mode)
6847 {
6848 case 0: hash_type = HASH_TYPE_MD5;
6849 salt_type = SALT_TYPE_NONE;
6850 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6851 opts_type = OPTS_TYPE_PT_GENERATE_LE
6852 | OPTS_TYPE_PT_ADD80
6853 | OPTS_TYPE_PT_ADDBITS14;
6854 kern_type = KERN_TYPE_MD5;
6855 dgst_size = DGST_SIZE_4_4;
6856 parse_func = md5_parse_hash;
6857 sort_by_digest = sort_by_digest_4_4;
6858 opti_type = OPTI_TYPE_ZERO_BYTE
6859 | OPTI_TYPE_PRECOMPUTE_INIT
6860 | OPTI_TYPE_PRECOMPUTE_MERKLE
6861 | OPTI_TYPE_MEET_IN_MIDDLE
6862 | OPTI_TYPE_EARLY_SKIP
6863 | OPTI_TYPE_NOT_ITERATED
6864 | OPTI_TYPE_NOT_SALTED
6865 | OPTI_TYPE_RAW_HASH;
6866 dgst_pos0 = 0;
6867 dgst_pos1 = 3;
6868 dgst_pos2 = 2;
6869 dgst_pos3 = 1;
6870 break;
6871
6872 case 10: hash_type = HASH_TYPE_MD5;
6873 salt_type = SALT_TYPE_INTERN;
6874 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6875 opts_type = OPTS_TYPE_PT_GENERATE_LE
6876 | OPTS_TYPE_ST_ADD80
6877 | OPTS_TYPE_ST_ADDBITS14;
6878 kern_type = KERN_TYPE_MD5_PWSLT;
6879 dgst_size = DGST_SIZE_4_4;
6880 parse_func = md5s_parse_hash;
6881 sort_by_digest = sort_by_digest_4_4;
6882 opti_type = OPTI_TYPE_ZERO_BYTE
6883 | OPTI_TYPE_PRECOMPUTE_INIT
6884 | OPTI_TYPE_PRECOMPUTE_MERKLE
6885 | OPTI_TYPE_MEET_IN_MIDDLE
6886 | OPTI_TYPE_EARLY_SKIP
6887 | OPTI_TYPE_NOT_ITERATED
6888 | OPTI_TYPE_APPENDED_SALT
6889 | OPTI_TYPE_RAW_HASH;
6890 dgst_pos0 = 0;
6891 dgst_pos1 = 3;
6892 dgst_pos2 = 2;
6893 dgst_pos3 = 1;
6894 break;
6895
6896 case 11: hash_type = HASH_TYPE_MD5;
6897 salt_type = SALT_TYPE_INTERN;
6898 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6899 opts_type = OPTS_TYPE_PT_GENERATE_LE
6900 | OPTS_TYPE_ST_ADD80
6901 | OPTS_TYPE_ST_ADDBITS14;
6902 kern_type = KERN_TYPE_MD5_PWSLT;
6903 dgst_size = DGST_SIZE_4_4;
6904 parse_func = joomla_parse_hash;
6905 sort_by_digest = sort_by_digest_4_4;
6906 opti_type = OPTI_TYPE_ZERO_BYTE
6907 | OPTI_TYPE_PRECOMPUTE_INIT
6908 | OPTI_TYPE_PRECOMPUTE_MERKLE
6909 | OPTI_TYPE_MEET_IN_MIDDLE
6910 | OPTI_TYPE_EARLY_SKIP
6911 | OPTI_TYPE_NOT_ITERATED
6912 | OPTI_TYPE_APPENDED_SALT
6913 | OPTI_TYPE_RAW_HASH;
6914 dgst_pos0 = 0;
6915 dgst_pos1 = 3;
6916 dgst_pos2 = 2;
6917 dgst_pos3 = 1;
6918 break;
6919
6920 case 12: hash_type = HASH_TYPE_MD5;
6921 salt_type = SALT_TYPE_INTERN;
6922 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6923 opts_type = OPTS_TYPE_PT_GENERATE_LE
6924 | OPTS_TYPE_ST_ADD80
6925 | OPTS_TYPE_ST_ADDBITS14;
6926 kern_type = KERN_TYPE_MD5_PWSLT;
6927 dgst_size = DGST_SIZE_4_4;
6928 parse_func = postgresql_parse_hash;
6929 sort_by_digest = sort_by_digest_4_4;
6930 opti_type = OPTI_TYPE_ZERO_BYTE
6931 | OPTI_TYPE_PRECOMPUTE_INIT
6932 | OPTI_TYPE_PRECOMPUTE_MERKLE
6933 | OPTI_TYPE_MEET_IN_MIDDLE
6934 | OPTI_TYPE_EARLY_SKIP
6935 | OPTI_TYPE_NOT_ITERATED
6936 | OPTI_TYPE_APPENDED_SALT
6937 | OPTI_TYPE_RAW_HASH;
6938 dgst_pos0 = 0;
6939 dgst_pos1 = 3;
6940 dgst_pos2 = 2;
6941 dgst_pos3 = 1;
6942 break;
6943
6944 case 20: hash_type = HASH_TYPE_MD5;
6945 salt_type = SALT_TYPE_INTERN;
6946 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6947 opts_type = OPTS_TYPE_PT_GENERATE_LE
6948 | OPTS_TYPE_PT_ADD80
6949 | OPTS_TYPE_PT_ADDBITS14;
6950 kern_type = KERN_TYPE_MD5_SLTPW;
6951 dgst_size = DGST_SIZE_4_4;
6952 parse_func = md5s_parse_hash;
6953 sort_by_digest = sort_by_digest_4_4;
6954 opti_type = OPTI_TYPE_ZERO_BYTE
6955 | OPTI_TYPE_PRECOMPUTE_INIT
6956 | OPTI_TYPE_PRECOMPUTE_MERKLE
6957 | OPTI_TYPE_EARLY_SKIP
6958 | OPTI_TYPE_NOT_ITERATED
6959 | OPTI_TYPE_PREPENDED_SALT
6960 | OPTI_TYPE_RAW_HASH;
6961 dgst_pos0 = 0;
6962 dgst_pos1 = 3;
6963 dgst_pos2 = 2;
6964 dgst_pos3 = 1;
6965 break;
6966
6967 case 21: hash_type = HASH_TYPE_MD5;
6968 salt_type = SALT_TYPE_INTERN;
6969 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6970 opts_type = OPTS_TYPE_PT_GENERATE_LE
6971 | OPTS_TYPE_PT_ADD80
6972 | OPTS_TYPE_PT_ADDBITS14;
6973 kern_type = KERN_TYPE_MD5_SLTPW;
6974 dgst_size = DGST_SIZE_4_4;
6975 parse_func = osc_parse_hash;
6976 sort_by_digest = sort_by_digest_4_4;
6977 opti_type = OPTI_TYPE_ZERO_BYTE
6978 | OPTI_TYPE_PRECOMPUTE_INIT
6979 | OPTI_TYPE_PRECOMPUTE_MERKLE
6980 | OPTI_TYPE_EARLY_SKIP
6981 | OPTI_TYPE_NOT_ITERATED
6982 | OPTI_TYPE_PREPENDED_SALT
6983 | OPTI_TYPE_RAW_HASH;
6984 dgst_pos0 = 0;
6985 dgst_pos1 = 3;
6986 dgst_pos2 = 2;
6987 dgst_pos3 = 1;
6988 break;
6989
6990 case 22: hash_type = HASH_TYPE_MD5;
6991 salt_type = SALT_TYPE_EMBEDDED;
6992 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6993 opts_type = OPTS_TYPE_PT_GENERATE_LE
6994 | OPTS_TYPE_PT_ADD80
6995 | OPTS_TYPE_PT_ADDBITS14;
6996 kern_type = KERN_TYPE_MD5_SLTPW;
6997 dgst_size = DGST_SIZE_4_4;
6998 parse_func = netscreen_parse_hash;
6999 sort_by_digest = sort_by_digest_4_4;
7000 opti_type = OPTI_TYPE_ZERO_BYTE
7001 | OPTI_TYPE_PRECOMPUTE_INIT
7002 | OPTI_TYPE_PRECOMPUTE_MERKLE
7003 | OPTI_TYPE_EARLY_SKIP
7004 | OPTI_TYPE_NOT_ITERATED
7005 | OPTI_TYPE_PREPENDED_SALT
7006 | OPTI_TYPE_RAW_HASH;
7007 dgst_pos0 = 0;
7008 dgst_pos1 = 3;
7009 dgst_pos2 = 2;
7010 dgst_pos3 = 1;
7011 break;
7012
7013 case 23: hash_type = HASH_TYPE_MD5;
7014 salt_type = SALT_TYPE_EMBEDDED;
7015 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7016 opts_type = OPTS_TYPE_PT_GENERATE_LE
7017 | OPTS_TYPE_PT_ADD80
7018 | OPTS_TYPE_PT_ADDBITS14;
7019 kern_type = KERN_TYPE_MD5_SLTPW;
7020 dgst_size = DGST_SIZE_4_4;
7021 parse_func = skype_parse_hash;
7022 sort_by_digest = sort_by_digest_4_4;
7023 opti_type = OPTI_TYPE_ZERO_BYTE
7024 | OPTI_TYPE_PRECOMPUTE_INIT
7025 | OPTI_TYPE_PRECOMPUTE_MERKLE
7026 | OPTI_TYPE_EARLY_SKIP
7027 | OPTI_TYPE_NOT_ITERATED
7028 | OPTI_TYPE_PREPENDED_SALT
7029 | OPTI_TYPE_RAW_HASH;
7030 dgst_pos0 = 0;
7031 dgst_pos1 = 3;
7032 dgst_pos2 = 2;
7033 dgst_pos3 = 1;
7034 break;
7035
7036 case 30: hash_type = HASH_TYPE_MD5;
7037 salt_type = SALT_TYPE_INTERN;
7038 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7039 opts_type = OPTS_TYPE_PT_GENERATE_LE
7040 | OPTS_TYPE_PT_UNICODE
7041 | OPTS_TYPE_ST_ADD80
7042 | OPTS_TYPE_ST_ADDBITS14;
7043 kern_type = KERN_TYPE_MD5_PWUSLT;
7044 dgst_size = DGST_SIZE_4_4;
7045 parse_func = md5s_parse_hash;
7046 sort_by_digest = sort_by_digest_4_4;
7047 opti_type = OPTI_TYPE_ZERO_BYTE
7048 | OPTI_TYPE_PRECOMPUTE_INIT
7049 | OPTI_TYPE_PRECOMPUTE_MERKLE
7050 | OPTI_TYPE_MEET_IN_MIDDLE
7051 | OPTI_TYPE_EARLY_SKIP
7052 | OPTI_TYPE_NOT_ITERATED
7053 | OPTI_TYPE_APPENDED_SALT
7054 | OPTI_TYPE_RAW_HASH;
7055 dgst_pos0 = 0;
7056 dgst_pos1 = 3;
7057 dgst_pos2 = 2;
7058 dgst_pos3 = 1;
7059 break;
7060
7061 case 40: hash_type = HASH_TYPE_MD5;
7062 salt_type = SALT_TYPE_INTERN;
7063 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7064 opts_type = OPTS_TYPE_PT_GENERATE_LE
7065 | OPTS_TYPE_PT_ADD80
7066 | OPTS_TYPE_PT_ADDBITS14
7067 | OPTS_TYPE_PT_UNICODE;
7068 kern_type = KERN_TYPE_MD5_SLTPWU;
7069 dgst_size = DGST_SIZE_4_4;
7070 parse_func = md5s_parse_hash;
7071 sort_by_digest = sort_by_digest_4_4;
7072 opti_type = OPTI_TYPE_ZERO_BYTE
7073 | OPTI_TYPE_PRECOMPUTE_INIT
7074 | OPTI_TYPE_PRECOMPUTE_MERKLE
7075 | OPTI_TYPE_EARLY_SKIP
7076 | OPTI_TYPE_NOT_ITERATED
7077 | OPTI_TYPE_PREPENDED_SALT
7078 | OPTI_TYPE_RAW_HASH;
7079 dgst_pos0 = 0;
7080 dgst_pos1 = 3;
7081 dgst_pos2 = 2;
7082 dgst_pos3 = 1;
7083 break;
7084
7085 case 50: hash_type = HASH_TYPE_MD5;
7086 salt_type = SALT_TYPE_INTERN;
7087 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7088 opts_type = OPTS_TYPE_PT_GENERATE_LE
7089 | OPTS_TYPE_ST_ADD80
7090 | OPTS_TYPE_ST_ADDBITS14;
7091 kern_type = KERN_TYPE_HMACMD5_PW;
7092 dgst_size = DGST_SIZE_4_4;
7093 parse_func = hmacmd5_parse_hash;
7094 sort_by_digest = sort_by_digest_4_4;
7095 opti_type = OPTI_TYPE_ZERO_BYTE
7096 | OPTI_TYPE_NOT_ITERATED;
7097 dgst_pos0 = 0;
7098 dgst_pos1 = 3;
7099 dgst_pos2 = 2;
7100 dgst_pos3 = 1;
7101 break;
7102
7103 case 60: hash_type = HASH_TYPE_MD5;
7104 salt_type = SALT_TYPE_INTERN;
7105 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7106 opts_type = OPTS_TYPE_PT_GENERATE_LE
7107 | OPTS_TYPE_PT_ADD80
7108 | OPTS_TYPE_PT_ADDBITS14;
7109 kern_type = KERN_TYPE_HMACMD5_SLT;
7110 dgst_size = DGST_SIZE_4_4;
7111 parse_func = hmacmd5_parse_hash;
7112 sort_by_digest = sort_by_digest_4_4;
7113 opti_type = OPTI_TYPE_ZERO_BYTE
7114 | OPTI_TYPE_NOT_ITERATED;
7115 dgst_pos0 = 0;
7116 dgst_pos1 = 3;
7117 dgst_pos2 = 2;
7118 dgst_pos3 = 1;
7119 break;
7120
7121 case 100: hash_type = HASH_TYPE_SHA1;
7122 salt_type = SALT_TYPE_NONE;
7123 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7124 opts_type = OPTS_TYPE_PT_GENERATE_BE
7125 | OPTS_TYPE_PT_ADD80
7126 | OPTS_TYPE_PT_ADDBITS15;
7127 kern_type = KERN_TYPE_SHA1;
7128 dgst_size = DGST_SIZE_4_5;
7129 parse_func = sha1_parse_hash;
7130 sort_by_digest = sort_by_digest_4_5;
7131 opti_type = OPTI_TYPE_ZERO_BYTE
7132 | OPTI_TYPE_PRECOMPUTE_INIT
7133 | OPTI_TYPE_PRECOMPUTE_MERKLE
7134 | OPTI_TYPE_EARLY_SKIP
7135 | OPTI_TYPE_NOT_ITERATED
7136 | OPTI_TYPE_NOT_SALTED
7137 | OPTI_TYPE_RAW_HASH;
7138 dgst_pos0 = 3;
7139 dgst_pos1 = 4;
7140 dgst_pos2 = 2;
7141 dgst_pos3 = 1;
7142 break;
7143
7144 case 101: hash_type = HASH_TYPE_SHA1;
7145 salt_type = SALT_TYPE_NONE;
7146 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7147 opts_type = OPTS_TYPE_PT_GENERATE_BE
7148 | OPTS_TYPE_PT_ADD80
7149 | OPTS_TYPE_PT_ADDBITS15;
7150 kern_type = KERN_TYPE_SHA1;
7151 dgst_size = DGST_SIZE_4_5;
7152 parse_func = sha1b64_parse_hash;
7153 sort_by_digest = sort_by_digest_4_5;
7154 opti_type = OPTI_TYPE_ZERO_BYTE
7155 | OPTI_TYPE_PRECOMPUTE_INIT
7156 | OPTI_TYPE_PRECOMPUTE_MERKLE
7157 | OPTI_TYPE_EARLY_SKIP
7158 | OPTI_TYPE_NOT_ITERATED
7159 | OPTI_TYPE_NOT_SALTED
7160 | OPTI_TYPE_RAW_HASH;
7161 dgst_pos0 = 3;
7162 dgst_pos1 = 4;
7163 dgst_pos2 = 2;
7164 dgst_pos3 = 1;
7165 break;
7166
7167 case 110: hash_type = HASH_TYPE_SHA1;
7168 salt_type = SALT_TYPE_INTERN;
7169 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7170 opts_type = OPTS_TYPE_PT_GENERATE_BE
7171 | OPTS_TYPE_ST_ADD80
7172 | OPTS_TYPE_ST_ADDBITS15;
7173 kern_type = KERN_TYPE_SHA1_PWSLT;
7174 dgst_size = DGST_SIZE_4_5;
7175 parse_func = sha1s_parse_hash;
7176 sort_by_digest = sort_by_digest_4_5;
7177 opti_type = OPTI_TYPE_ZERO_BYTE
7178 | OPTI_TYPE_PRECOMPUTE_INIT
7179 | OPTI_TYPE_PRECOMPUTE_MERKLE
7180 | OPTI_TYPE_EARLY_SKIP
7181 | OPTI_TYPE_NOT_ITERATED
7182 | OPTI_TYPE_APPENDED_SALT
7183 | OPTI_TYPE_RAW_HASH;
7184 dgst_pos0 = 3;
7185 dgst_pos1 = 4;
7186 dgst_pos2 = 2;
7187 dgst_pos3 = 1;
7188 break;
7189
7190 case 111: hash_type = HASH_TYPE_SHA1;
7191 salt_type = SALT_TYPE_EMBEDDED;
7192 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7193 opts_type = OPTS_TYPE_PT_GENERATE_BE
7194 | OPTS_TYPE_ST_ADD80
7195 | OPTS_TYPE_ST_ADDBITS15;
7196 kern_type = KERN_TYPE_SHA1_PWSLT;
7197 dgst_size = DGST_SIZE_4_5;
7198 parse_func = sha1b64s_parse_hash;
7199 sort_by_digest = sort_by_digest_4_5;
7200 opti_type = OPTI_TYPE_ZERO_BYTE
7201 | OPTI_TYPE_PRECOMPUTE_INIT
7202 | OPTI_TYPE_PRECOMPUTE_MERKLE
7203 | OPTI_TYPE_EARLY_SKIP
7204 | OPTI_TYPE_NOT_ITERATED
7205 | OPTI_TYPE_APPENDED_SALT
7206 | OPTI_TYPE_RAW_HASH;
7207 dgst_pos0 = 3;
7208 dgst_pos1 = 4;
7209 dgst_pos2 = 2;
7210 dgst_pos3 = 1;
7211 break;
7212
7213 case 112: hash_type = HASH_TYPE_SHA1;
7214 salt_type = SALT_TYPE_INTERN;
7215 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7216 opts_type = OPTS_TYPE_PT_GENERATE_BE
7217 | OPTS_TYPE_ST_ADD80
7218 | OPTS_TYPE_ST_ADDBITS15
7219 | OPTS_TYPE_ST_HEX;
7220 kern_type = KERN_TYPE_SHA1_PWSLT;
7221 dgst_size = DGST_SIZE_4_5;
7222 parse_func = oracles_parse_hash;
7223 sort_by_digest = sort_by_digest_4_5;
7224 opti_type = OPTI_TYPE_ZERO_BYTE
7225 | OPTI_TYPE_PRECOMPUTE_INIT
7226 | OPTI_TYPE_PRECOMPUTE_MERKLE
7227 | OPTI_TYPE_EARLY_SKIP
7228 | OPTI_TYPE_NOT_ITERATED
7229 | OPTI_TYPE_APPENDED_SALT
7230 | OPTI_TYPE_RAW_HASH;
7231 dgst_pos0 = 3;
7232 dgst_pos1 = 4;
7233 dgst_pos2 = 2;
7234 dgst_pos3 = 1;
7235 break;
7236
7237 case 120: hash_type = HASH_TYPE_SHA1;
7238 salt_type = SALT_TYPE_INTERN;
7239 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7240 opts_type = OPTS_TYPE_PT_GENERATE_BE
7241 | OPTS_TYPE_PT_ADD80
7242 | OPTS_TYPE_PT_ADDBITS15;
7243 kern_type = KERN_TYPE_SHA1_SLTPW;
7244 dgst_size = DGST_SIZE_4_5;
7245 parse_func = sha1s_parse_hash;
7246 sort_by_digest = sort_by_digest_4_5;
7247 opti_type = OPTI_TYPE_ZERO_BYTE
7248 | OPTI_TYPE_PRECOMPUTE_INIT
7249 | OPTI_TYPE_PRECOMPUTE_MERKLE
7250 | OPTI_TYPE_EARLY_SKIP
7251 | OPTI_TYPE_NOT_ITERATED
7252 | OPTI_TYPE_PREPENDED_SALT
7253 | OPTI_TYPE_RAW_HASH;
7254 dgst_pos0 = 3;
7255 dgst_pos1 = 4;
7256 dgst_pos2 = 2;
7257 dgst_pos3 = 1;
7258 break;
7259
7260 case 121: hash_type = HASH_TYPE_SHA1;
7261 salt_type = SALT_TYPE_INTERN;
7262 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7263 opts_type = OPTS_TYPE_PT_GENERATE_BE
7264 | OPTS_TYPE_PT_ADD80
7265 | OPTS_TYPE_PT_ADDBITS15
7266 | OPTS_TYPE_ST_LOWER;
7267 kern_type = KERN_TYPE_SHA1_SLTPW;
7268 dgst_size = DGST_SIZE_4_5;
7269 parse_func = smf_parse_hash;
7270 sort_by_digest = sort_by_digest_4_5;
7271 opti_type = OPTI_TYPE_ZERO_BYTE
7272 | OPTI_TYPE_PRECOMPUTE_INIT
7273 | OPTI_TYPE_PRECOMPUTE_MERKLE
7274 | OPTI_TYPE_EARLY_SKIP
7275 | OPTI_TYPE_NOT_ITERATED
7276 | OPTI_TYPE_PREPENDED_SALT
7277 | OPTI_TYPE_RAW_HASH;
7278 dgst_pos0 = 3;
7279 dgst_pos1 = 4;
7280 dgst_pos2 = 2;
7281 dgst_pos3 = 1;
7282 break;
7283
7284 case 122: hash_type = HASH_TYPE_SHA1;
7285 salt_type = SALT_TYPE_EMBEDDED;
7286 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7287 opts_type = OPTS_TYPE_PT_GENERATE_BE
7288 | OPTS_TYPE_PT_ADD80
7289 | OPTS_TYPE_PT_ADDBITS15
7290 | OPTS_TYPE_ST_HEX;
7291 kern_type = KERN_TYPE_SHA1_SLTPW;
7292 dgst_size = DGST_SIZE_4_5;
7293 parse_func = osx1_parse_hash;
7294 sort_by_digest = sort_by_digest_4_5;
7295 opti_type = OPTI_TYPE_ZERO_BYTE
7296 | OPTI_TYPE_PRECOMPUTE_INIT
7297 | OPTI_TYPE_PRECOMPUTE_MERKLE
7298 | OPTI_TYPE_EARLY_SKIP
7299 | OPTI_TYPE_NOT_ITERATED
7300 | OPTI_TYPE_PREPENDED_SALT
7301 | OPTI_TYPE_RAW_HASH;
7302 dgst_pos0 = 3;
7303 dgst_pos1 = 4;
7304 dgst_pos2 = 2;
7305 dgst_pos3 = 1;
7306 break;
7307
7308 case 124: hash_type = HASH_TYPE_SHA1;
7309 salt_type = SALT_TYPE_EMBEDDED;
7310 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7311 opts_type = OPTS_TYPE_PT_GENERATE_BE
7312 | OPTS_TYPE_PT_ADD80
7313 | OPTS_TYPE_PT_ADDBITS15;
7314 kern_type = KERN_TYPE_SHA1_SLTPW;
7315 dgst_size = DGST_SIZE_4_5;
7316 parse_func = djangosha1_parse_hash;
7317 sort_by_digest = sort_by_digest_4_5;
7318 opti_type = OPTI_TYPE_ZERO_BYTE
7319 | OPTI_TYPE_PRECOMPUTE_INIT
7320 | OPTI_TYPE_PRECOMPUTE_MERKLE
7321 | OPTI_TYPE_EARLY_SKIP
7322 | OPTI_TYPE_NOT_ITERATED
7323 | OPTI_TYPE_PREPENDED_SALT
7324 | OPTI_TYPE_RAW_HASH;
7325 dgst_pos0 = 3;
7326 dgst_pos1 = 4;
7327 dgst_pos2 = 2;
7328 dgst_pos3 = 1;
7329 break;
7330
7331 case 125: hash_type = HASH_TYPE_SHA1;
7332 salt_type = SALT_TYPE_EMBEDDED;
7333 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7334 opts_type = OPTS_TYPE_PT_GENERATE_BE
7335 | OPTS_TYPE_PT_ADD80
7336 | OPTS_TYPE_PT_ADDBITS15
7337 | OPTS_TYPE_ST_HEX;
7338 kern_type = KERN_TYPE_SHA1_SLTPW;
7339 dgst_size = DGST_SIZE_4_5;
7340 parse_func = arubaos_parse_hash;
7341 sort_by_digest = sort_by_digest_4_5;
7342 opti_type = OPTI_TYPE_ZERO_BYTE
7343 | OPTI_TYPE_PRECOMPUTE_INIT
7344 | OPTI_TYPE_PRECOMPUTE_MERKLE
7345 | OPTI_TYPE_EARLY_SKIP
7346 | OPTI_TYPE_NOT_ITERATED
7347 | OPTI_TYPE_PREPENDED_SALT
7348 | OPTI_TYPE_RAW_HASH;
7349 dgst_pos0 = 3;
7350 dgst_pos1 = 4;
7351 dgst_pos2 = 2;
7352 dgst_pos3 = 1;
7353 break;
7354
7355 case 130: hash_type = HASH_TYPE_SHA1;
7356 salt_type = SALT_TYPE_INTERN;
7357 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7358 opts_type = OPTS_TYPE_PT_GENERATE_BE
7359 | OPTS_TYPE_PT_UNICODE
7360 | OPTS_TYPE_ST_ADD80
7361 | OPTS_TYPE_ST_ADDBITS15;
7362 kern_type = KERN_TYPE_SHA1_PWUSLT;
7363 dgst_size = DGST_SIZE_4_5;
7364 parse_func = sha1s_parse_hash;
7365 sort_by_digest = sort_by_digest_4_5;
7366 opti_type = OPTI_TYPE_ZERO_BYTE
7367 | OPTI_TYPE_PRECOMPUTE_INIT
7368 | OPTI_TYPE_PRECOMPUTE_MERKLE
7369 | OPTI_TYPE_EARLY_SKIP
7370 | OPTI_TYPE_NOT_ITERATED
7371 | OPTI_TYPE_APPENDED_SALT
7372 | OPTI_TYPE_RAW_HASH;
7373 dgst_pos0 = 3;
7374 dgst_pos1 = 4;
7375 dgst_pos2 = 2;
7376 dgst_pos3 = 1;
7377 break;
7378
7379 case 131: hash_type = HASH_TYPE_SHA1;
7380 salt_type = SALT_TYPE_EMBEDDED;
7381 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7382 opts_type = OPTS_TYPE_PT_GENERATE_BE
7383 | OPTS_TYPE_PT_UNICODE
7384 | OPTS_TYPE_PT_UPPER
7385 | OPTS_TYPE_ST_ADD80
7386 | OPTS_TYPE_ST_ADDBITS15
7387 | OPTS_TYPE_ST_HEX;
7388 kern_type = KERN_TYPE_SHA1_PWUSLT;
7389 dgst_size = DGST_SIZE_4_5;
7390 parse_func = mssql2000_parse_hash;
7391 sort_by_digest = sort_by_digest_4_5;
7392 opti_type = OPTI_TYPE_ZERO_BYTE
7393 | OPTI_TYPE_PRECOMPUTE_INIT
7394 | OPTI_TYPE_PRECOMPUTE_MERKLE
7395 | OPTI_TYPE_EARLY_SKIP
7396 | OPTI_TYPE_NOT_ITERATED
7397 | OPTI_TYPE_APPENDED_SALT
7398 | OPTI_TYPE_RAW_HASH;
7399 dgst_pos0 = 3;
7400 dgst_pos1 = 4;
7401 dgst_pos2 = 2;
7402 dgst_pos3 = 1;
7403 break;
7404
7405 case 132: hash_type = HASH_TYPE_SHA1;
7406 salt_type = SALT_TYPE_EMBEDDED;
7407 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7408 opts_type = OPTS_TYPE_PT_GENERATE_BE
7409 | OPTS_TYPE_PT_UNICODE
7410 | OPTS_TYPE_ST_ADD80
7411 | OPTS_TYPE_ST_ADDBITS15
7412 | OPTS_TYPE_ST_HEX;
7413 kern_type = KERN_TYPE_SHA1_PWUSLT;
7414 dgst_size = DGST_SIZE_4_5;
7415 parse_func = mssql2005_parse_hash;
7416 sort_by_digest = sort_by_digest_4_5;
7417 opti_type = OPTI_TYPE_ZERO_BYTE
7418 | OPTI_TYPE_PRECOMPUTE_INIT
7419 | OPTI_TYPE_PRECOMPUTE_MERKLE
7420 | OPTI_TYPE_EARLY_SKIP
7421 | OPTI_TYPE_NOT_ITERATED
7422 | OPTI_TYPE_APPENDED_SALT
7423 | OPTI_TYPE_RAW_HASH;
7424 dgst_pos0 = 3;
7425 dgst_pos1 = 4;
7426 dgst_pos2 = 2;
7427 dgst_pos3 = 1;
7428 break;
7429
7430 case 133: hash_type = HASH_TYPE_SHA1;
7431 salt_type = SALT_TYPE_EMBEDDED;
7432 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7433 opts_type = OPTS_TYPE_PT_GENERATE_BE
7434 | OPTS_TYPE_PT_UNICODE
7435 | OPTS_TYPE_ST_ADD80
7436 | OPTS_TYPE_ST_ADDBITS15;
7437 kern_type = KERN_TYPE_SHA1_PWUSLT;
7438 dgst_size = DGST_SIZE_4_5;
7439 parse_func = peoplesoft_parse_hash;
7440 sort_by_digest = sort_by_digest_4_5;
7441 opti_type = OPTI_TYPE_ZERO_BYTE
7442 | OPTI_TYPE_PRECOMPUTE_INIT
7443 | OPTI_TYPE_PRECOMPUTE_MERKLE
7444 | OPTI_TYPE_EARLY_SKIP
7445 | OPTI_TYPE_NOT_ITERATED
7446 | OPTI_TYPE_APPENDED_SALT
7447 | OPTI_TYPE_RAW_HASH;
7448 dgst_pos0 = 3;
7449 dgst_pos1 = 4;
7450 dgst_pos2 = 2;
7451 dgst_pos3 = 1;
7452 break;
7453
7454 case 140: hash_type = HASH_TYPE_SHA1;
7455 salt_type = SALT_TYPE_INTERN;
7456 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7457 opts_type = OPTS_TYPE_PT_GENERATE_BE
7458 | OPTS_TYPE_PT_ADD80
7459 | OPTS_TYPE_PT_ADDBITS15
7460 | OPTS_TYPE_PT_UNICODE;
7461 kern_type = KERN_TYPE_SHA1_SLTPWU;
7462 dgst_size = DGST_SIZE_4_5;
7463 parse_func = sha1s_parse_hash;
7464 sort_by_digest = sort_by_digest_4_5;
7465 opti_type = OPTI_TYPE_ZERO_BYTE
7466 | OPTI_TYPE_PRECOMPUTE_INIT
7467 | OPTI_TYPE_PRECOMPUTE_MERKLE
7468 | OPTI_TYPE_EARLY_SKIP
7469 | OPTI_TYPE_NOT_ITERATED
7470 | OPTI_TYPE_PREPENDED_SALT
7471 | OPTI_TYPE_RAW_HASH;
7472 dgst_pos0 = 3;
7473 dgst_pos1 = 4;
7474 dgst_pos2 = 2;
7475 dgst_pos3 = 1;
7476 break;
7477
7478 case 141: hash_type = HASH_TYPE_SHA1;
7479 salt_type = SALT_TYPE_EMBEDDED;
7480 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7481 opts_type = OPTS_TYPE_PT_GENERATE_BE
7482 | OPTS_TYPE_PT_ADD80
7483 | OPTS_TYPE_PT_ADDBITS15
7484 | OPTS_TYPE_PT_UNICODE
7485 | OPTS_TYPE_ST_BASE64;
7486 kern_type = KERN_TYPE_SHA1_SLTPWU;
7487 dgst_size = DGST_SIZE_4_5;
7488 parse_func = episerver_parse_hash;
7489 sort_by_digest = sort_by_digest_4_5;
7490 opti_type = OPTI_TYPE_ZERO_BYTE
7491 | OPTI_TYPE_PRECOMPUTE_INIT
7492 | OPTI_TYPE_PRECOMPUTE_MERKLE
7493 | OPTI_TYPE_EARLY_SKIP
7494 | OPTI_TYPE_NOT_ITERATED
7495 | OPTI_TYPE_PREPENDED_SALT
7496 | OPTI_TYPE_RAW_HASH;
7497 dgst_pos0 = 3;
7498 dgst_pos1 = 4;
7499 dgst_pos2 = 2;
7500 dgst_pos3 = 1;
7501 break;
7502
7503 case 150: hash_type = HASH_TYPE_SHA1;
7504 salt_type = SALT_TYPE_INTERN;
7505 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7506 opts_type = OPTS_TYPE_PT_GENERATE_BE
7507 | OPTS_TYPE_ST_ADD80
7508 | OPTS_TYPE_ST_ADDBITS15;
7509 kern_type = KERN_TYPE_HMACSHA1_PW;
7510 dgst_size = DGST_SIZE_4_5;
7511 parse_func = hmacsha1_parse_hash;
7512 sort_by_digest = sort_by_digest_4_5;
7513 opti_type = OPTI_TYPE_ZERO_BYTE
7514 | OPTI_TYPE_NOT_ITERATED;
7515 dgst_pos0 = 3;
7516 dgst_pos1 = 4;
7517 dgst_pos2 = 2;
7518 dgst_pos3 = 1;
7519 break;
7520
7521 case 160: hash_type = HASH_TYPE_SHA1;
7522 salt_type = SALT_TYPE_INTERN;
7523 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7524 opts_type = OPTS_TYPE_PT_GENERATE_BE
7525 | OPTS_TYPE_PT_ADD80
7526 | OPTS_TYPE_PT_ADDBITS15;
7527 kern_type = KERN_TYPE_HMACSHA1_SLT;
7528 dgst_size = DGST_SIZE_4_5;
7529 parse_func = hmacsha1_parse_hash;
7530 sort_by_digest = sort_by_digest_4_5;
7531 opti_type = OPTI_TYPE_ZERO_BYTE
7532 | OPTI_TYPE_NOT_ITERATED;
7533 dgst_pos0 = 3;
7534 dgst_pos1 = 4;
7535 dgst_pos2 = 2;
7536 dgst_pos3 = 1;
7537 break;
7538
7539 case 190: hash_type = HASH_TYPE_SHA1;
7540 salt_type = SALT_TYPE_NONE;
7541 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7542 opts_type = OPTS_TYPE_PT_GENERATE_BE
7543 | OPTS_TYPE_PT_ADD80
7544 | OPTS_TYPE_PT_ADDBITS15;
7545 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7546 dgst_size = DGST_SIZE_4_5;
7547 parse_func = sha1linkedin_parse_hash;
7548 sort_by_digest = sort_by_digest_4_5;
7549 opti_type = OPTI_TYPE_ZERO_BYTE
7550 | OPTI_TYPE_PRECOMPUTE_INIT
7551 | OPTI_TYPE_EARLY_SKIP
7552 | OPTI_TYPE_NOT_ITERATED
7553 | OPTI_TYPE_NOT_SALTED;
7554 dgst_pos0 = 0;
7555 dgst_pos1 = 4;
7556 dgst_pos2 = 3;
7557 dgst_pos3 = 2;
7558 break;
7559
7560 case 200: hash_type = HASH_TYPE_MYSQL;
7561 salt_type = SALT_TYPE_NONE;
7562 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7563 opts_type = 0;
7564 kern_type = KERN_TYPE_MYSQL;
7565 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7566 parse_func = mysql323_parse_hash;
7567 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7568 opti_type = OPTI_TYPE_ZERO_BYTE;
7569 dgst_pos0 = 0;
7570 dgst_pos1 = 1;
7571 dgst_pos2 = 2;
7572 dgst_pos3 = 3;
7573 break;
7574
7575 case 300: hash_type = HASH_TYPE_SHA1;
7576 salt_type = SALT_TYPE_NONE;
7577 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7578 opts_type = OPTS_TYPE_PT_GENERATE_BE
7579 | OPTS_TYPE_PT_ADD80
7580 | OPTS_TYPE_PT_ADDBITS15;
7581 kern_type = KERN_TYPE_MYSQL41;
7582 dgst_size = DGST_SIZE_4_5;
7583 parse_func = sha1_parse_hash;
7584 sort_by_digest = sort_by_digest_4_5;
7585 opti_type = OPTI_TYPE_ZERO_BYTE
7586 | OPTI_TYPE_PRECOMPUTE_INIT
7587 | OPTI_TYPE_PRECOMPUTE_MERKLE
7588 | OPTI_TYPE_EARLY_SKIP
7589 | OPTI_TYPE_NOT_ITERATED
7590 | OPTI_TYPE_NOT_SALTED;
7591 dgst_pos0 = 3;
7592 dgst_pos1 = 4;
7593 dgst_pos2 = 2;
7594 dgst_pos3 = 1;
7595 break;
7596
7597 case 400: hash_type = HASH_TYPE_MD5;
7598 salt_type = SALT_TYPE_EMBEDDED;
7599 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7600 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7601 kern_type = KERN_TYPE_PHPASS;
7602 dgst_size = DGST_SIZE_4_4;
7603 parse_func = phpass_parse_hash;
7604 sort_by_digest = sort_by_digest_4_4;
7605 opti_type = OPTI_TYPE_ZERO_BYTE;
7606 dgst_pos0 = 0;
7607 dgst_pos1 = 1;
7608 dgst_pos2 = 2;
7609 dgst_pos3 = 3;
7610 break;
7611
7612 case 500: hash_type = HASH_TYPE_MD5;
7613 salt_type = SALT_TYPE_EMBEDDED;
7614 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7615 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7616 kern_type = KERN_TYPE_MD5CRYPT;
7617 dgst_size = DGST_SIZE_4_4;
7618 parse_func = md5crypt_parse_hash;
7619 sort_by_digest = sort_by_digest_4_4;
7620 opti_type = OPTI_TYPE_ZERO_BYTE;
7621 dgst_pos0 = 0;
7622 dgst_pos1 = 1;
7623 dgst_pos2 = 2;
7624 dgst_pos3 = 3;
7625 break;
7626
7627 case 501: hash_type = HASH_TYPE_MD5;
7628 salt_type = SALT_TYPE_EMBEDDED;
7629 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7630 opts_type = OPTS_TYPE_PT_GENERATE_LE
7631 | OPTS_TYPE_HASH_COPY;
7632 kern_type = KERN_TYPE_MD5CRYPT;
7633 dgst_size = DGST_SIZE_4_4;
7634 parse_func = juniper_parse_hash;
7635 sort_by_digest = sort_by_digest_4_4;
7636 opti_type = OPTI_TYPE_ZERO_BYTE;
7637 dgst_pos0 = 0;
7638 dgst_pos1 = 1;
7639 dgst_pos2 = 2;
7640 dgst_pos3 = 3;
7641 break;
7642
7643 case 900: hash_type = HASH_TYPE_MD4;
7644 salt_type = SALT_TYPE_NONE;
7645 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7646 opts_type = OPTS_TYPE_PT_GENERATE_LE
7647 | OPTS_TYPE_PT_ADD80
7648 | OPTS_TYPE_PT_ADDBITS14;
7649 kern_type = KERN_TYPE_MD4;
7650 dgst_size = DGST_SIZE_4_4;
7651 parse_func = md4_parse_hash;
7652 sort_by_digest = sort_by_digest_4_4;
7653 opti_type = OPTI_TYPE_ZERO_BYTE
7654 | OPTI_TYPE_PRECOMPUTE_INIT
7655 | OPTI_TYPE_PRECOMPUTE_MERKLE
7656 | OPTI_TYPE_MEET_IN_MIDDLE
7657 | OPTI_TYPE_EARLY_SKIP
7658 | OPTI_TYPE_NOT_ITERATED
7659 | OPTI_TYPE_NOT_SALTED
7660 | OPTI_TYPE_RAW_HASH;
7661 dgst_pos0 = 0;
7662 dgst_pos1 = 3;
7663 dgst_pos2 = 2;
7664 dgst_pos3 = 1;
7665 break;
7666
7667 case 1000: hash_type = HASH_TYPE_MD4;
7668 salt_type = SALT_TYPE_NONE;
7669 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7670 opts_type = OPTS_TYPE_PT_GENERATE_LE
7671 | OPTS_TYPE_PT_ADD80
7672 | OPTS_TYPE_PT_ADDBITS14
7673 | OPTS_TYPE_PT_UNICODE;
7674 kern_type = KERN_TYPE_MD4_PWU;
7675 dgst_size = DGST_SIZE_4_4;
7676 parse_func = md4_parse_hash;
7677 sort_by_digest = sort_by_digest_4_4;
7678 opti_type = OPTI_TYPE_ZERO_BYTE
7679 | OPTI_TYPE_PRECOMPUTE_INIT
7680 | OPTI_TYPE_PRECOMPUTE_MERKLE
7681 | OPTI_TYPE_MEET_IN_MIDDLE
7682 | OPTI_TYPE_EARLY_SKIP
7683 | OPTI_TYPE_NOT_ITERATED
7684 | OPTI_TYPE_NOT_SALTED
7685 | OPTI_TYPE_RAW_HASH;
7686 dgst_pos0 = 0;
7687 dgst_pos1 = 3;
7688 dgst_pos2 = 2;
7689 dgst_pos3 = 1;
7690 break;
7691
7692 case 1100: hash_type = HASH_TYPE_MD4;
7693 salt_type = SALT_TYPE_INTERN;
7694 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7695 opts_type = OPTS_TYPE_PT_GENERATE_LE
7696 | OPTS_TYPE_PT_ADD80
7697 | OPTS_TYPE_PT_ADDBITS14
7698 | OPTS_TYPE_PT_UNICODE
7699 | OPTS_TYPE_ST_ADD80
7700 | OPTS_TYPE_ST_UNICODE
7701 | OPTS_TYPE_ST_LOWER;
7702 kern_type = KERN_TYPE_MD44_PWUSLT;
7703 dgst_size = DGST_SIZE_4_4;
7704 parse_func = dcc_parse_hash;
7705 sort_by_digest = sort_by_digest_4_4;
7706 opti_type = OPTI_TYPE_ZERO_BYTE
7707 | OPTI_TYPE_PRECOMPUTE_INIT
7708 | OPTI_TYPE_PRECOMPUTE_MERKLE
7709 | OPTI_TYPE_EARLY_SKIP
7710 | OPTI_TYPE_NOT_ITERATED;
7711 dgst_pos0 = 0;
7712 dgst_pos1 = 3;
7713 dgst_pos2 = 2;
7714 dgst_pos3 = 1;
7715 break;
7716
7717 case 1400: hash_type = HASH_TYPE_SHA256;
7718 salt_type = SALT_TYPE_NONE;
7719 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7720 opts_type = OPTS_TYPE_PT_GENERATE_BE
7721 | OPTS_TYPE_PT_ADD80
7722 | OPTS_TYPE_PT_ADDBITS15;
7723 kern_type = KERN_TYPE_SHA256;
7724 dgst_size = DGST_SIZE_4_8;
7725 parse_func = sha256_parse_hash;
7726 sort_by_digest = sort_by_digest_4_8;
7727 opti_type = OPTI_TYPE_ZERO_BYTE
7728 | OPTI_TYPE_PRECOMPUTE_INIT
7729 | OPTI_TYPE_PRECOMPUTE_MERKLE
7730 | OPTI_TYPE_EARLY_SKIP
7731 | OPTI_TYPE_NOT_ITERATED
7732 | OPTI_TYPE_NOT_SALTED
7733 | OPTI_TYPE_RAW_HASH;
7734 dgst_pos0 = 3;
7735 dgst_pos1 = 7;
7736 dgst_pos2 = 2;
7737 dgst_pos3 = 6;
7738 break;
7739
7740 case 1410: hash_type = HASH_TYPE_SHA256;
7741 salt_type = SALT_TYPE_INTERN;
7742 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7743 opts_type = OPTS_TYPE_PT_GENERATE_BE
7744 | OPTS_TYPE_ST_ADD80
7745 | OPTS_TYPE_ST_ADDBITS15;
7746 kern_type = KERN_TYPE_SHA256_PWSLT;
7747 dgst_size = DGST_SIZE_4_8;
7748 parse_func = sha256s_parse_hash;
7749 sort_by_digest = sort_by_digest_4_8;
7750 opti_type = OPTI_TYPE_ZERO_BYTE
7751 | OPTI_TYPE_PRECOMPUTE_INIT
7752 | OPTI_TYPE_PRECOMPUTE_MERKLE
7753 | OPTI_TYPE_EARLY_SKIP
7754 | OPTI_TYPE_NOT_ITERATED
7755 | OPTI_TYPE_APPENDED_SALT
7756 | OPTI_TYPE_RAW_HASH;
7757 dgst_pos0 = 3;
7758 dgst_pos1 = 7;
7759 dgst_pos2 = 2;
7760 dgst_pos3 = 6;
7761 break;
7762
7763 case 1420: hash_type = HASH_TYPE_SHA256;
7764 salt_type = SALT_TYPE_INTERN;
7765 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7766 opts_type = OPTS_TYPE_PT_GENERATE_BE
7767 | OPTS_TYPE_PT_ADD80
7768 | OPTS_TYPE_PT_ADDBITS15;
7769 kern_type = KERN_TYPE_SHA256_SLTPW;
7770 dgst_size = DGST_SIZE_4_8;
7771 parse_func = sha256s_parse_hash;
7772 sort_by_digest = sort_by_digest_4_8;
7773 opti_type = OPTI_TYPE_ZERO_BYTE
7774 | OPTI_TYPE_PRECOMPUTE_INIT
7775 | OPTI_TYPE_PRECOMPUTE_MERKLE
7776 | OPTI_TYPE_EARLY_SKIP
7777 | OPTI_TYPE_NOT_ITERATED
7778 | OPTI_TYPE_PREPENDED_SALT
7779 | OPTI_TYPE_RAW_HASH;
7780 dgst_pos0 = 3;
7781 dgst_pos1 = 7;
7782 dgst_pos2 = 2;
7783 dgst_pos3 = 6;
7784 break;
7785
7786 case 1421: hash_type = HASH_TYPE_SHA256;
7787 salt_type = SALT_TYPE_EMBEDDED;
7788 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7789 opts_type = OPTS_TYPE_PT_GENERATE_BE
7790 | OPTS_TYPE_PT_ADD80
7791 | OPTS_TYPE_PT_ADDBITS15;
7792 kern_type = KERN_TYPE_SHA256_SLTPW;
7793 dgst_size = DGST_SIZE_4_8;
7794 parse_func = hmailserver_parse_hash;
7795 sort_by_digest = sort_by_digest_4_8;
7796 opti_type = OPTI_TYPE_ZERO_BYTE
7797 | OPTI_TYPE_PRECOMPUTE_INIT
7798 | OPTI_TYPE_PRECOMPUTE_MERKLE
7799 | OPTI_TYPE_EARLY_SKIP
7800 | OPTI_TYPE_NOT_ITERATED
7801 | OPTI_TYPE_PREPENDED_SALT
7802 | OPTI_TYPE_RAW_HASH;
7803 dgst_pos0 = 3;
7804 dgst_pos1 = 7;
7805 dgst_pos2 = 2;
7806 dgst_pos3 = 6;
7807 break;
7808
7809 case 1430: hash_type = HASH_TYPE_SHA256;
7810 salt_type = SALT_TYPE_INTERN;
7811 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7812 opts_type = OPTS_TYPE_PT_GENERATE_BE
7813 | OPTS_TYPE_PT_UNICODE
7814 | OPTS_TYPE_ST_ADD80
7815 | OPTS_TYPE_ST_ADDBITS15;
7816 kern_type = KERN_TYPE_SHA256_PWUSLT;
7817 dgst_size = DGST_SIZE_4_8;
7818 parse_func = sha256s_parse_hash;
7819 sort_by_digest = sort_by_digest_4_8;
7820 opti_type = OPTI_TYPE_ZERO_BYTE
7821 | OPTI_TYPE_PRECOMPUTE_INIT
7822 | OPTI_TYPE_PRECOMPUTE_MERKLE
7823 | OPTI_TYPE_EARLY_SKIP
7824 | OPTI_TYPE_NOT_ITERATED
7825 | OPTI_TYPE_APPENDED_SALT
7826 | OPTI_TYPE_RAW_HASH;
7827 dgst_pos0 = 3;
7828 dgst_pos1 = 7;
7829 dgst_pos2 = 2;
7830 dgst_pos3 = 6;
7831 break;
7832
7833 case 1440: hash_type = HASH_TYPE_SHA256;
7834 salt_type = SALT_TYPE_INTERN;
7835 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7836 opts_type = OPTS_TYPE_PT_GENERATE_BE
7837 | OPTS_TYPE_PT_ADD80
7838 | OPTS_TYPE_PT_ADDBITS15
7839 | OPTS_TYPE_PT_UNICODE;
7840 kern_type = KERN_TYPE_SHA256_SLTPWU;
7841 dgst_size = DGST_SIZE_4_8;
7842 parse_func = sha256s_parse_hash;
7843 sort_by_digest = sort_by_digest_4_8;
7844 opti_type = OPTI_TYPE_ZERO_BYTE
7845 | OPTI_TYPE_PRECOMPUTE_INIT
7846 | OPTI_TYPE_PRECOMPUTE_MERKLE
7847 | OPTI_TYPE_EARLY_SKIP
7848 | OPTI_TYPE_NOT_ITERATED
7849 | OPTI_TYPE_PREPENDED_SALT
7850 | OPTI_TYPE_RAW_HASH;
7851 dgst_pos0 = 3;
7852 dgst_pos1 = 7;
7853 dgst_pos2 = 2;
7854 dgst_pos3 = 6;
7855 break;
7856
7857 case 1441: hash_type = HASH_TYPE_SHA256;
7858 salt_type = SALT_TYPE_EMBEDDED;
7859 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7860 opts_type = OPTS_TYPE_PT_GENERATE_BE
7861 | OPTS_TYPE_PT_ADD80
7862 | OPTS_TYPE_PT_ADDBITS15
7863 | OPTS_TYPE_PT_UNICODE
7864 | OPTS_TYPE_ST_BASE64;
7865 kern_type = KERN_TYPE_SHA256_SLTPWU;
7866 dgst_size = DGST_SIZE_4_8;
7867 parse_func = episerver4_parse_hash;
7868 sort_by_digest = sort_by_digest_4_8;
7869 opti_type = OPTI_TYPE_ZERO_BYTE
7870 | OPTI_TYPE_PRECOMPUTE_INIT
7871 | OPTI_TYPE_PRECOMPUTE_MERKLE
7872 | OPTI_TYPE_EARLY_SKIP
7873 | OPTI_TYPE_NOT_ITERATED
7874 | OPTI_TYPE_PREPENDED_SALT
7875 | OPTI_TYPE_RAW_HASH;
7876 dgst_pos0 = 3;
7877 dgst_pos1 = 7;
7878 dgst_pos2 = 2;
7879 dgst_pos3 = 6;
7880 break;
7881
7882 case 1450: hash_type = HASH_TYPE_SHA256;
7883 salt_type = SALT_TYPE_INTERN;
7884 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7885 opts_type = OPTS_TYPE_PT_GENERATE_BE
7886 | OPTS_TYPE_ST_ADD80;
7887 kern_type = KERN_TYPE_HMACSHA256_PW;
7888 dgst_size = DGST_SIZE_4_8;
7889 parse_func = hmacsha256_parse_hash;
7890 sort_by_digest = sort_by_digest_4_8;
7891 opti_type = OPTI_TYPE_ZERO_BYTE
7892 | OPTI_TYPE_NOT_ITERATED;
7893 dgst_pos0 = 3;
7894 dgst_pos1 = 7;
7895 dgst_pos2 = 2;
7896 dgst_pos3 = 6;
7897 break;
7898
7899 case 1460: hash_type = HASH_TYPE_SHA256;
7900 salt_type = SALT_TYPE_INTERN;
7901 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7902 opts_type = OPTS_TYPE_PT_GENERATE_BE
7903 | OPTS_TYPE_PT_ADD80
7904 | OPTS_TYPE_PT_ADDBITS15;
7905 kern_type = KERN_TYPE_HMACSHA256_SLT;
7906 dgst_size = DGST_SIZE_4_8;
7907 parse_func = hmacsha256_parse_hash;
7908 sort_by_digest = sort_by_digest_4_8;
7909 opti_type = OPTI_TYPE_ZERO_BYTE
7910 | OPTI_TYPE_NOT_ITERATED;
7911 dgst_pos0 = 3;
7912 dgst_pos1 = 7;
7913 dgst_pos2 = 2;
7914 dgst_pos3 = 6;
7915 break;
7916
7917 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7918 salt_type = SALT_TYPE_EMBEDDED;
7919 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7920 opts_type = OPTS_TYPE_PT_GENERATE_LE
7921 | OPTS_TYPE_PT_BITSLICE;
7922 kern_type = KERN_TYPE_DESCRYPT;
7923 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7924 parse_func = descrypt_parse_hash;
7925 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7926 opti_type = OPTI_TYPE_ZERO_BYTE
7927 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7928 dgst_pos0 = 0;
7929 dgst_pos1 = 1;
7930 dgst_pos2 = 2;
7931 dgst_pos3 = 3;
7932 break;
7933
7934 case 1600: hash_type = HASH_TYPE_MD5;
7935 salt_type = SALT_TYPE_EMBEDDED;
7936 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7937 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7938 kern_type = KERN_TYPE_APR1CRYPT;
7939 dgst_size = DGST_SIZE_4_4;
7940 parse_func = md5apr1_parse_hash;
7941 sort_by_digest = sort_by_digest_4_4;
7942 opti_type = OPTI_TYPE_ZERO_BYTE;
7943 dgst_pos0 = 0;
7944 dgst_pos1 = 1;
7945 dgst_pos2 = 2;
7946 dgst_pos3 = 3;
7947 break;
7948
7949 case 1700: hash_type = HASH_TYPE_SHA512;
7950 salt_type = SALT_TYPE_NONE;
7951 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7952 opts_type = OPTS_TYPE_PT_GENERATE_BE
7953 | OPTS_TYPE_PT_ADD80
7954 | OPTS_TYPE_PT_ADDBITS15;
7955 kern_type = KERN_TYPE_SHA512;
7956 dgst_size = DGST_SIZE_8_8;
7957 parse_func = sha512_parse_hash;
7958 sort_by_digest = sort_by_digest_8_8;
7959 opti_type = OPTI_TYPE_ZERO_BYTE
7960 | OPTI_TYPE_PRECOMPUTE_INIT
7961 | OPTI_TYPE_PRECOMPUTE_MERKLE
7962 | OPTI_TYPE_EARLY_SKIP
7963 | OPTI_TYPE_NOT_ITERATED
7964 | OPTI_TYPE_NOT_SALTED
7965 | OPTI_TYPE_USES_BITS_64
7966 | OPTI_TYPE_RAW_HASH;
7967 dgst_pos0 = 14;
7968 dgst_pos1 = 15;
7969 dgst_pos2 = 6;
7970 dgst_pos3 = 7;
7971 break;
7972
7973 case 1710: hash_type = HASH_TYPE_SHA512;
7974 salt_type = SALT_TYPE_INTERN;
7975 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7976 opts_type = OPTS_TYPE_PT_GENERATE_BE
7977 | OPTS_TYPE_ST_ADD80
7978 | OPTS_TYPE_ST_ADDBITS15;
7979 kern_type = KERN_TYPE_SHA512_PWSLT;
7980 dgst_size = DGST_SIZE_8_8;
7981 parse_func = sha512s_parse_hash;
7982 sort_by_digest = sort_by_digest_8_8;
7983 opti_type = OPTI_TYPE_ZERO_BYTE
7984 | OPTI_TYPE_PRECOMPUTE_INIT
7985 | OPTI_TYPE_PRECOMPUTE_MERKLE
7986 | OPTI_TYPE_EARLY_SKIP
7987 | OPTI_TYPE_NOT_ITERATED
7988 | OPTI_TYPE_APPENDED_SALT
7989 | OPTI_TYPE_USES_BITS_64
7990 | OPTI_TYPE_RAW_HASH;
7991 dgst_pos0 = 14;
7992 dgst_pos1 = 15;
7993 dgst_pos2 = 6;
7994 dgst_pos3 = 7;
7995 break;
7996
7997 case 1711: hash_type = HASH_TYPE_SHA512;
7998 salt_type = SALT_TYPE_EMBEDDED;
7999 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8000 opts_type = OPTS_TYPE_PT_GENERATE_BE
8001 | OPTS_TYPE_ST_ADD80
8002 | OPTS_TYPE_ST_ADDBITS15;
8003 kern_type = KERN_TYPE_SHA512_PWSLT;
8004 dgst_size = DGST_SIZE_8_8;
8005 parse_func = sha512b64s_parse_hash;
8006 sort_by_digest = sort_by_digest_8_8;
8007 opti_type = OPTI_TYPE_ZERO_BYTE
8008 | OPTI_TYPE_PRECOMPUTE_INIT
8009 | OPTI_TYPE_PRECOMPUTE_MERKLE
8010 | OPTI_TYPE_EARLY_SKIP
8011 | OPTI_TYPE_NOT_ITERATED
8012 | OPTI_TYPE_APPENDED_SALT
8013 | OPTI_TYPE_USES_BITS_64
8014 | OPTI_TYPE_RAW_HASH;
8015 dgst_pos0 = 14;
8016 dgst_pos1 = 15;
8017 dgst_pos2 = 6;
8018 dgst_pos3 = 7;
8019 break;
8020
8021 case 1720: hash_type = HASH_TYPE_SHA512;
8022 salt_type = SALT_TYPE_INTERN;
8023 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8024 opts_type = OPTS_TYPE_PT_GENERATE_BE
8025 | OPTS_TYPE_PT_ADD80
8026 | OPTS_TYPE_PT_ADDBITS15;
8027 kern_type = KERN_TYPE_SHA512_SLTPW;
8028 dgst_size = DGST_SIZE_8_8;
8029 parse_func = sha512s_parse_hash;
8030 sort_by_digest = sort_by_digest_8_8;
8031 opti_type = OPTI_TYPE_ZERO_BYTE
8032 | OPTI_TYPE_PRECOMPUTE_INIT
8033 | OPTI_TYPE_PRECOMPUTE_MERKLE
8034 | OPTI_TYPE_EARLY_SKIP
8035 | OPTI_TYPE_NOT_ITERATED
8036 | OPTI_TYPE_PREPENDED_SALT
8037 | OPTI_TYPE_USES_BITS_64
8038 | OPTI_TYPE_RAW_HASH;
8039 dgst_pos0 = 14;
8040 dgst_pos1 = 15;
8041 dgst_pos2 = 6;
8042 dgst_pos3 = 7;
8043 break;
8044
8045 case 1722: hash_type = HASH_TYPE_SHA512;
8046 salt_type = SALT_TYPE_EMBEDDED;
8047 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8048 opts_type = OPTS_TYPE_PT_GENERATE_BE
8049 | OPTS_TYPE_PT_ADD80
8050 | OPTS_TYPE_PT_ADDBITS15
8051 | OPTS_TYPE_ST_HEX;
8052 kern_type = KERN_TYPE_SHA512_SLTPW;
8053 dgst_size = DGST_SIZE_8_8;
8054 parse_func = osx512_parse_hash;
8055 sort_by_digest = sort_by_digest_8_8;
8056 opti_type = OPTI_TYPE_ZERO_BYTE
8057 | OPTI_TYPE_PRECOMPUTE_INIT
8058 | OPTI_TYPE_PRECOMPUTE_MERKLE
8059 | OPTI_TYPE_EARLY_SKIP
8060 | OPTI_TYPE_NOT_ITERATED
8061 | OPTI_TYPE_PREPENDED_SALT
8062 | OPTI_TYPE_USES_BITS_64
8063 | OPTI_TYPE_RAW_HASH;
8064 dgst_pos0 = 14;
8065 dgst_pos1 = 15;
8066 dgst_pos2 = 6;
8067 dgst_pos3 = 7;
8068 break;
8069
8070 case 1730: hash_type = HASH_TYPE_SHA512;
8071 salt_type = SALT_TYPE_INTERN;
8072 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8073 opts_type = OPTS_TYPE_PT_GENERATE_BE
8074 | OPTS_TYPE_PT_UNICODE
8075 | OPTS_TYPE_ST_ADD80
8076 | OPTS_TYPE_ST_ADDBITS15;
8077 kern_type = KERN_TYPE_SHA512_PWSLTU;
8078 dgst_size = DGST_SIZE_8_8;
8079 parse_func = sha512s_parse_hash;
8080 sort_by_digest = sort_by_digest_8_8;
8081 opti_type = OPTI_TYPE_ZERO_BYTE
8082 | OPTI_TYPE_PRECOMPUTE_INIT
8083 | OPTI_TYPE_PRECOMPUTE_MERKLE
8084 | OPTI_TYPE_EARLY_SKIP
8085 | OPTI_TYPE_NOT_ITERATED
8086 | OPTI_TYPE_APPENDED_SALT
8087 | OPTI_TYPE_USES_BITS_64
8088 | OPTI_TYPE_RAW_HASH;
8089 dgst_pos0 = 14;
8090 dgst_pos1 = 15;
8091 dgst_pos2 = 6;
8092 dgst_pos3 = 7;
8093 break;
8094
8095 case 1731: hash_type = HASH_TYPE_SHA512;
8096 salt_type = SALT_TYPE_EMBEDDED;
8097 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8098 opts_type = OPTS_TYPE_PT_GENERATE_BE
8099 | OPTS_TYPE_PT_UNICODE
8100 | OPTS_TYPE_ST_ADD80
8101 | OPTS_TYPE_ST_ADDBITS15
8102 | OPTS_TYPE_ST_HEX;
8103 kern_type = KERN_TYPE_SHA512_PWSLTU;
8104 dgst_size = DGST_SIZE_8_8;
8105 parse_func = mssql2012_parse_hash;
8106 sort_by_digest = sort_by_digest_8_8;
8107 opti_type = OPTI_TYPE_ZERO_BYTE
8108 | OPTI_TYPE_PRECOMPUTE_INIT
8109 | OPTI_TYPE_PRECOMPUTE_MERKLE
8110 | OPTI_TYPE_EARLY_SKIP
8111 | OPTI_TYPE_NOT_ITERATED
8112 | OPTI_TYPE_APPENDED_SALT
8113 | OPTI_TYPE_USES_BITS_64
8114 | OPTI_TYPE_RAW_HASH;
8115 dgst_pos0 = 14;
8116 dgst_pos1 = 15;
8117 dgst_pos2 = 6;
8118 dgst_pos3 = 7;
8119 break;
8120
8121 case 1740: hash_type = HASH_TYPE_SHA512;
8122 salt_type = SALT_TYPE_INTERN;
8123 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8124 opts_type = OPTS_TYPE_PT_GENERATE_BE
8125 | OPTS_TYPE_PT_ADD80
8126 | OPTS_TYPE_PT_ADDBITS15
8127 | OPTS_TYPE_PT_UNICODE;
8128 kern_type = KERN_TYPE_SHA512_SLTPWU;
8129 dgst_size = DGST_SIZE_8_8;
8130 parse_func = sha512s_parse_hash;
8131 sort_by_digest = sort_by_digest_8_8;
8132 opti_type = OPTI_TYPE_ZERO_BYTE
8133 | OPTI_TYPE_PRECOMPUTE_INIT
8134 | OPTI_TYPE_PRECOMPUTE_MERKLE
8135 | OPTI_TYPE_EARLY_SKIP
8136 | OPTI_TYPE_NOT_ITERATED
8137 | OPTI_TYPE_PREPENDED_SALT
8138 | OPTI_TYPE_USES_BITS_64
8139 | OPTI_TYPE_RAW_HASH;
8140 dgst_pos0 = 14;
8141 dgst_pos1 = 15;
8142 dgst_pos2 = 6;
8143 dgst_pos3 = 7;
8144 break;
8145
8146 case 1750: hash_type = HASH_TYPE_SHA512;
8147 salt_type = SALT_TYPE_INTERN;
8148 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8149 opts_type = OPTS_TYPE_PT_GENERATE_BE
8150 | OPTS_TYPE_ST_ADD80;
8151 kern_type = KERN_TYPE_HMACSHA512_PW;
8152 dgst_size = DGST_SIZE_8_8;
8153 parse_func = hmacsha512_parse_hash;
8154 sort_by_digest = sort_by_digest_8_8;
8155 opti_type = OPTI_TYPE_ZERO_BYTE
8156 | OPTI_TYPE_USES_BITS_64
8157 | OPTI_TYPE_NOT_ITERATED;
8158 dgst_pos0 = 14;
8159 dgst_pos1 = 15;
8160 dgst_pos2 = 6;
8161 dgst_pos3 = 7;
8162 break;
8163
8164 case 1760: hash_type = HASH_TYPE_SHA512;
8165 salt_type = SALT_TYPE_INTERN;
8166 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8167 opts_type = OPTS_TYPE_PT_GENERATE_BE
8168 | OPTS_TYPE_PT_ADD80
8169 | OPTS_TYPE_PT_ADDBITS15;
8170 kern_type = KERN_TYPE_HMACSHA512_SLT;
8171 dgst_size = DGST_SIZE_8_8;
8172 parse_func = hmacsha512_parse_hash;
8173 sort_by_digest = sort_by_digest_8_8;
8174 opti_type = OPTI_TYPE_ZERO_BYTE
8175 | OPTI_TYPE_USES_BITS_64
8176 | OPTI_TYPE_NOT_ITERATED;
8177 dgst_pos0 = 14;
8178 dgst_pos1 = 15;
8179 dgst_pos2 = 6;
8180 dgst_pos3 = 7;
8181 break;
8182
8183 case 1800: hash_type = HASH_TYPE_SHA512;
8184 salt_type = SALT_TYPE_EMBEDDED;
8185 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8186 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8187 kern_type = KERN_TYPE_SHA512CRYPT;
8188 dgst_size = DGST_SIZE_8_8;
8189 parse_func = sha512crypt_parse_hash;
8190 sort_by_digest = sort_by_digest_8_8;
8191 opti_type = OPTI_TYPE_ZERO_BYTE
8192 | OPTI_TYPE_USES_BITS_64;
8193 dgst_pos0 = 0;
8194 dgst_pos1 = 1;
8195 dgst_pos2 = 2;
8196 dgst_pos3 = 3;
8197 break;
8198
8199 case 2100: hash_type = HASH_TYPE_DCC2;
8200 salt_type = SALT_TYPE_EMBEDDED;
8201 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8202 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8203 | OPTS_TYPE_ST_LOWER
8204 | OPTS_TYPE_ST_UNICODE;
8205 kern_type = KERN_TYPE_DCC2;
8206 dgst_size = DGST_SIZE_4_4;
8207 parse_func = dcc2_parse_hash;
8208 sort_by_digest = sort_by_digest_4_4;
8209 opti_type = OPTI_TYPE_ZERO_BYTE;
8210 dgst_pos0 = 0;
8211 dgst_pos1 = 1;
8212 dgst_pos2 = 2;
8213 dgst_pos3 = 3;
8214 break;
8215
8216 case 2400: hash_type = HASH_TYPE_MD5;
8217 salt_type = SALT_TYPE_NONE;
8218 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8219 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8220 kern_type = KERN_TYPE_MD5PIX;
8221 dgst_size = DGST_SIZE_4_4;
8222 parse_func = md5pix_parse_hash;
8223 sort_by_digest = sort_by_digest_4_4;
8224 opti_type = OPTI_TYPE_ZERO_BYTE
8225 | OPTI_TYPE_PRECOMPUTE_INIT
8226 | OPTI_TYPE_PRECOMPUTE_MERKLE
8227 | OPTI_TYPE_EARLY_SKIP
8228 | OPTI_TYPE_NOT_ITERATED
8229 | OPTI_TYPE_NOT_SALTED;
8230 dgst_pos0 = 0;
8231 dgst_pos1 = 3;
8232 dgst_pos2 = 2;
8233 dgst_pos3 = 1;
8234 break;
8235
8236 case 2410: hash_type = HASH_TYPE_MD5;
8237 salt_type = SALT_TYPE_INTERN;
8238 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8239 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8240 kern_type = KERN_TYPE_MD5ASA;
8241 dgst_size = DGST_SIZE_4_4;
8242 parse_func = md5asa_parse_hash;
8243 sort_by_digest = sort_by_digest_4_4;
8244 opti_type = OPTI_TYPE_ZERO_BYTE
8245 | OPTI_TYPE_PRECOMPUTE_INIT
8246 | OPTI_TYPE_PRECOMPUTE_MERKLE
8247 | OPTI_TYPE_EARLY_SKIP
8248 | OPTI_TYPE_NOT_ITERATED;
8249 dgst_pos0 = 0;
8250 dgst_pos1 = 3;
8251 dgst_pos2 = 2;
8252 dgst_pos3 = 1;
8253 break;
8254
8255 case 2500: hash_type = HASH_TYPE_WPA;
8256 salt_type = SALT_TYPE_EMBEDDED;
8257 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8258 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8259 kern_type = KERN_TYPE_WPA;
8260 dgst_size = DGST_SIZE_4_4;
8261 parse_func = wpa_parse_hash;
8262 sort_by_digest = sort_by_digest_4_4;
8263 opti_type = OPTI_TYPE_ZERO_BYTE;
8264 dgst_pos0 = 0;
8265 dgst_pos1 = 1;
8266 dgst_pos2 = 2;
8267 dgst_pos3 = 3;
8268 break;
8269
8270 case 2600: hash_type = HASH_TYPE_MD5;
8271 salt_type = SALT_TYPE_VIRTUAL;
8272 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8273 opts_type = OPTS_TYPE_PT_GENERATE_LE
8274 | OPTS_TYPE_PT_ADD80
8275 | OPTS_TYPE_PT_ADDBITS14
8276 | OPTS_TYPE_ST_ADD80;
8277 kern_type = KERN_TYPE_MD55_PWSLT1;
8278 dgst_size = DGST_SIZE_4_4;
8279 parse_func = md5md5_parse_hash;
8280 sort_by_digest = sort_by_digest_4_4;
8281 opti_type = OPTI_TYPE_ZERO_BYTE
8282 | OPTI_TYPE_PRECOMPUTE_INIT
8283 | OPTI_TYPE_PRECOMPUTE_MERKLE
8284 | OPTI_TYPE_EARLY_SKIP;
8285 dgst_pos0 = 0;
8286 dgst_pos1 = 3;
8287 dgst_pos2 = 2;
8288 dgst_pos3 = 1;
8289 break;
8290
8291 case 2611: hash_type = HASH_TYPE_MD5;
8292 salt_type = SALT_TYPE_INTERN;
8293 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8294 opts_type = OPTS_TYPE_PT_GENERATE_LE
8295 | OPTS_TYPE_PT_ADD80
8296 | OPTS_TYPE_PT_ADDBITS14
8297 | OPTS_TYPE_ST_ADD80;
8298 kern_type = KERN_TYPE_MD55_PWSLT1;
8299 dgst_size = DGST_SIZE_4_4;
8300 parse_func = vb3_parse_hash;
8301 sort_by_digest = sort_by_digest_4_4;
8302 opti_type = OPTI_TYPE_ZERO_BYTE
8303 | OPTI_TYPE_PRECOMPUTE_INIT
8304 | OPTI_TYPE_PRECOMPUTE_MERKLE
8305 | OPTI_TYPE_EARLY_SKIP;
8306 dgst_pos0 = 0;
8307 dgst_pos1 = 3;
8308 dgst_pos2 = 2;
8309 dgst_pos3 = 1;
8310 break;
8311
8312 case 2612: hash_type = HASH_TYPE_MD5;
8313 salt_type = SALT_TYPE_EMBEDDED;
8314 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8315 opts_type = OPTS_TYPE_PT_GENERATE_LE
8316 | OPTS_TYPE_PT_ADD80
8317 | OPTS_TYPE_PT_ADDBITS14
8318 | OPTS_TYPE_ST_ADD80
8319 | OPTS_TYPE_ST_HEX;
8320 kern_type = KERN_TYPE_MD55_PWSLT1;
8321 dgst_size = DGST_SIZE_4_4;
8322 parse_func = phps_parse_hash;
8323 sort_by_digest = sort_by_digest_4_4;
8324 opti_type = OPTI_TYPE_ZERO_BYTE
8325 | OPTI_TYPE_PRECOMPUTE_INIT
8326 | OPTI_TYPE_PRECOMPUTE_MERKLE
8327 | OPTI_TYPE_EARLY_SKIP;
8328 dgst_pos0 = 0;
8329 dgst_pos1 = 3;
8330 dgst_pos2 = 2;
8331 dgst_pos3 = 1;
8332 break;
8333
8334 case 2711: hash_type = HASH_TYPE_MD5;
8335 salt_type = SALT_TYPE_INTERN;
8336 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8337 opts_type = OPTS_TYPE_PT_GENERATE_LE
8338 | OPTS_TYPE_PT_ADD80
8339 | OPTS_TYPE_PT_ADDBITS14
8340 | OPTS_TYPE_ST_ADD80;
8341 kern_type = KERN_TYPE_MD55_PWSLT2;
8342 dgst_size = DGST_SIZE_4_4;
8343 parse_func = vb30_parse_hash;
8344 sort_by_digest = sort_by_digest_4_4;
8345 opti_type = OPTI_TYPE_ZERO_BYTE
8346 | OPTI_TYPE_PRECOMPUTE_INIT
8347 | OPTI_TYPE_EARLY_SKIP;
8348 dgst_pos0 = 0;
8349 dgst_pos1 = 3;
8350 dgst_pos2 = 2;
8351 dgst_pos3 = 1;
8352 break;
8353
8354 case 2811: hash_type = HASH_TYPE_MD5;
8355 salt_type = SALT_TYPE_INTERN;
8356 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8357 opts_type = OPTS_TYPE_PT_GENERATE_LE
8358 | OPTS_TYPE_PT_ADD80
8359 | OPTS_TYPE_PT_ADDBITS14;
8360 kern_type = KERN_TYPE_MD55_SLTPW;
8361 dgst_size = DGST_SIZE_4_4;
8362 parse_func = ipb2_parse_hash;
8363 sort_by_digest = sort_by_digest_4_4;
8364 opti_type = OPTI_TYPE_ZERO_BYTE
8365 | OPTI_TYPE_PRECOMPUTE_INIT
8366 | OPTI_TYPE_EARLY_SKIP;
8367 dgst_pos0 = 0;
8368 dgst_pos1 = 3;
8369 dgst_pos2 = 2;
8370 dgst_pos3 = 1;
8371 break;
8372
8373 case 3000: hash_type = HASH_TYPE_LM;
8374 salt_type = SALT_TYPE_NONE;
8375 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8376 opts_type = OPTS_TYPE_PT_GENERATE_LE
8377 | OPTS_TYPE_PT_UPPER
8378 | OPTS_TYPE_PT_BITSLICE;
8379 kern_type = KERN_TYPE_LM;
8380 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8381 parse_func = lm_parse_hash;
8382 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8383 opti_type = OPTI_TYPE_ZERO_BYTE
8384 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8385 dgst_pos0 = 0;
8386 dgst_pos1 = 1;
8387 dgst_pos2 = 2;
8388 dgst_pos3 = 3;
8389 break;
8390
8391 case 3100: hash_type = HASH_TYPE_ORACLEH;
8392 salt_type = SALT_TYPE_INTERN;
8393 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8394 opts_type = OPTS_TYPE_PT_GENERATE_LE
8395 | OPTS_TYPE_PT_UPPER
8396 | OPTS_TYPE_ST_UPPER;
8397 kern_type = KERN_TYPE_ORACLEH;
8398 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8399 parse_func = oracleh_parse_hash;
8400 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8401 opti_type = OPTI_TYPE_ZERO_BYTE;
8402 dgst_pos0 = 0;
8403 dgst_pos1 = 1;
8404 dgst_pos2 = 2;
8405 dgst_pos3 = 3;
8406 break;
8407
8408 case 3200: hash_type = HASH_TYPE_BCRYPT;
8409 salt_type = SALT_TYPE_EMBEDDED;
8410 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8411 opts_type = OPTS_TYPE_PT_GENERATE_LE
8412 | OPTS_TYPE_ST_GENERATE_LE;
8413 kern_type = KERN_TYPE_BCRYPT;
8414 dgst_size = DGST_SIZE_4_6;
8415 parse_func = bcrypt_parse_hash;
8416 sort_by_digest = sort_by_digest_4_6;
8417 opti_type = OPTI_TYPE_ZERO_BYTE;
8418 dgst_pos0 = 0;
8419 dgst_pos1 = 1;
8420 dgst_pos2 = 2;
8421 dgst_pos3 = 3;
8422 break;
8423
8424 case 3710: hash_type = HASH_TYPE_MD5;
8425 salt_type = SALT_TYPE_INTERN;
8426 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8427 opts_type = OPTS_TYPE_PT_GENERATE_LE
8428 | OPTS_TYPE_PT_ADD80
8429 | OPTS_TYPE_PT_ADDBITS14;
8430 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8431 dgst_size = DGST_SIZE_4_4;
8432 parse_func = md5s_parse_hash;
8433 sort_by_digest = sort_by_digest_4_4;
8434 opti_type = OPTI_TYPE_ZERO_BYTE
8435 | OPTI_TYPE_PRECOMPUTE_INIT
8436 | OPTI_TYPE_PRECOMPUTE_MERKLE
8437 | OPTI_TYPE_EARLY_SKIP;
8438 dgst_pos0 = 0;
8439 dgst_pos1 = 3;
8440 dgst_pos2 = 2;
8441 dgst_pos3 = 1;
8442 break;
8443
8444 case 3711: hash_type = HASH_TYPE_MD5;
8445 salt_type = SALT_TYPE_EMBEDDED;
8446 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8447 opts_type = OPTS_TYPE_PT_GENERATE_LE
8448 | OPTS_TYPE_PT_ADD80
8449 | OPTS_TYPE_PT_ADDBITS14;
8450 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8451 dgst_size = DGST_SIZE_4_4;
8452 parse_func = mediawiki_b_parse_hash;
8453 sort_by_digest = sort_by_digest_4_4;
8454 opti_type = OPTI_TYPE_ZERO_BYTE
8455 | OPTI_TYPE_PRECOMPUTE_INIT
8456 | OPTI_TYPE_PRECOMPUTE_MERKLE
8457 | OPTI_TYPE_EARLY_SKIP;
8458 dgst_pos0 = 0;
8459 dgst_pos1 = 3;
8460 dgst_pos2 = 2;
8461 dgst_pos3 = 1;
8462 break;
8463
8464 case 3800: hash_type = HASH_TYPE_MD5;
8465 salt_type = SALT_TYPE_INTERN;
8466 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8467 opts_type = OPTS_TYPE_PT_GENERATE_LE
8468 | OPTS_TYPE_ST_ADDBITS14;
8469 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8470 dgst_size = DGST_SIZE_4_4;
8471 parse_func = md5s_parse_hash;
8472 sort_by_digest = sort_by_digest_4_4;
8473 opti_type = OPTI_TYPE_ZERO_BYTE
8474 | OPTI_TYPE_PRECOMPUTE_INIT
8475 | OPTI_TYPE_PRECOMPUTE_MERKLE
8476 | OPTI_TYPE_EARLY_SKIP
8477 | OPTI_TYPE_NOT_ITERATED
8478 | OPTI_TYPE_RAW_HASH;
8479 dgst_pos0 = 0;
8480 dgst_pos1 = 3;
8481 dgst_pos2 = 2;
8482 dgst_pos3 = 1;
8483 break;
8484
8485 case 4300: hash_type = HASH_TYPE_MD5;
8486 salt_type = SALT_TYPE_VIRTUAL;
8487 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8488 opts_type = OPTS_TYPE_PT_GENERATE_LE
8489 | OPTS_TYPE_PT_ADD80
8490 | OPTS_TYPE_PT_ADDBITS14
8491 | OPTS_TYPE_ST_ADD80;
8492 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8493 dgst_size = DGST_SIZE_4_4;
8494 parse_func = md5md5_parse_hash;
8495 sort_by_digest = sort_by_digest_4_4;
8496 opti_type = OPTI_TYPE_ZERO_BYTE
8497 | OPTI_TYPE_PRECOMPUTE_INIT
8498 | OPTI_TYPE_PRECOMPUTE_MERKLE
8499 | OPTI_TYPE_EARLY_SKIP;
8500 dgst_pos0 = 0;
8501 dgst_pos1 = 3;
8502 dgst_pos2 = 2;
8503 dgst_pos3 = 1;
8504 break;
8505
8506
8507 case 4400: hash_type = HASH_TYPE_MD5;
8508 salt_type = SALT_TYPE_NONE;
8509 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8510 opts_type = OPTS_TYPE_PT_GENERATE_BE
8511 | OPTS_TYPE_PT_ADD80
8512 | OPTS_TYPE_PT_ADDBITS15;
8513 kern_type = KERN_TYPE_MD5_SHA1;
8514 dgst_size = DGST_SIZE_4_4;
8515 parse_func = md5_parse_hash;
8516 sort_by_digest = sort_by_digest_4_4;
8517 opti_type = OPTI_TYPE_ZERO_BYTE
8518 | OPTI_TYPE_PRECOMPUTE_INIT
8519 | OPTI_TYPE_PRECOMPUTE_MERKLE
8520 | OPTI_TYPE_EARLY_SKIP
8521 | OPTI_TYPE_NOT_ITERATED
8522 | OPTI_TYPE_NOT_SALTED
8523 | OPTI_TYPE_RAW_HASH;
8524 dgst_pos0 = 0;
8525 dgst_pos1 = 3;
8526 dgst_pos2 = 2;
8527 dgst_pos3 = 1;
8528 break;
8529
8530 case 4500: hash_type = HASH_TYPE_SHA1;
8531 salt_type = SALT_TYPE_NONE;
8532 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8533 opts_type = OPTS_TYPE_PT_GENERATE_BE
8534 | OPTS_TYPE_PT_ADD80
8535 | OPTS_TYPE_PT_ADDBITS15;
8536 kern_type = KERN_TYPE_SHA11;
8537 dgst_size = DGST_SIZE_4_5;
8538 parse_func = sha1_parse_hash;
8539 sort_by_digest = sort_by_digest_4_5;
8540 opti_type = OPTI_TYPE_ZERO_BYTE
8541 | OPTI_TYPE_PRECOMPUTE_INIT
8542 | OPTI_TYPE_PRECOMPUTE_MERKLE
8543 | OPTI_TYPE_EARLY_SKIP
8544 | OPTI_TYPE_NOT_SALTED;
8545 dgst_pos0 = 3;
8546 dgst_pos1 = 4;
8547 dgst_pos2 = 2;
8548 dgst_pos3 = 1;
8549 break;
8550
8551 case 4700: hash_type = HASH_TYPE_SHA1;
8552 salt_type = SALT_TYPE_NONE;
8553 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8554 opts_type = OPTS_TYPE_PT_GENERATE_LE
8555 | OPTS_TYPE_PT_ADD80
8556 | OPTS_TYPE_PT_ADDBITS14;
8557 kern_type = KERN_TYPE_SHA1_MD5;
8558 dgst_size = DGST_SIZE_4_5;
8559 parse_func = sha1_parse_hash;
8560 sort_by_digest = sort_by_digest_4_5;
8561 opti_type = OPTI_TYPE_ZERO_BYTE
8562 | OPTI_TYPE_PRECOMPUTE_INIT
8563 | OPTI_TYPE_PRECOMPUTE_MERKLE
8564 | OPTI_TYPE_EARLY_SKIP
8565 | OPTI_TYPE_NOT_ITERATED
8566 | OPTI_TYPE_NOT_SALTED
8567 | OPTI_TYPE_RAW_HASH;
8568 dgst_pos0 = 3;
8569 dgst_pos1 = 4;
8570 dgst_pos2 = 2;
8571 dgst_pos3 = 1;
8572 break;
8573
8574 case 4800: hash_type = HASH_TYPE_MD5;
8575 salt_type = SALT_TYPE_EMBEDDED;
8576 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8577 opts_type = OPTS_TYPE_PT_GENERATE_LE
8578 | OPTS_TYPE_PT_ADDBITS14;
8579 kern_type = KERN_TYPE_MD5_CHAP;
8580 dgst_size = DGST_SIZE_4_4;
8581 parse_func = chap_parse_hash;
8582 sort_by_digest = sort_by_digest_4_4;
8583 opti_type = OPTI_TYPE_ZERO_BYTE
8584 | OPTI_TYPE_PRECOMPUTE_INIT
8585 | OPTI_TYPE_PRECOMPUTE_MERKLE
8586 | OPTI_TYPE_MEET_IN_MIDDLE
8587 | OPTI_TYPE_EARLY_SKIP
8588 | OPTI_TYPE_NOT_ITERATED
8589 | OPTI_TYPE_RAW_HASH;
8590 dgst_pos0 = 0;
8591 dgst_pos1 = 3;
8592 dgst_pos2 = 2;
8593 dgst_pos3 = 1;
8594 break;
8595
8596 case 4900: hash_type = HASH_TYPE_SHA1;
8597 salt_type = SALT_TYPE_INTERN;
8598 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8599 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8600 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8601 dgst_size = DGST_SIZE_4_5;
8602 parse_func = sha1s_parse_hash;
8603 sort_by_digest = sort_by_digest_4_5;
8604 opti_type = OPTI_TYPE_ZERO_BYTE
8605 | OPTI_TYPE_PRECOMPUTE_INIT
8606 | OPTI_TYPE_PRECOMPUTE_MERKLE
8607 | OPTI_TYPE_EARLY_SKIP;
8608 dgst_pos0 = 3;
8609 dgst_pos1 = 4;
8610 dgst_pos2 = 2;
8611 dgst_pos3 = 1;
8612 break;
8613
8614 case 5000: hash_type = HASH_TYPE_KECCAK;
8615 salt_type = SALT_TYPE_EMBEDDED;
8616 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8617 opts_type = OPTS_TYPE_PT_GENERATE_LE
8618 | OPTS_TYPE_PT_ADD01;
8619 kern_type = KERN_TYPE_KECCAK;
8620 dgst_size = DGST_SIZE_8_25;
8621 parse_func = keccak_parse_hash;
8622 sort_by_digest = sort_by_digest_8_25;
8623 opti_type = OPTI_TYPE_ZERO_BYTE
8624 | OPTI_TYPE_USES_BITS_64
8625 | OPTI_TYPE_RAW_HASH;
8626 dgst_pos0 = 2;
8627 dgst_pos1 = 3;
8628 dgst_pos2 = 4;
8629 dgst_pos3 = 5;
8630 break;
8631
8632 case 5100: hash_type = HASH_TYPE_MD5H;
8633 salt_type = SALT_TYPE_NONE;
8634 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8635 opts_type = OPTS_TYPE_PT_GENERATE_LE
8636 | OPTS_TYPE_PT_ADD80
8637 | OPTS_TYPE_PT_ADDBITS14;
8638 kern_type = KERN_TYPE_MD5H;
8639 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8640 parse_func = md5half_parse_hash;
8641 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8642 opti_type = OPTI_TYPE_ZERO_BYTE
8643 | OPTI_TYPE_RAW_HASH;
8644 dgst_pos0 = 0;
8645 dgst_pos1 = 1;
8646 dgst_pos2 = 2;
8647 dgst_pos3 = 3;
8648 break;
8649
8650 case 5200: hash_type = HASH_TYPE_SHA256;
8651 salt_type = SALT_TYPE_EMBEDDED;
8652 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8653 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8654 kern_type = KERN_TYPE_PSAFE3;
8655 dgst_size = DGST_SIZE_4_8;
8656 parse_func = psafe3_parse_hash;
8657 sort_by_digest = sort_by_digest_4_8;
8658 opti_type = OPTI_TYPE_ZERO_BYTE;
8659 dgst_pos0 = 0;
8660 dgst_pos1 = 1;
8661 dgst_pos2 = 2;
8662 dgst_pos3 = 3;
8663 break;
8664
8665 case 5300: hash_type = HASH_TYPE_MD5;
8666 salt_type = SALT_TYPE_EMBEDDED;
8667 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8668 opts_type = OPTS_TYPE_PT_GENERATE_LE
8669 | OPTS_TYPE_ST_ADD80;
8670 kern_type = KERN_TYPE_IKEPSK_MD5;
8671 dgst_size = DGST_SIZE_4_4;
8672 parse_func = ikepsk_md5_parse_hash;
8673 sort_by_digest = sort_by_digest_4_4;
8674 opti_type = OPTI_TYPE_ZERO_BYTE;
8675 dgst_pos0 = 0;
8676 dgst_pos1 = 3;
8677 dgst_pos2 = 2;
8678 dgst_pos3 = 1;
8679 break;
8680
8681 case 5400: hash_type = HASH_TYPE_SHA1;
8682 salt_type = SALT_TYPE_EMBEDDED;
8683 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8684 opts_type = OPTS_TYPE_PT_GENERATE_BE
8685 | OPTS_TYPE_ST_ADD80;
8686 kern_type = KERN_TYPE_IKEPSK_SHA1;
8687 dgst_size = DGST_SIZE_4_5;
8688 parse_func = ikepsk_sha1_parse_hash;
8689 sort_by_digest = sort_by_digest_4_5;
8690 opti_type = OPTI_TYPE_ZERO_BYTE;
8691 dgst_pos0 = 3;
8692 dgst_pos1 = 4;
8693 dgst_pos2 = 2;
8694 dgst_pos3 = 1;
8695 break;
8696
8697 case 5500: hash_type = HASH_TYPE_NETNTLM;
8698 salt_type = SALT_TYPE_EMBEDDED;
8699 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8700 opts_type = OPTS_TYPE_PT_GENERATE_LE
8701 | OPTS_TYPE_PT_ADD80
8702 | OPTS_TYPE_PT_ADDBITS14
8703 | OPTS_TYPE_PT_UNICODE
8704 | OPTS_TYPE_ST_HEX;
8705 kern_type = KERN_TYPE_NETNTLMv1;
8706 dgst_size = DGST_SIZE_4_4;
8707 parse_func = netntlmv1_parse_hash;
8708 sort_by_digest = sort_by_digest_4_4;
8709 opti_type = OPTI_TYPE_ZERO_BYTE
8710 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8711 dgst_pos0 = 0;
8712 dgst_pos1 = 1;
8713 dgst_pos2 = 2;
8714 dgst_pos3 = 3;
8715 break;
8716
8717 case 5600: hash_type = HASH_TYPE_MD5;
8718 salt_type = SALT_TYPE_EMBEDDED;
8719 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8720 opts_type = OPTS_TYPE_PT_GENERATE_LE
8721 | OPTS_TYPE_PT_ADD80
8722 | OPTS_TYPE_PT_ADDBITS14
8723 | OPTS_TYPE_PT_UNICODE;
8724 kern_type = KERN_TYPE_NETNTLMv2;
8725 dgst_size = DGST_SIZE_4_4;
8726 parse_func = netntlmv2_parse_hash;
8727 sort_by_digest = sort_by_digest_4_4;
8728 opti_type = OPTI_TYPE_ZERO_BYTE;
8729 dgst_pos0 = 0;
8730 dgst_pos1 = 3;
8731 dgst_pos2 = 2;
8732 dgst_pos3 = 1;
8733 break;
8734
8735 case 5700: hash_type = HASH_TYPE_SHA256;
8736 salt_type = SALT_TYPE_NONE;
8737 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8738 opts_type = OPTS_TYPE_PT_GENERATE_BE
8739 | OPTS_TYPE_PT_ADD80
8740 | OPTS_TYPE_PT_ADDBITS15;
8741 kern_type = KERN_TYPE_SHA256;
8742 dgst_size = DGST_SIZE_4_8;
8743 parse_func = cisco4_parse_hash;
8744 sort_by_digest = sort_by_digest_4_8;
8745 opti_type = OPTI_TYPE_ZERO_BYTE
8746 | OPTI_TYPE_PRECOMPUTE_INIT
8747 | OPTI_TYPE_PRECOMPUTE_MERKLE
8748 | OPTI_TYPE_EARLY_SKIP
8749 | OPTI_TYPE_NOT_ITERATED
8750 | OPTI_TYPE_NOT_SALTED
8751 | OPTI_TYPE_RAW_HASH;
8752 dgst_pos0 = 3;
8753 dgst_pos1 = 7;
8754 dgst_pos2 = 2;
8755 dgst_pos3 = 6;
8756 break;
8757
8758 case 5800: hash_type = HASH_TYPE_SHA1;
8759 salt_type = SALT_TYPE_INTERN;
8760 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8761 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8762 | OPTS_TYPE_ST_ADD80;
8763 kern_type = KERN_TYPE_ANDROIDPIN;
8764 dgst_size = DGST_SIZE_4_5;
8765 parse_func = androidpin_parse_hash;
8766 sort_by_digest = sort_by_digest_4_5;
8767 opti_type = OPTI_TYPE_ZERO_BYTE;
8768 dgst_pos0 = 0;
8769 dgst_pos1 = 1;
8770 dgst_pos2 = 2;
8771 dgst_pos3 = 3;
8772 break;
8773
8774 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8775 salt_type = SALT_TYPE_NONE;
8776 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8777 opts_type = OPTS_TYPE_PT_GENERATE_LE
8778 | OPTS_TYPE_PT_ADD80;
8779 kern_type = KERN_TYPE_RIPEMD160;
8780 dgst_size = DGST_SIZE_4_5;
8781 parse_func = ripemd160_parse_hash;
8782 sort_by_digest = sort_by_digest_4_5;
8783 opti_type = OPTI_TYPE_ZERO_BYTE;
8784 dgst_pos0 = 0;
8785 dgst_pos1 = 1;
8786 dgst_pos2 = 2;
8787 dgst_pos3 = 3;
8788 break;
8789
8790 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8791 salt_type = SALT_TYPE_NONE;
8792 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8793 opts_type = OPTS_TYPE_PT_GENERATE_BE
8794 | OPTS_TYPE_PT_ADD80;
8795 kern_type = KERN_TYPE_WHIRLPOOL;
8796 dgst_size = DGST_SIZE_4_16;
8797 parse_func = whirlpool_parse_hash;
8798 sort_by_digest = sort_by_digest_4_16;
8799 opti_type = OPTI_TYPE_ZERO_BYTE;
8800 dgst_pos0 = 0;
8801 dgst_pos1 = 1;
8802 dgst_pos2 = 2;
8803 dgst_pos3 = 3;
8804 break;
8805
8806 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8807 salt_type = SALT_TYPE_EMBEDDED;
8808 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8809 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8810 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8811 dgst_size = DGST_SIZE_4_5;
8812 parse_func = truecrypt_parse_hash_2k;
8813 sort_by_digest = sort_by_digest_4_5;
8814 opti_type = OPTI_TYPE_ZERO_BYTE;
8815 dgst_pos0 = 0;
8816 dgst_pos1 = 1;
8817 dgst_pos2 = 2;
8818 dgst_pos3 = 3;
8819 break;
8820
8821 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8822 salt_type = SALT_TYPE_EMBEDDED;
8823 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8824 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8825 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8826 dgst_size = DGST_SIZE_4_5;
8827 parse_func = truecrypt_parse_hash_2k;
8828 sort_by_digest = sort_by_digest_4_5;
8829 opti_type = OPTI_TYPE_ZERO_BYTE;
8830 dgst_pos0 = 0;
8831 dgst_pos1 = 1;
8832 dgst_pos2 = 2;
8833 dgst_pos3 = 3;
8834 break;
8835
8836 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8837 salt_type = SALT_TYPE_EMBEDDED;
8838 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8839 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8840 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8841 dgst_size = DGST_SIZE_4_5;
8842 parse_func = truecrypt_parse_hash_2k;
8843 sort_by_digest = sort_by_digest_4_5;
8844 opti_type = OPTI_TYPE_ZERO_BYTE;
8845 dgst_pos0 = 0;
8846 dgst_pos1 = 1;
8847 dgst_pos2 = 2;
8848 dgst_pos3 = 3;
8849 break;
8850
8851 case 6221: hash_type = HASH_TYPE_SHA512;
8852 salt_type = SALT_TYPE_EMBEDDED;
8853 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8854 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8855 kern_type = KERN_TYPE_TCSHA512_XTS512;
8856 dgst_size = DGST_SIZE_8_8;
8857 parse_func = truecrypt_parse_hash_1k;
8858 sort_by_digest = sort_by_digest_8_8;
8859 opti_type = OPTI_TYPE_ZERO_BYTE
8860 | OPTI_TYPE_USES_BITS_64;
8861 dgst_pos0 = 0;
8862 dgst_pos1 = 1;
8863 dgst_pos2 = 2;
8864 dgst_pos3 = 3;
8865 break;
8866
8867 case 6222: hash_type = HASH_TYPE_SHA512;
8868 salt_type = SALT_TYPE_EMBEDDED;
8869 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8870 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8871 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8872 dgst_size = DGST_SIZE_8_8;
8873 parse_func = truecrypt_parse_hash_1k;
8874 sort_by_digest = sort_by_digest_8_8;
8875 opti_type = OPTI_TYPE_ZERO_BYTE
8876 | OPTI_TYPE_USES_BITS_64;
8877 dgst_pos0 = 0;
8878 dgst_pos1 = 1;
8879 dgst_pos2 = 2;
8880 dgst_pos3 = 3;
8881 break;
8882
8883 case 6223: hash_type = HASH_TYPE_SHA512;
8884 salt_type = SALT_TYPE_EMBEDDED;
8885 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8886 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8887 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8888 dgst_size = DGST_SIZE_8_8;
8889 parse_func = truecrypt_parse_hash_1k;
8890 sort_by_digest = sort_by_digest_8_8;
8891 opti_type = OPTI_TYPE_ZERO_BYTE
8892 | OPTI_TYPE_USES_BITS_64;
8893 dgst_pos0 = 0;
8894 dgst_pos1 = 1;
8895 dgst_pos2 = 2;
8896 dgst_pos3 = 3;
8897 break;
8898
8899 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8900 salt_type = SALT_TYPE_EMBEDDED;
8901 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8902 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8903 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8904 dgst_size = DGST_SIZE_4_8;
8905 parse_func = truecrypt_parse_hash_1k;
8906 sort_by_digest = sort_by_digest_4_8;
8907 opti_type = OPTI_TYPE_ZERO_BYTE;
8908 dgst_pos0 = 0;
8909 dgst_pos1 = 1;
8910 dgst_pos2 = 2;
8911 dgst_pos3 = 3;
8912 break;
8913
8914 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8915 salt_type = SALT_TYPE_EMBEDDED;
8916 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8917 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8918 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8919 dgst_size = DGST_SIZE_4_8;
8920 parse_func = truecrypt_parse_hash_1k;
8921 sort_by_digest = sort_by_digest_4_8;
8922 opti_type = OPTI_TYPE_ZERO_BYTE;
8923 dgst_pos0 = 0;
8924 dgst_pos1 = 1;
8925 dgst_pos2 = 2;
8926 dgst_pos3 = 3;
8927 break;
8928
8929 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8930 salt_type = SALT_TYPE_EMBEDDED;
8931 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8932 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8933 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8934 dgst_size = DGST_SIZE_4_8;
8935 parse_func = truecrypt_parse_hash_1k;
8936 sort_by_digest = sort_by_digest_4_8;
8937 opti_type = OPTI_TYPE_ZERO_BYTE;
8938 dgst_pos0 = 0;
8939 dgst_pos1 = 1;
8940 dgst_pos2 = 2;
8941 dgst_pos3 = 3;
8942 break;
8943
8944 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8945 salt_type = SALT_TYPE_EMBEDDED;
8946 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8947 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8948 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8949 dgst_size = DGST_SIZE_4_5;
8950 parse_func = truecrypt_parse_hash_1k;
8951 sort_by_digest = sort_by_digest_4_5;
8952 opti_type = OPTI_TYPE_ZERO_BYTE;
8953 dgst_pos0 = 0;
8954 dgst_pos1 = 1;
8955 dgst_pos2 = 2;
8956 dgst_pos3 = 3;
8957 break;
8958
8959 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8960 salt_type = SALT_TYPE_EMBEDDED;
8961 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8962 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8963 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8964 dgst_size = DGST_SIZE_4_5;
8965 parse_func = truecrypt_parse_hash_1k;
8966 sort_by_digest = sort_by_digest_4_5;
8967 opti_type = OPTI_TYPE_ZERO_BYTE;
8968 dgst_pos0 = 0;
8969 dgst_pos1 = 1;
8970 dgst_pos2 = 2;
8971 dgst_pos3 = 3;
8972 break;
8973
8974 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8975 salt_type = SALT_TYPE_EMBEDDED;
8976 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8977 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8978 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8979 dgst_size = DGST_SIZE_4_5;
8980 parse_func = truecrypt_parse_hash_1k;
8981 sort_by_digest = sort_by_digest_4_5;
8982 opti_type = OPTI_TYPE_ZERO_BYTE;
8983 dgst_pos0 = 0;
8984 dgst_pos1 = 1;
8985 dgst_pos2 = 2;
8986 dgst_pos3 = 3;
8987 break;
8988
8989 case 6300: hash_type = HASH_TYPE_MD5;
8990 salt_type = SALT_TYPE_EMBEDDED;
8991 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8992 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8993 kern_type = KERN_TYPE_MD5AIX;
8994 dgst_size = DGST_SIZE_4_4;
8995 parse_func = md5aix_parse_hash;
8996 sort_by_digest = sort_by_digest_4_4;
8997 opti_type = OPTI_TYPE_ZERO_BYTE;
8998 dgst_pos0 = 0;
8999 dgst_pos1 = 1;
9000 dgst_pos2 = 2;
9001 dgst_pos3 = 3;
9002 break;
9003
9004 case 6400: hash_type = HASH_TYPE_SHA256;
9005 salt_type = SALT_TYPE_EMBEDDED;
9006 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9007 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9008 kern_type = KERN_TYPE_SHA256AIX;
9009 dgst_size = DGST_SIZE_4_8;
9010 parse_func = sha256aix_parse_hash;
9011 sort_by_digest = sort_by_digest_4_8;
9012 opti_type = OPTI_TYPE_ZERO_BYTE;
9013 dgst_pos0 = 0;
9014 dgst_pos1 = 1;
9015 dgst_pos2 = 2;
9016 dgst_pos3 = 3;
9017 break;
9018
9019 case 6500: hash_type = HASH_TYPE_SHA512;
9020 salt_type = SALT_TYPE_EMBEDDED;
9021 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9022 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9023 kern_type = KERN_TYPE_SHA512AIX;
9024 dgst_size = DGST_SIZE_8_8;
9025 parse_func = sha512aix_parse_hash;
9026 sort_by_digest = sort_by_digest_8_8;
9027 opti_type = OPTI_TYPE_ZERO_BYTE
9028 | OPTI_TYPE_USES_BITS_64;
9029 dgst_pos0 = 0;
9030 dgst_pos1 = 1;
9031 dgst_pos2 = 2;
9032 dgst_pos3 = 3;
9033 break;
9034
9035 case 6600: hash_type = HASH_TYPE_AES;
9036 salt_type = SALT_TYPE_EMBEDDED;
9037 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9038 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9039 kern_type = KERN_TYPE_AGILEKEY;
9040 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9041 parse_func = agilekey_parse_hash;
9042 sort_by_digest = sort_by_digest_4_5;
9043 opti_type = OPTI_TYPE_ZERO_BYTE;
9044 dgst_pos0 = 0;
9045 dgst_pos1 = 1;
9046 dgst_pos2 = 2;
9047 dgst_pos3 = 3;
9048 break;
9049
9050 case 6700: hash_type = HASH_TYPE_SHA1;
9051 salt_type = SALT_TYPE_EMBEDDED;
9052 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9053 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9054 kern_type = KERN_TYPE_SHA1AIX;
9055 dgst_size = DGST_SIZE_4_5;
9056 parse_func = sha1aix_parse_hash;
9057 sort_by_digest = sort_by_digest_4_5;
9058 opti_type = OPTI_TYPE_ZERO_BYTE;
9059 dgst_pos0 = 0;
9060 dgst_pos1 = 1;
9061 dgst_pos2 = 2;
9062 dgst_pos3 = 3;
9063 break;
9064
9065 case 6800: hash_type = HASH_TYPE_AES;
9066 salt_type = SALT_TYPE_EMBEDDED;
9067 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9068 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9069 kern_type = KERN_TYPE_LASTPASS;
9070 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9071 parse_func = lastpass_parse_hash;
9072 sort_by_digest = sort_by_digest_4_8;
9073 opti_type = OPTI_TYPE_ZERO_BYTE;
9074 dgst_pos0 = 0;
9075 dgst_pos1 = 1;
9076 dgst_pos2 = 2;
9077 dgst_pos3 = 3;
9078 break;
9079
9080 case 6900: hash_type = HASH_TYPE_GOST;
9081 salt_type = SALT_TYPE_NONE;
9082 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9083 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9084 kern_type = KERN_TYPE_GOST;
9085 dgst_size = DGST_SIZE_4_8;
9086 parse_func = gost_parse_hash;
9087 sort_by_digest = sort_by_digest_4_8;
9088 opti_type = OPTI_TYPE_ZERO_BYTE;
9089 dgst_pos0 = 0;
9090 dgst_pos1 = 1;
9091 dgst_pos2 = 2;
9092 dgst_pos3 = 3;
9093 break;
9094
9095 case 7100: hash_type = HASH_TYPE_SHA512;
9096 salt_type = SALT_TYPE_EMBEDDED;
9097 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9098 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9099 kern_type = KERN_TYPE_PBKDF2_SHA512;
9100 dgst_size = DGST_SIZE_8_16;
9101 parse_func = sha512osx_parse_hash;
9102 sort_by_digest = sort_by_digest_8_16;
9103 opti_type = OPTI_TYPE_ZERO_BYTE
9104 | OPTI_TYPE_USES_BITS_64;
9105 dgst_pos0 = 0;
9106 dgst_pos1 = 1;
9107 dgst_pos2 = 2;
9108 dgst_pos3 = 3;
9109 break;
9110
9111 case 7200: hash_type = HASH_TYPE_SHA512;
9112 salt_type = SALT_TYPE_EMBEDDED;
9113 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9114 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9115 kern_type = KERN_TYPE_PBKDF2_SHA512;
9116 dgst_size = DGST_SIZE_8_16;
9117 parse_func = sha512grub_parse_hash;
9118 sort_by_digest = sort_by_digest_8_16;
9119 opti_type = OPTI_TYPE_ZERO_BYTE
9120 | OPTI_TYPE_USES_BITS_64;
9121 dgst_pos0 = 0;
9122 dgst_pos1 = 1;
9123 dgst_pos2 = 2;
9124 dgst_pos3 = 3;
9125 break;
9126
9127 case 7300: hash_type = HASH_TYPE_SHA1;
9128 salt_type = SALT_TYPE_EMBEDDED;
9129 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9130 opts_type = OPTS_TYPE_PT_GENERATE_BE
9131 | OPTS_TYPE_ST_ADD80
9132 | OPTS_TYPE_ST_ADDBITS15;
9133 kern_type = KERN_TYPE_RAKP;
9134 dgst_size = DGST_SIZE_4_5;
9135 parse_func = rakp_parse_hash;
9136 sort_by_digest = sort_by_digest_4_5;
9137 opti_type = OPTI_TYPE_ZERO_BYTE
9138 | OPTI_TYPE_NOT_ITERATED;
9139 dgst_pos0 = 3;
9140 dgst_pos1 = 4;
9141 dgst_pos2 = 2;
9142 dgst_pos3 = 1;
9143 break;
9144
9145 case 7400: hash_type = HASH_TYPE_SHA256;
9146 salt_type = SALT_TYPE_EMBEDDED;
9147 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9148 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9149 kern_type = KERN_TYPE_SHA256CRYPT;
9150 dgst_size = DGST_SIZE_4_8;
9151 parse_func = sha256crypt_parse_hash;
9152 sort_by_digest = sort_by_digest_4_8;
9153 opti_type = OPTI_TYPE_ZERO_BYTE;
9154 dgst_pos0 = 0;
9155 dgst_pos1 = 1;
9156 dgst_pos2 = 2;
9157 dgst_pos3 = 3;
9158 break;
9159
9160 case 7500: hash_type = HASH_TYPE_KRB5PA;
9161 salt_type = SALT_TYPE_EMBEDDED;
9162 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9163 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9164 kern_type = KERN_TYPE_KRB5PA;
9165 dgst_size = DGST_SIZE_4_4;
9166 parse_func = krb5pa_parse_hash;
9167 sort_by_digest = sort_by_digest_4_4;
9168 opti_type = OPTI_TYPE_ZERO_BYTE
9169 | OPTI_TYPE_NOT_ITERATED;
9170 dgst_pos0 = 0;
9171 dgst_pos1 = 1;
9172 dgst_pos2 = 2;
9173 dgst_pos3 = 3;
9174 break;
9175
9176 case 7600: hash_type = HASH_TYPE_SHA1;
9177 salt_type = SALT_TYPE_INTERN;
9178 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9179 opts_type = OPTS_TYPE_PT_GENERATE_BE
9180 | OPTS_TYPE_PT_ADD80
9181 | OPTS_TYPE_PT_ADDBITS15;
9182 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9183 dgst_size = DGST_SIZE_4_5;
9184 parse_func = redmine_parse_hash;
9185 sort_by_digest = sort_by_digest_4_5;
9186 opti_type = OPTI_TYPE_ZERO_BYTE
9187 | OPTI_TYPE_PRECOMPUTE_INIT
9188 | OPTI_TYPE_EARLY_SKIP
9189 | OPTI_TYPE_NOT_ITERATED
9190 | OPTI_TYPE_PREPENDED_SALT;
9191 dgst_pos0 = 3;
9192 dgst_pos1 = 4;
9193 dgst_pos2 = 2;
9194 dgst_pos3 = 1;
9195 break;
9196
9197 case 7700: hash_type = HASH_TYPE_SAPB;
9198 salt_type = SALT_TYPE_EMBEDDED;
9199 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9200 opts_type = OPTS_TYPE_PT_GENERATE_LE
9201 | OPTS_TYPE_PT_UPPER
9202 | OPTS_TYPE_ST_UPPER;
9203 kern_type = KERN_TYPE_SAPB;
9204 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9205 parse_func = sapb_parse_hash;
9206 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9207 opti_type = OPTI_TYPE_ZERO_BYTE
9208 | OPTI_TYPE_PRECOMPUTE_INIT
9209 | OPTI_TYPE_NOT_ITERATED;
9210 dgst_pos0 = 0;
9211 dgst_pos1 = 1;
9212 dgst_pos2 = 2;
9213 dgst_pos3 = 3;
9214 break;
9215
9216 case 7800: hash_type = HASH_TYPE_SAPG;
9217 salt_type = SALT_TYPE_EMBEDDED;
9218 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9219 opts_type = OPTS_TYPE_PT_GENERATE_BE
9220 | OPTS_TYPE_ST_ADD80
9221 | OPTS_TYPE_ST_UPPER;
9222 kern_type = KERN_TYPE_SAPG;
9223 dgst_size = DGST_SIZE_4_5;
9224 parse_func = sapg_parse_hash;
9225 sort_by_digest = sort_by_digest_4_5;
9226 opti_type = OPTI_TYPE_ZERO_BYTE
9227 | OPTI_TYPE_PRECOMPUTE_INIT
9228 | OPTI_TYPE_NOT_ITERATED;
9229 dgst_pos0 = 3;
9230 dgst_pos1 = 4;
9231 dgst_pos2 = 2;
9232 dgst_pos3 = 1;
9233 break;
9234
9235 case 7900: hash_type = HASH_TYPE_SHA512;
9236 salt_type = SALT_TYPE_EMBEDDED;
9237 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9238 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9239 kern_type = KERN_TYPE_DRUPAL7;
9240 dgst_size = DGST_SIZE_8_8;
9241 parse_func = drupal7_parse_hash;
9242 sort_by_digest = sort_by_digest_8_8;
9243 opti_type = OPTI_TYPE_ZERO_BYTE
9244 | OPTI_TYPE_USES_BITS_64;
9245 dgst_pos0 = 0;
9246 dgst_pos1 = 1;
9247 dgst_pos2 = 2;
9248 dgst_pos3 = 3;
9249 break;
9250
9251 case 8000: hash_type = HASH_TYPE_SHA256;
9252 salt_type = SALT_TYPE_EMBEDDED;
9253 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9254 opts_type = OPTS_TYPE_PT_GENERATE_BE
9255 | OPTS_TYPE_PT_UNICODE
9256 | OPTS_TYPE_ST_ADD80
9257 | OPTS_TYPE_ST_HEX;
9258 kern_type = KERN_TYPE_SYBASEASE;
9259 dgst_size = DGST_SIZE_4_8;
9260 parse_func = sybasease_parse_hash;
9261 sort_by_digest = sort_by_digest_4_8;
9262 opti_type = OPTI_TYPE_ZERO_BYTE
9263 | OPTI_TYPE_PRECOMPUTE_INIT
9264 | OPTI_TYPE_EARLY_SKIP
9265 | OPTI_TYPE_NOT_ITERATED
9266 | OPTI_TYPE_RAW_HASH;
9267 dgst_pos0 = 3;
9268 dgst_pos1 = 7;
9269 dgst_pos2 = 2;
9270 dgst_pos3 = 6;
9271 break;
9272
9273 case 8100: hash_type = HASH_TYPE_SHA1;
9274 salt_type = SALT_TYPE_EMBEDDED;
9275 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9276 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9277 kern_type = KERN_TYPE_NETSCALER;
9278 dgst_size = DGST_SIZE_4_5;
9279 parse_func = netscaler_parse_hash;
9280 sort_by_digest = sort_by_digest_4_5;
9281 opti_type = OPTI_TYPE_ZERO_BYTE
9282 | OPTI_TYPE_PRECOMPUTE_INIT
9283 | OPTI_TYPE_PRECOMPUTE_MERKLE
9284 | OPTI_TYPE_EARLY_SKIP
9285 | OPTI_TYPE_NOT_ITERATED
9286 | OPTI_TYPE_PREPENDED_SALT
9287 | OPTI_TYPE_RAW_HASH;
9288 dgst_pos0 = 3;
9289 dgst_pos1 = 4;
9290 dgst_pos2 = 2;
9291 dgst_pos3 = 1;
9292 break;
9293
9294 case 8200: hash_type = HASH_TYPE_SHA256;
9295 salt_type = SALT_TYPE_EMBEDDED;
9296 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9297 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9298 kern_type = KERN_TYPE_CLOUDKEY;
9299 dgst_size = DGST_SIZE_4_8;
9300 parse_func = cloudkey_parse_hash;
9301 sort_by_digest = sort_by_digest_4_8;
9302 opti_type = OPTI_TYPE_ZERO_BYTE;
9303 dgst_pos0 = 0;
9304 dgst_pos1 = 1;
9305 dgst_pos2 = 2;
9306 dgst_pos3 = 3;
9307 break;
9308
9309 case 8300: hash_type = HASH_TYPE_SHA1;
9310 salt_type = SALT_TYPE_EMBEDDED;
9311 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9312 opts_type = OPTS_TYPE_PT_GENERATE_BE
9313 | OPTS_TYPE_ST_HEX
9314 | OPTS_TYPE_ST_ADD80;
9315 kern_type = KERN_TYPE_NSEC3;
9316 dgst_size = DGST_SIZE_4_5;
9317 parse_func = nsec3_parse_hash;
9318 sort_by_digest = sort_by_digest_4_5;
9319 opti_type = OPTI_TYPE_ZERO_BYTE;
9320 dgst_pos0 = 3;
9321 dgst_pos1 = 4;
9322 dgst_pos2 = 2;
9323 dgst_pos3 = 1;
9324 break;
9325
9326 case 8400: hash_type = HASH_TYPE_SHA1;
9327 salt_type = SALT_TYPE_INTERN;
9328 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9329 opts_type = OPTS_TYPE_PT_GENERATE_BE
9330 | OPTS_TYPE_PT_ADD80
9331 | OPTS_TYPE_PT_ADDBITS15;
9332 kern_type = KERN_TYPE_WBB3;
9333 dgst_size = DGST_SIZE_4_5;
9334 parse_func = wbb3_parse_hash;
9335 sort_by_digest = sort_by_digest_4_5;
9336 opti_type = OPTI_TYPE_ZERO_BYTE
9337 | OPTI_TYPE_PRECOMPUTE_INIT
9338 | OPTI_TYPE_NOT_ITERATED;
9339 dgst_pos0 = 3;
9340 dgst_pos1 = 4;
9341 dgst_pos2 = 2;
9342 dgst_pos3 = 1;
9343 break;
9344
9345 case 8500: hash_type = HASH_TYPE_DESRACF;
9346 salt_type = SALT_TYPE_EMBEDDED;
9347 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9348 opts_type = OPTS_TYPE_PT_GENERATE_LE
9349 | OPTS_TYPE_ST_UPPER;
9350 kern_type = KERN_TYPE_RACF;
9351 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9352 parse_func = racf_parse_hash;
9353 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9354 opti_type = OPTI_TYPE_ZERO_BYTE
9355 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9356 dgst_pos0 = 0;
9357 dgst_pos1 = 1;
9358 dgst_pos2 = 2;
9359 dgst_pos3 = 3;
9360 break;
9361
9362 case 8600: hash_type = HASH_TYPE_LOTUS5;
9363 salt_type = SALT_TYPE_NONE;
9364 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9365 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9366 kern_type = KERN_TYPE_LOTUS5;
9367 dgst_size = DGST_SIZE_4_4;
9368 parse_func = lotus5_parse_hash;
9369 sort_by_digest = sort_by_digest_4_4;
9370 opti_type = OPTI_TYPE_EARLY_SKIP
9371 | OPTI_TYPE_NOT_ITERATED
9372 | OPTI_TYPE_NOT_SALTED
9373 | OPTI_TYPE_RAW_HASH;
9374 dgst_pos0 = 0;
9375 dgst_pos1 = 1;
9376 dgst_pos2 = 2;
9377 dgst_pos3 = 3;
9378 break;
9379
9380 case 8700: hash_type = HASH_TYPE_LOTUS6;
9381 salt_type = SALT_TYPE_EMBEDDED;
9382 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9383 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9384 kern_type = KERN_TYPE_LOTUS6;
9385 dgst_size = DGST_SIZE_4_4;
9386 parse_func = lotus6_parse_hash;
9387 sort_by_digest = sort_by_digest_4_4;
9388 opti_type = OPTI_TYPE_EARLY_SKIP
9389 | OPTI_TYPE_NOT_ITERATED
9390 | OPTI_TYPE_RAW_HASH;
9391 dgst_pos0 = 0;
9392 dgst_pos1 = 1;
9393 dgst_pos2 = 2;
9394 dgst_pos3 = 3;
9395 break;
9396
9397 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9398 salt_type = SALT_TYPE_EMBEDDED;
9399 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9400 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9401 kern_type = KERN_TYPE_ANDROIDFDE;
9402 dgst_size = DGST_SIZE_4_4;
9403 parse_func = androidfde_parse_hash;
9404 sort_by_digest = sort_by_digest_4_4;
9405 opti_type = OPTI_TYPE_ZERO_BYTE;
9406 dgst_pos0 = 0;
9407 dgst_pos1 = 1;
9408 dgst_pos2 = 2;
9409 dgst_pos3 = 3;
9410 break;
9411
9412 case 8900: hash_type = HASH_TYPE_SCRYPT;
9413 salt_type = SALT_TYPE_EMBEDDED;
9414 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9415 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9416 kern_type = KERN_TYPE_SCRYPT;
9417 dgst_size = DGST_SIZE_4_8;
9418 parse_func = scrypt_parse_hash;
9419 sort_by_digest = sort_by_digest_4_8;
9420 opti_type = OPTI_TYPE_ZERO_BYTE;
9421 dgst_pos0 = 0;
9422 dgst_pos1 = 1;
9423 dgst_pos2 = 2;
9424 dgst_pos3 = 3;
9425 break;
9426
9427 case 9000: hash_type = HASH_TYPE_SHA1;
9428 salt_type = SALT_TYPE_EMBEDDED;
9429 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9430 opts_type = OPTS_TYPE_PT_GENERATE_LE
9431 | OPTS_TYPE_ST_GENERATE_LE;
9432 kern_type = KERN_TYPE_PSAFE2;
9433 dgst_size = DGST_SIZE_4_5;
9434 parse_func = psafe2_parse_hash;
9435 sort_by_digest = sort_by_digest_4_5;
9436 opti_type = OPTI_TYPE_ZERO_BYTE;
9437 dgst_pos0 = 0;
9438 dgst_pos1 = 1;
9439 dgst_pos2 = 2;
9440 dgst_pos3 = 3;
9441 break;
9442
9443 case 9100: hash_type = HASH_TYPE_LOTUS8;
9444 salt_type = SALT_TYPE_EMBEDDED;
9445 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9446 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9447 kern_type = KERN_TYPE_LOTUS8;
9448 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9449 parse_func = lotus8_parse_hash;
9450 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9451 opti_type = OPTI_TYPE_ZERO_BYTE;
9452 dgst_pos0 = 0;
9453 dgst_pos1 = 1;
9454 dgst_pos2 = 2;
9455 dgst_pos3 = 3;
9456 break;
9457
9458 case 9200: hash_type = HASH_TYPE_SHA256;
9459 salt_type = SALT_TYPE_EMBEDDED;
9460 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9461 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9462 kern_type = KERN_TYPE_PBKDF2_SHA256;
9463 dgst_size = DGST_SIZE_4_32;
9464 parse_func = cisco8_parse_hash;
9465 sort_by_digest = sort_by_digest_4_32;
9466 opti_type = OPTI_TYPE_ZERO_BYTE;
9467 dgst_pos0 = 0;
9468 dgst_pos1 = 1;
9469 dgst_pos2 = 2;
9470 dgst_pos3 = 3;
9471 break;
9472
9473 case 9300: hash_type = HASH_TYPE_SCRYPT;
9474 salt_type = SALT_TYPE_EMBEDDED;
9475 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9476 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9477 kern_type = KERN_TYPE_SCRYPT;
9478 dgst_size = DGST_SIZE_4_8;
9479 parse_func = cisco9_parse_hash;
9480 sort_by_digest = sort_by_digest_4_8;
9481 opti_type = OPTI_TYPE_ZERO_BYTE;
9482 dgst_pos0 = 0;
9483 dgst_pos1 = 1;
9484 dgst_pos2 = 2;
9485 dgst_pos3 = 3;
9486 break;
9487
9488 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9489 salt_type = SALT_TYPE_EMBEDDED;
9490 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9491 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9492 kern_type = KERN_TYPE_OFFICE2007;
9493 dgst_size = DGST_SIZE_4_4;
9494 parse_func = office2007_parse_hash;
9495 sort_by_digest = sort_by_digest_4_4;
9496 opti_type = OPTI_TYPE_ZERO_BYTE;
9497 dgst_pos0 = 0;
9498 dgst_pos1 = 1;
9499 dgst_pos2 = 2;
9500 dgst_pos3 = 3;
9501 break;
9502
9503 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9504 salt_type = SALT_TYPE_EMBEDDED;
9505 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9506 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9507 kern_type = KERN_TYPE_OFFICE2010;
9508 dgst_size = DGST_SIZE_4_4;
9509 parse_func = office2010_parse_hash;
9510 sort_by_digest = sort_by_digest_4_4;
9511 opti_type = OPTI_TYPE_ZERO_BYTE;
9512 dgst_pos0 = 0;
9513 dgst_pos1 = 1;
9514 dgst_pos2 = 2;
9515 dgst_pos3 = 3;
9516 break;
9517
9518 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9519 salt_type = SALT_TYPE_EMBEDDED;
9520 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9521 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9522 kern_type = KERN_TYPE_OFFICE2013;
9523 dgst_size = DGST_SIZE_4_4;
9524 parse_func = office2013_parse_hash;
9525 sort_by_digest = sort_by_digest_4_4;
9526 opti_type = OPTI_TYPE_ZERO_BYTE;
9527 dgst_pos0 = 0;
9528 dgst_pos1 = 1;
9529 dgst_pos2 = 2;
9530 dgst_pos3 = 3;
9531 break;
9532
9533 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9534 salt_type = SALT_TYPE_EMBEDDED;
9535 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9536 opts_type = OPTS_TYPE_PT_GENERATE_LE
9537 | OPTS_TYPE_PT_ADD80
9538 | OPTS_TYPE_PT_UNICODE;
9539 kern_type = KERN_TYPE_OLDOFFICE01;
9540 dgst_size = DGST_SIZE_4_4;
9541 parse_func = oldoffice01_parse_hash;
9542 sort_by_digest = sort_by_digest_4_4;
9543 opti_type = OPTI_TYPE_ZERO_BYTE
9544 | OPTI_TYPE_PRECOMPUTE_INIT
9545 | OPTI_TYPE_NOT_ITERATED;
9546 dgst_pos0 = 0;
9547 dgst_pos1 = 1;
9548 dgst_pos2 = 2;
9549 dgst_pos3 = 3;
9550 break;
9551
9552 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9553 salt_type = SALT_TYPE_EMBEDDED;
9554 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9555 opts_type = OPTS_TYPE_PT_GENERATE_LE
9556 | OPTS_TYPE_PT_ADD80;
9557 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9558 dgst_size = DGST_SIZE_4_4;
9559 parse_func = oldoffice01cm1_parse_hash;
9560 sort_by_digest = sort_by_digest_4_4;
9561 opti_type = OPTI_TYPE_ZERO_BYTE
9562 | OPTI_TYPE_PRECOMPUTE_INIT
9563 | OPTI_TYPE_NOT_ITERATED;
9564 dgst_pos0 = 0;
9565 dgst_pos1 = 1;
9566 dgst_pos2 = 2;
9567 dgst_pos3 = 3;
9568 break;
9569
9570 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9571 salt_type = SALT_TYPE_EMBEDDED;
9572 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9573 opts_type = OPTS_TYPE_PT_GENERATE_LE
9574 | OPTS_TYPE_PT_ADD80
9575 | OPTS_TYPE_PT_UNICODE
9576 | OPTS_TYPE_PT_NEVERCRACK;
9577 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9578 dgst_size = DGST_SIZE_4_4;
9579 parse_func = oldoffice01cm2_parse_hash;
9580 sort_by_digest = sort_by_digest_4_4;
9581 opti_type = OPTI_TYPE_ZERO_BYTE
9582 | OPTI_TYPE_PRECOMPUTE_INIT
9583 | OPTI_TYPE_NOT_ITERATED;
9584 dgst_pos0 = 0;
9585 dgst_pos1 = 1;
9586 dgst_pos2 = 2;
9587 dgst_pos3 = 3;
9588 break;
9589
9590 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9591 salt_type = SALT_TYPE_EMBEDDED;
9592 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9593 opts_type = OPTS_TYPE_PT_GENERATE_BE
9594 | OPTS_TYPE_PT_ADD80
9595 | OPTS_TYPE_PT_UNICODE;
9596 kern_type = KERN_TYPE_OLDOFFICE34;
9597 dgst_size = DGST_SIZE_4_4;
9598 parse_func = oldoffice34_parse_hash;
9599 sort_by_digest = sort_by_digest_4_4;
9600 opti_type = OPTI_TYPE_ZERO_BYTE
9601 | OPTI_TYPE_PRECOMPUTE_INIT
9602 | OPTI_TYPE_NOT_ITERATED;
9603 dgst_pos0 = 0;
9604 dgst_pos1 = 1;
9605 dgst_pos2 = 2;
9606 dgst_pos3 = 3;
9607 break;
9608
9609 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9610 salt_type = SALT_TYPE_EMBEDDED;
9611 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9612 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9613 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9614 dgst_size = DGST_SIZE_4_4;
9615 parse_func = oldoffice34cm1_parse_hash;
9616 sort_by_digest = sort_by_digest_4_4;
9617 opti_type = OPTI_TYPE_ZERO_BYTE
9618 | OPTI_TYPE_PRECOMPUTE_INIT
9619 | OPTI_TYPE_NOT_ITERATED;
9620 dgst_pos0 = 0;
9621 dgst_pos1 = 1;
9622 dgst_pos2 = 2;
9623 dgst_pos3 = 3;
9624 break;
9625
9626 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9627 salt_type = SALT_TYPE_EMBEDDED;
9628 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9629 opts_type = OPTS_TYPE_PT_GENERATE_BE
9630 | OPTS_TYPE_PT_ADD80
9631 | OPTS_TYPE_PT_UNICODE
9632 | OPTS_TYPE_PT_NEVERCRACK;
9633 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9634 dgst_size = DGST_SIZE_4_4;
9635 parse_func = oldoffice34cm2_parse_hash;
9636 sort_by_digest = sort_by_digest_4_4;
9637 opti_type = OPTI_TYPE_ZERO_BYTE
9638 | OPTI_TYPE_PRECOMPUTE_INIT
9639 | OPTI_TYPE_NOT_ITERATED;
9640 dgst_pos0 = 0;
9641 dgst_pos1 = 1;
9642 dgst_pos2 = 2;
9643 dgst_pos3 = 3;
9644 break;
9645
9646 case 9900: hash_type = HASH_TYPE_MD5;
9647 salt_type = SALT_TYPE_NONE;
9648 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9649 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9650 kern_type = KERN_TYPE_RADMIN2;
9651 dgst_size = DGST_SIZE_4_4;
9652 parse_func = radmin2_parse_hash;
9653 sort_by_digest = sort_by_digest_4_4;
9654 opti_type = OPTI_TYPE_ZERO_BYTE
9655 | OPTI_TYPE_PRECOMPUTE_INIT
9656 | OPTI_TYPE_EARLY_SKIP
9657 | OPTI_TYPE_NOT_ITERATED
9658 | OPTI_TYPE_NOT_SALTED;
9659 dgst_pos0 = 0;
9660 dgst_pos1 = 3;
9661 dgst_pos2 = 2;
9662 dgst_pos3 = 1;
9663 break;
9664
9665 case 10000: hash_type = HASH_TYPE_SHA256;
9666 salt_type = SALT_TYPE_EMBEDDED;
9667 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9668 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9669 kern_type = KERN_TYPE_PBKDF2_SHA256;
9670 dgst_size = DGST_SIZE_4_32;
9671 parse_func = djangopbkdf2_parse_hash;
9672 sort_by_digest = sort_by_digest_4_32;
9673 opti_type = OPTI_TYPE_ZERO_BYTE;
9674 dgst_pos0 = 0;
9675 dgst_pos1 = 1;
9676 dgst_pos2 = 2;
9677 dgst_pos3 = 3;
9678 break;
9679
9680 case 10100: hash_type = HASH_TYPE_SIPHASH;
9681 salt_type = SALT_TYPE_EMBEDDED;
9682 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9683 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9684 kern_type = KERN_TYPE_SIPHASH;
9685 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9686 parse_func = siphash_parse_hash;
9687 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9688 opti_type = OPTI_TYPE_ZERO_BYTE
9689 | OPTI_TYPE_NOT_ITERATED
9690 | OPTI_TYPE_RAW_HASH;
9691 dgst_pos0 = 0;
9692 dgst_pos1 = 1;
9693 dgst_pos2 = 2;
9694 dgst_pos3 = 3;
9695 break;
9696
9697 case 10200: hash_type = HASH_TYPE_MD5;
9698 salt_type = SALT_TYPE_EMBEDDED;
9699 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9700 opts_type = OPTS_TYPE_PT_GENERATE_LE
9701 | OPTS_TYPE_ST_ADD80
9702 | OPTS_TYPE_ST_ADDBITS14;
9703 kern_type = KERN_TYPE_HMACMD5_PW;
9704 dgst_size = DGST_SIZE_4_4;
9705 parse_func = crammd5_parse_hash;
9706 sort_by_digest = sort_by_digest_4_4;
9707 opti_type = OPTI_TYPE_ZERO_BYTE
9708 | OPTI_TYPE_NOT_ITERATED;
9709 dgst_pos0 = 0;
9710 dgst_pos1 = 3;
9711 dgst_pos2 = 2;
9712 dgst_pos3 = 1;
9713 break;
9714
9715 case 10300: hash_type = HASH_TYPE_SHA1;
9716 salt_type = SALT_TYPE_EMBEDDED;
9717 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9718 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9719 kern_type = KERN_TYPE_SAPH_SHA1;
9720 dgst_size = DGST_SIZE_4_5;
9721 parse_func = saph_sha1_parse_hash;
9722 sort_by_digest = sort_by_digest_4_5;
9723 opti_type = OPTI_TYPE_ZERO_BYTE;
9724 dgst_pos0 = 0;
9725 dgst_pos1 = 1;
9726 dgst_pos2 = 2;
9727 dgst_pos3 = 3;
9728 break;
9729
9730 case 10400: hash_type = HASH_TYPE_PDFU16;
9731 salt_type = SALT_TYPE_EMBEDDED;
9732 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9733 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9734 kern_type = KERN_TYPE_PDF11;
9735 dgst_size = DGST_SIZE_4_4;
9736 parse_func = pdf11_parse_hash;
9737 sort_by_digest = sort_by_digest_4_4;
9738 opti_type = OPTI_TYPE_ZERO_BYTE
9739 | OPTI_TYPE_NOT_ITERATED;
9740 dgst_pos0 = 0;
9741 dgst_pos1 = 1;
9742 dgst_pos2 = 2;
9743 dgst_pos3 = 3;
9744 break;
9745
9746 case 10410: hash_type = HASH_TYPE_PDFU16;
9747 salt_type = SALT_TYPE_EMBEDDED;
9748 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9749 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9750 kern_type = KERN_TYPE_PDF11CM1;
9751 dgst_size = DGST_SIZE_4_4;
9752 parse_func = pdf11cm1_parse_hash;
9753 sort_by_digest = sort_by_digest_4_4;
9754 opti_type = OPTI_TYPE_ZERO_BYTE
9755 | OPTI_TYPE_NOT_ITERATED;
9756 dgst_pos0 = 0;
9757 dgst_pos1 = 1;
9758 dgst_pos2 = 2;
9759 dgst_pos3 = 3;
9760 break;
9761
9762 case 10420: hash_type = HASH_TYPE_PDFU16;
9763 salt_type = SALT_TYPE_EMBEDDED;
9764 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9765 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9766 kern_type = KERN_TYPE_PDF11CM2;
9767 dgst_size = DGST_SIZE_4_4;
9768 parse_func = pdf11cm2_parse_hash;
9769 sort_by_digest = sort_by_digest_4_4;
9770 opti_type = OPTI_TYPE_ZERO_BYTE
9771 | OPTI_TYPE_NOT_ITERATED;
9772 dgst_pos0 = 0;
9773 dgst_pos1 = 1;
9774 dgst_pos2 = 2;
9775 dgst_pos3 = 3;
9776 break;
9777
9778 case 10500: hash_type = HASH_TYPE_PDFU16;
9779 salt_type = SALT_TYPE_EMBEDDED;
9780 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9781 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9782 kern_type = KERN_TYPE_PDF14;
9783 dgst_size = DGST_SIZE_4_4;
9784 parse_func = pdf14_parse_hash;
9785 sort_by_digest = sort_by_digest_4_4;
9786 opti_type = OPTI_TYPE_ZERO_BYTE
9787 | OPTI_TYPE_NOT_ITERATED;
9788 dgst_pos0 = 0;
9789 dgst_pos1 = 1;
9790 dgst_pos2 = 2;
9791 dgst_pos3 = 3;
9792 break;
9793
9794 case 10600: hash_type = HASH_TYPE_SHA256;
9795 salt_type = SALT_TYPE_EMBEDDED;
9796 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9797 opts_type = OPTS_TYPE_PT_GENERATE_BE
9798 | OPTS_TYPE_ST_ADD80
9799 | OPTS_TYPE_ST_ADDBITS15
9800 | OPTS_TYPE_HASH_COPY;
9801 kern_type = KERN_TYPE_SHA256_PWSLT;
9802 dgst_size = DGST_SIZE_4_8;
9803 parse_func = pdf17l3_parse_hash;
9804 sort_by_digest = sort_by_digest_4_8;
9805 opti_type = OPTI_TYPE_ZERO_BYTE
9806 | OPTI_TYPE_PRECOMPUTE_INIT
9807 | OPTI_TYPE_PRECOMPUTE_MERKLE
9808 | OPTI_TYPE_EARLY_SKIP
9809 | OPTI_TYPE_NOT_ITERATED
9810 | OPTI_TYPE_APPENDED_SALT
9811 | OPTI_TYPE_RAW_HASH;
9812 dgst_pos0 = 3;
9813 dgst_pos1 = 7;
9814 dgst_pos2 = 2;
9815 dgst_pos3 = 6;
9816 break;
9817
9818 case 10700: hash_type = HASH_TYPE_PDFU32;
9819 salt_type = SALT_TYPE_EMBEDDED;
9820 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9821 opts_type = OPTS_TYPE_PT_GENERATE_LE
9822 | OPTS_TYPE_HASH_COPY;
9823 kern_type = KERN_TYPE_PDF17L8;
9824 dgst_size = DGST_SIZE_4_8;
9825 parse_func = pdf17l8_parse_hash;
9826 sort_by_digest = sort_by_digest_4_8;
9827 opti_type = OPTI_TYPE_ZERO_BYTE
9828 | OPTI_TYPE_NOT_ITERATED;
9829 dgst_pos0 = 0;
9830 dgst_pos1 = 1;
9831 dgst_pos2 = 2;
9832 dgst_pos3 = 3;
9833 break;
9834
9835 case 10800: hash_type = HASH_TYPE_SHA384;
9836 salt_type = SALT_TYPE_NONE;
9837 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9838 opts_type = OPTS_TYPE_PT_GENERATE_BE
9839 | OPTS_TYPE_PT_ADD80
9840 | OPTS_TYPE_PT_ADDBITS15;
9841 kern_type = KERN_TYPE_SHA384;
9842 dgst_size = DGST_SIZE_8_8;
9843 parse_func = sha384_parse_hash;
9844 sort_by_digest = sort_by_digest_8_8;
9845 opti_type = OPTI_TYPE_ZERO_BYTE
9846 | OPTI_TYPE_PRECOMPUTE_INIT
9847 | OPTI_TYPE_PRECOMPUTE_MERKLE
9848 | OPTI_TYPE_EARLY_SKIP
9849 | OPTI_TYPE_NOT_ITERATED
9850 | OPTI_TYPE_NOT_SALTED
9851 | OPTI_TYPE_USES_BITS_64
9852 | OPTI_TYPE_RAW_HASH;
9853 dgst_pos0 = 6;
9854 dgst_pos1 = 7;
9855 dgst_pos2 = 4;
9856 dgst_pos3 = 5;
9857 break;
9858
9859 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9860 salt_type = SALT_TYPE_EMBEDDED;
9861 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9862 opts_type = OPTS_TYPE_PT_GENERATE_LE
9863 | OPTS_TYPE_ST_BASE64
9864 | OPTS_TYPE_HASH_COPY;
9865 kern_type = KERN_TYPE_PBKDF2_SHA256;
9866 dgst_size = DGST_SIZE_4_32;
9867 parse_func = pbkdf2_sha256_parse_hash;
9868 sort_by_digest = sort_by_digest_4_32;
9869 opti_type = OPTI_TYPE_ZERO_BYTE;
9870 dgst_pos0 = 0;
9871 dgst_pos1 = 1;
9872 dgst_pos2 = 2;
9873 dgst_pos3 = 3;
9874 break;
9875
9876 case 11000: hash_type = HASH_TYPE_MD5;
9877 salt_type = SALT_TYPE_INTERN;
9878 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9879 opts_type = OPTS_TYPE_PT_GENERATE_LE
9880 | OPTS_TYPE_PT_ADD80;
9881 kern_type = KERN_TYPE_PRESTASHOP;
9882 dgst_size = DGST_SIZE_4_4;
9883 parse_func = prestashop_parse_hash;
9884 sort_by_digest = sort_by_digest_4_4;
9885 opti_type = OPTI_TYPE_ZERO_BYTE
9886 | OPTI_TYPE_PRECOMPUTE_INIT
9887 | OPTI_TYPE_NOT_ITERATED
9888 | OPTI_TYPE_PREPENDED_SALT;
9889 dgst_pos0 = 0;
9890 dgst_pos1 = 3;
9891 dgst_pos2 = 2;
9892 dgst_pos3 = 1;
9893 break;
9894
9895 case 11100: hash_type = HASH_TYPE_MD5;
9896 salt_type = SALT_TYPE_EMBEDDED;
9897 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9898 opts_type = OPTS_TYPE_PT_GENERATE_LE
9899 | OPTS_TYPE_ST_ADD80;
9900 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9901 dgst_size = DGST_SIZE_4_4;
9902 parse_func = postgresql_auth_parse_hash;
9903 sort_by_digest = sort_by_digest_4_4;
9904 opti_type = OPTI_TYPE_ZERO_BYTE
9905 | OPTI_TYPE_PRECOMPUTE_INIT
9906 | OPTI_TYPE_PRECOMPUTE_MERKLE
9907 | OPTI_TYPE_EARLY_SKIP;
9908 dgst_pos0 = 0;
9909 dgst_pos1 = 3;
9910 dgst_pos2 = 2;
9911 dgst_pos3 = 1;
9912 break;
9913
9914 case 11200: hash_type = HASH_TYPE_SHA1;
9915 salt_type = SALT_TYPE_EMBEDDED;
9916 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9917 opts_type = OPTS_TYPE_PT_GENERATE_BE
9918 | OPTS_TYPE_PT_ADD80
9919 | OPTS_TYPE_ST_HEX;
9920 kern_type = KERN_TYPE_MYSQL_AUTH;
9921 dgst_size = DGST_SIZE_4_5;
9922 parse_func = mysql_auth_parse_hash;
9923 sort_by_digest = sort_by_digest_4_5;
9924 opti_type = OPTI_TYPE_ZERO_BYTE
9925 | OPTI_TYPE_EARLY_SKIP;
9926 dgst_pos0 = 3;
9927 dgst_pos1 = 4;
9928 dgst_pos2 = 2;
9929 dgst_pos3 = 1;
9930 break;
9931
9932 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9933 salt_type = SALT_TYPE_EMBEDDED;
9934 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9935 opts_type = OPTS_TYPE_PT_GENERATE_LE
9936 | OPTS_TYPE_ST_HEX
9937 | OPTS_TYPE_ST_ADD80;
9938 kern_type = KERN_TYPE_BITCOIN_WALLET;
9939 dgst_size = DGST_SIZE_4_4;
9940 parse_func = bitcoin_wallet_parse_hash;
9941 sort_by_digest = sort_by_digest_4_4;
9942 opti_type = OPTI_TYPE_ZERO_BYTE;
9943 dgst_pos0 = 0;
9944 dgst_pos1 = 1;
9945 dgst_pos2 = 2;
9946 dgst_pos3 = 3;
9947 break;
9948
9949 case 11400: hash_type = HASH_TYPE_MD5;
9950 salt_type = SALT_TYPE_EMBEDDED;
9951 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9952 opts_type = OPTS_TYPE_PT_GENERATE_LE
9953 | OPTS_TYPE_PT_ADD80
9954 | OPTS_TYPE_HASH_COPY;
9955 kern_type = KERN_TYPE_SIP_AUTH;
9956 dgst_size = DGST_SIZE_4_4;
9957 parse_func = sip_auth_parse_hash;
9958 sort_by_digest = sort_by_digest_4_4;
9959 opti_type = OPTI_TYPE_ZERO_BYTE;
9960 dgst_pos0 = 0;
9961 dgst_pos1 = 3;
9962 dgst_pos2 = 2;
9963 dgst_pos3 = 1;
9964 break;
9965
9966 case 11500: hash_type = HASH_TYPE_CRC32;
9967 salt_type = SALT_TYPE_INTERN;
9968 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9969 opts_type = OPTS_TYPE_PT_GENERATE_LE
9970 | OPTS_TYPE_ST_GENERATE_LE
9971 | OPTS_TYPE_ST_HEX;
9972 kern_type = KERN_TYPE_CRC32;
9973 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9974 parse_func = crc32_parse_hash;
9975 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9976 opti_type = OPTI_TYPE_ZERO_BYTE;
9977 dgst_pos0 = 0;
9978 dgst_pos1 = 1;
9979 dgst_pos2 = 2;
9980 dgst_pos3 = 3;
9981 break;
9982
9983 case 11600: hash_type = HASH_TYPE_AES;
9984 salt_type = SALT_TYPE_EMBEDDED;
9985 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9986 opts_type = OPTS_TYPE_PT_GENERATE_LE
9987 | OPTS_TYPE_PT_NEVERCRACK;
9988 kern_type = KERN_TYPE_SEVEN_ZIP;
9989 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9990 parse_func = seven_zip_parse_hash;
9991 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9992 opti_type = OPTI_TYPE_ZERO_BYTE;
9993 dgst_pos0 = 0;
9994 dgst_pos1 = 1;
9995 dgst_pos2 = 2;
9996 dgst_pos3 = 3;
9997 break;
9998
9999 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10000 salt_type = SALT_TYPE_NONE;
10001 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10002 opts_type = OPTS_TYPE_PT_GENERATE_LE
10003 | OPTS_TYPE_PT_ADD01;
10004 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10005 dgst_size = DGST_SIZE_4_8;
10006 parse_func = gost2012sbog_256_parse_hash;
10007 sort_by_digest = sort_by_digest_4_8;
10008 opti_type = OPTI_TYPE_ZERO_BYTE;
10009 dgst_pos0 = 0;
10010 dgst_pos1 = 1;
10011 dgst_pos2 = 2;
10012 dgst_pos3 = 3;
10013 break;
10014
10015 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10016 salt_type = SALT_TYPE_NONE;
10017 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10018 opts_type = OPTS_TYPE_PT_GENERATE_LE
10019 | OPTS_TYPE_PT_ADD01;
10020 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10021 dgst_size = DGST_SIZE_4_16;
10022 parse_func = gost2012sbog_512_parse_hash;
10023 sort_by_digest = sort_by_digest_4_16;
10024 opti_type = OPTI_TYPE_ZERO_BYTE;
10025 dgst_pos0 = 0;
10026 dgst_pos1 = 1;
10027 dgst_pos2 = 2;
10028 dgst_pos3 = 3;
10029 break;
10030
10031 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10032 salt_type = SALT_TYPE_EMBEDDED;
10033 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10034 opts_type = OPTS_TYPE_PT_GENERATE_LE
10035 | OPTS_TYPE_ST_BASE64
10036 | OPTS_TYPE_HASH_COPY;
10037 kern_type = KERN_TYPE_PBKDF2_MD5;
10038 dgst_size = DGST_SIZE_4_32;
10039 parse_func = pbkdf2_md5_parse_hash;
10040 sort_by_digest = sort_by_digest_4_32;
10041 opti_type = OPTI_TYPE_ZERO_BYTE;
10042 dgst_pos0 = 0;
10043 dgst_pos1 = 1;
10044 dgst_pos2 = 2;
10045 dgst_pos3 = 3;
10046 break;
10047
10048 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10049 salt_type = SALT_TYPE_EMBEDDED;
10050 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10051 opts_type = OPTS_TYPE_PT_GENERATE_LE
10052 | OPTS_TYPE_ST_BASE64
10053 | OPTS_TYPE_HASH_COPY;
10054 kern_type = KERN_TYPE_PBKDF2_SHA1;
10055 dgst_size = DGST_SIZE_4_32;
10056 parse_func = pbkdf2_sha1_parse_hash;
10057 sort_by_digest = sort_by_digest_4_32;
10058 opti_type = OPTI_TYPE_ZERO_BYTE;
10059 dgst_pos0 = 0;
10060 dgst_pos1 = 1;
10061 dgst_pos2 = 2;
10062 dgst_pos3 = 3;
10063 break;
10064
10065 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10066 salt_type = SALT_TYPE_EMBEDDED;
10067 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10068 opts_type = OPTS_TYPE_PT_GENERATE_LE
10069 | OPTS_TYPE_ST_BASE64
10070 | OPTS_TYPE_HASH_COPY;
10071 kern_type = KERN_TYPE_PBKDF2_SHA512;
10072 dgst_size = DGST_SIZE_8_16;
10073 parse_func = pbkdf2_sha512_parse_hash;
10074 sort_by_digest = sort_by_digest_8_16;
10075 opti_type = OPTI_TYPE_ZERO_BYTE
10076 | OPTI_TYPE_USES_BITS_64;
10077 dgst_pos0 = 0;
10078 dgst_pos1 = 1;
10079 dgst_pos2 = 2;
10080 dgst_pos3 = 3;
10081 break;
10082
10083 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10084 salt_type = SALT_TYPE_EMBEDDED;
10085 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10086 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10087 kern_type = KERN_TYPE_ECRYPTFS;
10088 dgst_size = DGST_SIZE_8_8;
10089 parse_func = ecryptfs_parse_hash;
10090 sort_by_digest = sort_by_digest_8_8;
10091 opti_type = OPTI_TYPE_ZERO_BYTE
10092 | OPTI_TYPE_USES_BITS_64;
10093 dgst_pos0 = 0;
10094 dgst_pos1 = 1;
10095 dgst_pos2 = 2;
10096 dgst_pos3 = 3;
10097 break;
10098
10099 case 12300: hash_type = HASH_TYPE_ORACLET;
10100 salt_type = SALT_TYPE_EMBEDDED;
10101 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10102 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10103 kern_type = KERN_TYPE_ORACLET;
10104 dgst_size = DGST_SIZE_8_16;
10105 parse_func = oraclet_parse_hash;
10106 sort_by_digest = sort_by_digest_8_16;
10107 opti_type = OPTI_TYPE_ZERO_BYTE
10108 | OPTI_TYPE_USES_BITS_64;
10109 dgst_pos0 = 0;
10110 dgst_pos1 = 1;
10111 dgst_pos2 = 2;
10112 dgst_pos3 = 3;
10113 break;
10114
10115 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10116 salt_type = SALT_TYPE_EMBEDDED;
10117 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10118 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10119 kern_type = KERN_TYPE_BSDICRYPT;
10120 dgst_size = DGST_SIZE_4_4;
10121 parse_func = bsdicrypt_parse_hash;
10122 sort_by_digest = sort_by_digest_4_4;
10123 opti_type = OPTI_TYPE_ZERO_BYTE
10124 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10125 dgst_pos0 = 0;
10126 dgst_pos1 = 1;
10127 dgst_pos2 = 2;
10128 dgst_pos3 = 3;
10129 break;
10130
10131 case 12500: hash_type = HASH_TYPE_RAR3HP;
10132 salt_type = SALT_TYPE_EMBEDDED;
10133 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10134 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10135 kern_type = KERN_TYPE_RAR3;
10136 dgst_size = DGST_SIZE_4_4;
10137 parse_func = rar3hp_parse_hash;
10138 sort_by_digest = sort_by_digest_4_4;
10139 opti_type = OPTI_TYPE_ZERO_BYTE;
10140 dgst_pos0 = 0;
10141 dgst_pos1 = 1;
10142 dgst_pos2 = 2;
10143 dgst_pos3 = 3;
10144 break;
10145
10146 case 12600: hash_type = HASH_TYPE_SHA256;
10147 salt_type = SALT_TYPE_INTERN;
10148 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10149 opts_type = OPTS_TYPE_PT_GENERATE_BE
10150 | OPTS_TYPE_PT_ADD80;
10151 kern_type = KERN_TYPE_CF10;
10152 dgst_size = DGST_SIZE_4_8;
10153 parse_func = cf10_parse_hash;
10154 sort_by_digest = sort_by_digest_4_8;
10155 opti_type = OPTI_TYPE_ZERO_BYTE
10156 | OPTI_TYPE_PRECOMPUTE_INIT
10157 | OPTI_TYPE_EARLY_SKIP
10158 | OPTI_TYPE_NOT_ITERATED;
10159 dgst_pos0 = 3;
10160 dgst_pos1 = 7;
10161 dgst_pos2 = 2;
10162 dgst_pos3 = 6;
10163 break;
10164
10165 case 12700: hash_type = HASH_TYPE_AES;
10166 salt_type = SALT_TYPE_EMBEDDED;
10167 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10168 opts_type = OPTS_TYPE_PT_GENERATE_LE
10169 | OPTS_TYPE_HASH_COPY;
10170 kern_type = KERN_TYPE_MYWALLET;
10171 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10172 parse_func = mywallet_parse_hash;
10173 sort_by_digest = sort_by_digest_4_5;
10174 opti_type = OPTI_TYPE_ZERO_BYTE;
10175 dgst_pos0 = 0;
10176 dgst_pos1 = 1;
10177 dgst_pos2 = 2;
10178 dgst_pos3 = 3;
10179 break;
10180
10181 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10182 salt_type = SALT_TYPE_EMBEDDED;
10183 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10184 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10185 kern_type = KERN_TYPE_MS_DRSR;
10186 dgst_size = DGST_SIZE_4_8;
10187 parse_func = ms_drsr_parse_hash;
10188 sort_by_digest = sort_by_digest_4_8;
10189 opti_type = OPTI_TYPE_ZERO_BYTE;
10190 dgst_pos0 = 0;
10191 dgst_pos1 = 1;
10192 dgst_pos2 = 2;
10193 dgst_pos3 = 3;
10194 break;
10195
10196 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10197 salt_type = SALT_TYPE_EMBEDDED;
10198 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10199 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10200 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10201 dgst_size = DGST_SIZE_4_8;
10202 parse_func = androidfde_samsung_parse_hash;
10203 sort_by_digest = sort_by_digest_4_8;
10204 opti_type = OPTI_TYPE_ZERO_BYTE;
10205 dgst_pos0 = 0;
10206 dgst_pos1 = 1;
10207 dgst_pos2 = 2;
10208 dgst_pos3 = 3;
10209 break;
10210
10211 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10212 salt_type = SALT_TYPE_EMBEDDED;
10213 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10214 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10215 kern_type = KERN_TYPE_RAR5;
10216 dgst_size = DGST_SIZE_4_4;
10217 parse_func = rar5_parse_hash;
10218 sort_by_digest = sort_by_digest_4_4;
10219 opti_type = OPTI_TYPE_ZERO_BYTE;
10220 dgst_pos0 = 0;
10221 dgst_pos1 = 1;
10222 dgst_pos2 = 2;
10223 dgst_pos3 = 3;
10224 break;
10225
10226 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10227 salt_type = SALT_TYPE_EMBEDDED;
10228 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10229 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10230 kern_type = KERN_TYPE_KRB5TGS;
10231 dgst_size = DGST_SIZE_4_4;
10232 parse_func = krb5tgs_parse_hash;
10233 sort_by_digest = sort_by_digest_4_4;
10234 opti_type = OPTI_TYPE_ZERO_BYTE
10235 | OPTI_TYPE_NOT_ITERATED;
10236 dgst_pos0 = 0;
10237 dgst_pos1 = 1;
10238 dgst_pos2 = 2;
10239 dgst_pos3 = 3;
10240 break;
10241
10242 case 13200: hash_type = HASH_TYPE_AES;
10243 salt_type = SALT_TYPE_EMBEDDED;
10244 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10245 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10246 kern_type = KERN_TYPE_AXCRYPT;
10247 dgst_size = DGST_SIZE_4_4;
10248 parse_func = axcrypt_parse_hash;
10249 sort_by_digest = sort_by_digest_4_4;
10250 opti_type = OPTI_TYPE_ZERO_BYTE;
10251 dgst_pos0 = 0;
10252 dgst_pos1 = 1;
10253 dgst_pos2 = 2;
10254 dgst_pos3 = 3;
10255 break;
10256
10257 case 13300: hash_type = HASH_TYPE_SHA1;
10258 salt_type = SALT_TYPE_NONE;
10259 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10260 opts_type = OPTS_TYPE_PT_GENERATE_BE
10261 | OPTS_TYPE_PT_ADD80
10262 | OPTS_TYPE_PT_ADDBITS15;
10263 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10264 dgst_size = DGST_SIZE_4_5;
10265 parse_func = sha1axcrypt_parse_hash;
10266 sort_by_digest = sort_by_digest_4_5;
10267 opti_type = OPTI_TYPE_ZERO_BYTE
10268 | OPTI_TYPE_PRECOMPUTE_INIT
10269 | OPTI_TYPE_EARLY_SKIP
10270 | OPTI_TYPE_NOT_ITERATED
10271 | OPTI_TYPE_NOT_SALTED;
10272 dgst_pos0 = 0;
10273 dgst_pos1 = 4;
10274 dgst_pos2 = 3;
10275 dgst_pos3 = 2;
10276 break;
10277
10278 case 13400: hash_type = HASH_TYPE_AES;
10279 salt_type = SALT_TYPE_EMBEDDED;
10280 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10281 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10282 kern_type = KERN_TYPE_KEEPASS;
10283 dgst_size = DGST_SIZE_4_4;
10284 parse_func = keepass_parse_hash;
10285 sort_by_digest = sort_by_digest_4_4;
10286 opti_type = OPTI_TYPE_ZERO_BYTE;
10287 dgst_pos0 = 0;
10288 dgst_pos1 = 1;
10289 dgst_pos2 = 2;
10290 dgst_pos3 = 3;
10291 break;
10292
10293 case 13500: hash_type = HASH_TYPE_SHA1;
10294 salt_type = SALT_TYPE_EMBEDDED;
10295 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10296 opts_type = OPTS_TYPE_PT_GENERATE_BE
10297 | OPTS_TYPE_PT_UNICODE
10298 | OPTS_TYPE_PT_ADD80
10299 | OPTS_TYPE_ST_ADDBITS15;
10300 kern_type = KERN_TYPE_SHA1_SLTPWU;
10301 dgst_size = DGST_SIZE_4_5;
10302 parse_func = pstoken_parse_hash;
10303 sort_by_digest = sort_by_digest_4_5;
10304 opti_type = OPTI_TYPE_ZERO_BYTE
10305 | OPTI_TYPE_PRECOMPUTE_INIT
10306 | OPTI_TYPE_PRECOMPUTE_MERKLE
10307 | OPTI_TYPE_EARLY_SKIP
10308 | OPTI_TYPE_NOT_ITERATED
10309 | OPTI_TYPE_PREPENDED_SALT
10310 | OPTI_TYPE_RAW_HASH;
10311 dgst_pos0 = 3;
10312 dgst_pos1 = 4;
10313 dgst_pos2 = 2;
10314 dgst_pos3 = 1;
10315 break;
10316
10317 default: usage_mini_print (PROGNAME); return (-1);
10318 }
10319
10320 /**
10321 * parser
10322 */
10323
10324 data.parse_func = parse_func;
10325
10326 /**
10327 * misc stuff
10328 */
10329
10330 if (hex_salt)
10331 {
10332 if (salt_type == SALT_TYPE_INTERN)
10333 {
10334 opts_type |= OPTS_TYPE_ST_HEX;
10335 }
10336 else
10337 {
10338 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10339
10340 return (-1);
10341 }
10342 }
10343
10344 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10345 | (salt_type == SALT_TYPE_EXTERN)
10346 | (salt_type == SALT_TYPE_EMBEDDED)
10347 | (salt_type == SALT_TYPE_VIRTUAL));
10348
10349 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10350
10351 data.hash_type = hash_type;
10352 data.attack_mode = attack_mode;
10353 data.attack_kern = attack_kern;
10354 data.attack_exec = attack_exec;
10355 data.kern_type = kern_type;
10356 data.opts_type = opts_type;
10357 data.dgst_size = dgst_size;
10358 data.salt_type = salt_type;
10359 data.isSalted = isSalted;
10360 data.sort_by_digest = sort_by_digest;
10361 data.dgst_pos0 = dgst_pos0;
10362 data.dgst_pos1 = dgst_pos1;
10363 data.dgst_pos2 = dgst_pos2;
10364 data.dgst_pos3 = dgst_pos3;
10365
10366 esalt_size = 0;
10367
10368 switch (hash_mode)
10369 {
10370 case 2500: esalt_size = sizeof (wpa_t); break;
10371 case 5300: esalt_size = sizeof (ikepsk_t); break;
10372 case 5400: esalt_size = sizeof (ikepsk_t); break;
10373 case 5500: esalt_size = sizeof (netntlm_t); break;
10374 case 5600: esalt_size = sizeof (netntlm_t); break;
10375 case 6211: esalt_size = sizeof (tc_t); break;
10376 case 6212: esalt_size = sizeof (tc_t); break;
10377 case 6213: esalt_size = sizeof (tc_t); break;
10378 case 6221: esalt_size = sizeof (tc_t); break;
10379 case 6222: esalt_size = sizeof (tc_t); break;
10380 case 6223: esalt_size = sizeof (tc_t); break;
10381 case 6231: esalt_size = sizeof (tc_t); break;
10382 case 6232: esalt_size = sizeof (tc_t); break;
10383 case 6233: esalt_size = sizeof (tc_t); break;
10384 case 6241: esalt_size = sizeof (tc_t); break;
10385 case 6242: esalt_size = sizeof (tc_t); break;
10386 case 6243: esalt_size = sizeof (tc_t); break;
10387 case 6600: esalt_size = sizeof (agilekey_t); break;
10388 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10389 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10390 case 7300: esalt_size = sizeof (rakp_t); break;
10391 case 7500: esalt_size = sizeof (krb5pa_t); break;
10392 case 8200: esalt_size = sizeof (cloudkey_t); break;
10393 case 8800: esalt_size = sizeof (androidfde_t); break;
10394 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10395 case 9400: esalt_size = sizeof (office2007_t); break;
10396 case 9500: esalt_size = sizeof (office2010_t); break;
10397 case 9600: esalt_size = sizeof (office2013_t); break;
10398 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10399 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10400 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10401 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10402 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10403 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10404 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10405 case 10200: esalt_size = sizeof (cram_md5_t); break;
10406 case 10400: esalt_size = sizeof (pdf_t); break;
10407 case 10410: esalt_size = sizeof (pdf_t); break;
10408 case 10420: esalt_size = sizeof (pdf_t); break;
10409 case 10500: esalt_size = sizeof (pdf_t); break;
10410 case 10600: esalt_size = sizeof (pdf_t); break;
10411 case 10700: esalt_size = sizeof (pdf_t); break;
10412 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10413 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10414 case 11400: esalt_size = sizeof (sip_t); break;
10415 case 11600: esalt_size = sizeof (seven_zip_t); break;
10416 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10417 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10418 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10419 case 13000: esalt_size = sizeof (rar5_t); break;
10420 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10421 case 13400: esalt_size = sizeof (keepass_t); break;
10422 case 13500: esalt_size = sizeof (pstoken_t); break;
10423 }
10424
10425 data.esalt_size = esalt_size;
10426
10427 /**
10428 * choose dictionary parser
10429 */
10430
10431 if (hash_type == HASH_TYPE_LM)
10432 {
10433 get_next_word_func = get_next_word_lm;
10434 }
10435 else if (opts_type & OPTS_TYPE_PT_UPPER)
10436 {
10437 get_next_word_func = get_next_word_uc;
10438 }
10439 else
10440 {
10441 get_next_word_func = get_next_word_std;
10442 }
10443
10444 /**
10445 * dictstat
10446 */
10447
10448 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10449
10450 #ifdef _POSIX
10451 size_t dictstat_nmemb = 0;
10452 #endif
10453
10454 #ifdef _WIN
10455 uint dictstat_nmemb = 0;
10456 #endif
10457
10458 char dictstat[256] = { 0 };
10459
10460 FILE *dictstat_fp = NULL;
10461
10462 if (keyspace == 0)
10463 {
10464 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10465
10466 dictstat_fp = fopen (dictstat, "rb");
10467
10468 if (dictstat_fp)
10469 {
10470 #ifdef _POSIX
10471 struct stat tmpstat;
10472
10473 fstat (fileno (dictstat_fp), &tmpstat);
10474 #endif
10475
10476 #ifdef _WIN
10477 struct stat64 tmpstat;
10478
10479 _fstat64 (fileno (dictstat_fp), &tmpstat);
10480 #endif
10481
10482 if (tmpstat.st_mtime < COMPTIME)
10483 {
10484 /* with v0.15 the format changed so we have to ensure user is using a good version
10485 since there is no version-header in the dictstat file */
10486
10487 fclose (dictstat_fp);
10488
10489 unlink (dictstat);
10490 }
10491 else
10492 {
10493 while (!feof (dictstat_fp))
10494 {
10495 dictstat_t d;
10496
10497 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10498
10499 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10500
10501 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10502 {
10503 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10504
10505 return -1;
10506 }
10507 }
10508
10509 fclose (dictstat_fp);
10510 }
10511 }
10512 }
10513
10514 /**
10515 * potfile
10516 */
10517
10518 char potfile[256] = { 0 };
10519
10520 if (potfile_path == NULL)
10521 {
10522 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10523 }
10524 else
10525 {
10526 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10527 }
10528
10529 data.pot_fp = NULL;
10530
10531 FILE *out_fp = NULL;
10532 FILE *pot_fp = NULL;
10533
10534 if (show == 1 || left == 1)
10535 {
10536 pot_fp = fopen (potfile, "rb");
10537
10538 if (pot_fp == NULL)
10539 {
10540 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10541
10542 return (-1);
10543 }
10544
10545 if (outfile != NULL)
10546 {
10547 if ((out_fp = fopen (outfile, "ab")) == NULL)
10548 {
10549 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10550
10551 fclose (pot_fp);
10552
10553 return (-1);
10554 }
10555 }
10556 else
10557 {
10558 out_fp = stdout;
10559 }
10560 }
10561 else
10562 {
10563 if (potfile_disable == 0)
10564 {
10565 pot_fp = fopen (potfile, "ab");
10566
10567 if (pot_fp == NULL)
10568 {
10569 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10570
10571 return (-1);
10572 }
10573
10574 data.pot_fp = pot_fp;
10575 }
10576 }
10577
10578 pot_t *pot = NULL;
10579
10580 uint pot_cnt = 0;
10581 uint pot_avail = 0;
10582
10583 if (show == 1 || left == 1)
10584 {
10585 SUPPRESS_OUTPUT = 1;
10586
10587 pot_avail = count_lines (pot_fp);
10588
10589 rewind (pot_fp);
10590
10591 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10592
10593 uint pot_hashes_avail = 0;
10594
10595 uint line_num = 0;
10596
10597 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10598
10599 while (!feof (pot_fp))
10600 {
10601 line_num++;
10602
10603 int line_len = fgetl (pot_fp, line_buf);
10604
10605 if (line_len == 0) continue;
10606
10607 char *plain_buf = line_buf + line_len;
10608
10609 pot_t *pot_ptr = &pot[pot_cnt];
10610
10611 hash_t *hashes_buf = &pot_ptr->hash;
10612
10613 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10614 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10615
10616 if (pot_cnt == pot_hashes_avail)
10617 {
10618 uint pos = 0;
10619
10620 for (pos = 0; pos < INCR_POT; pos++)
10621 {
10622 if ((pot_cnt + pos) >= pot_avail) break;
10623
10624 pot_t *tmp_pot = &pot[pot_cnt + pos];
10625
10626 hash_t *tmp_hash = &tmp_pot->hash;
10627
10628 tmp_hash->digest = mymalloc (dgst_size);
10629
10630 if (isSalted)
10631 {
10632 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10633 }
10634
10635 if (esalt_size)
10636 {
10637 tmp_hash->esalt = mymalloc (esalt_size);
10638 }
10639
10640 pot_hashes_avail++;
10641 }
10642 }
10643
10644 int plain_len = 0;
10645
10646 int parser_status;
10647
10648 int iter = MAX_CUT_TRIES;
10649
10650 do
10651 {
10652 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10653 {
10654 if (line_buf[i] == ':')
10655 {
10656 line_len--;
10657
10658 break;
10659 }
10660 }
10661
10662 if (data.hash_mode != 2500)
10663 {
10664 parser_status = parse_func (line_buf, line_len, hashes_buf);
10665 }
10666 else
10667 {
10668 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10669
10670 if (line_len > max_salt_size)
10671 {
10672 parser_status = PARSER_GLOBAL_LENGTH;
10673 }
10674 else
10675 {
10676 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10677
10678 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10679
10680 hashes_buf->salt->salt_len = line_len;
10681
10682 parser_status = PARSER_OK;
10683 }
10684 }
10685
10686 // if NOT parsed without error, we add the ":" to the plain
10687
10688 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10689 {
10690 plain_len++;
10691 plain_buf--;
10692 }
10693
10694 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10695
10696 if (parser_status < PARSER_GLOBAL_ZERO)
10697 {
10698 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10699
10700 continue;
10701 }
10702
10703 if (plain_len >= 255) continue;
10704
10705 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10706
10707 pot_ptr->plain_len = plain_len;
10708
10709 pot_cnt++;
10710 }
10711
10712 myfree (line_buf);
10713
10714 fclose (pot_fp);
10715
10716 SUPPRESS_OUTPUT = 0;
10717
10718 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10719 }
10720
10721 /**
10722 * word len
10723 */
10724
10725 uint pw_min = PW_MIN;
10726 uint pw_max = PW_MAX;
10727
10728 switch (hash_mode)
10729 {
10730 case 125: if (pw_max > 32) pw_max = 32;
10731 break;
10732 case 400: if (pw_max > 40) pw_max = 40;
10733 break;
10734 case 500: if (pw_max > 16) pw_max = 16;
10735 break;
10736 case 1500: if (pw_max > 8) pw_max = 8;
10737 break;
10738 case 1600: if (pw_max > 16) pw_max = 16;
10739 break;
10740 case 1800: if (pw_max > 16) pw_max = 16;
10741 break;
10742 case 2100: if (pw_max > 16) pw_max = 16;
10743 break;
10744 case 2500: if (pw_min < 8) pw_min = 8;
10745 break;
10746 case 3000: if (pw_max > 7) pw_max = 7;
10747 break;
10748 case 5200: if (pw_max > 24) pw_max = 24;
10749 break;
10750 case 5800: if (pw_max > 16) pw_max = 16;
10751 break;
10752 case 6300: if (pw_max > 16) pw_max = 16;
10753 break;
10754 case 7400: if (pw_max > 16) pw_max = 16;
10755 break;
10756 case 7900: if (pw_max > 48) pw_max = 48;
10757 break;
10758 case 8500: if (pw_max > 8) pw_max = 8;
10759 break;
10760 case 8600: if (pw_max > 16) pw_max = 16;
10761 break;
10762 case 9710: pw_min = 5;
10763 pw_max = 5;
10764 break;
10765 case 9810: pw_min = 5;
10766 pw_max = 5;
10767 break;
10768 case 10410: pw_min = 5;
10769 pw_max = 5;
10770 break;
10771 case 10300: if (pw_max < 3) pw_min = 3;
10772 if (pw_max > 40) pw_max = 40;
10773 break;
10774 case 10500: if (pw_max < 3) pw_min = 3;
10775 if (pw_max > 40) pw_max = 40;
10776 break;
10777 case 10700: if (pw_max > 16) pw_max = 16;
10778 break;
10779 case 11300: if (pw_max > 40) pw_max = 40;
10780 break;
10781 case 12500: if (pw_max > 20) pw_max = 20;
10782 break;
10783 case 12800: if (pw_max > 24) pw_max = 24;
10784 break;
10785 }
10786
10787 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10788 {
10789 switch (attack_kern)
10790 {
10791 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10792 break;
10793 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10794 break;
10795 }
10796 }
10797
10798 /**
10799 * charsets : keep them together for more easy maintainnce
10800 */
10801
10802 cs_t mp_sys[6] = { { { 0 }, 0 } };
10803 cs_t mp_usr[4] = { { { 0 }, 0 } };
10804
10805 mp_setup_sys (mp_sys);
10806
10807 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10808 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10809 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10810 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10811
10812 /**
10813 * load hashes, part I: find input mode, count hashes
10814 */
10815
10816 uint hashlist_mode = 0;
10817 uint hashlist_format = HLFMT_HASHCAT;
10818
10819 uint hashes_avail = 0;
10820
10821 if (benchmark == 0)
10822 {
10823 struct stat f;
10824
10825 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10826
10827 if ((hash_mode == 2500) ||
10828 (hash_mode == 5200) ||
10829 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10830 (hash_mode == 9000))
10831 {
10832 hashlist_mode = HL_MODE_ARG;
10833
10834 char *hashfile = myargv[optind];
10835
10836 data.hashfile = hashfile;
10837
10838 logfile_top_var_string ("target", hashfile);
10839 }
10840
10841 if (hashlist_mode == HL_MODE_ARG)
10842 {
10843 if (hash_mode == 2500)
10844 {
10845 struct stat st;
10846
10847 if (stat (data.hashfile, &st) == -1)
10848 {
10849 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10850
10851 return (-1);
10852 }
10853
10854 hashes_avail = st.st_size / sizeof (hccap_t);
10855 }
10856 else
10857 {
10858 hashes_avail = 1;
10859 }
10860 }
10861 else if (hashlist_mode == HL_MODE_FILE)
10862 {
10863 char *hashfile = myargv[optind];
10864
10865 data.hashfile = hashfile;
10866
10867 logfile_top_var_string ("target", hashfile);
10868
10869 FILE *fp = NULL;
10870
10871 if ((fp = fopen (hashfile, "rb")) == NULL)
10872 {
10873 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10874
10875 return (-1);
10876 }
10877
10878 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10879
10880 hashes_avail = count_lines (fp);
10881
10882 rewind (fp);
10883
10884 if (hashes_avail == 0)
10885 {
10886 log_error ("ERROR: hashfile is empty or corrupt");
10887
10888 fclose (fp);
10889
10890 return (-1);
10891 }
10892
10893 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10894
10895 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10896 {
10897 log_error ("ERROR: remove not supported in native hashfile-format mode");
10898
10899 fclose (fp);
10900
10901 return (-1);
10902 }
10903
10904 fclose (fp);
10905 }
10906 }
10907 else
10908 {
10909 hashlist_mode = HL_MODE_ARG;
10910
10911 hashes_avail = 1;
10912 }
10913
10914 if (hash_mode == 3000) hashes_avail *= 2;
10915
10916 data.hashlist_mode = hashlist_mode;
10917 data.hashlist_format = hashlist_format;
10918
10919 logfile_top_uint (hashlist_mode);
10920 logfile_top_uint (hashlist_format);
10921
10922 /**
10923 * load hashes, part II: allocate required memory, set pointers
10924 */
10925
10926 hash_t *hashes_buf = NULL;
10927 void *digests_buf = NULL;
10928 salt_t *salts_buf = NULL;
10929 void *esalts_buf = NULL;
10930
10931 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10932
10933 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10934
10935 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10936 {
10937 u32 hash_pos;
10938
10939 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10940 {
10941 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10942
10943 hashes_buf[hash_pos].hash_info = hash_info;
10944
10945 if (username && (remove || show || left))
10946 {
10947 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10948 }
10949
10950 if (benchmark)
10951 {
10952 hash_info->orighash = (char *) mymalloc (256);
10953 }
10954 }
10955 }
10956
10957 if (isSalted)
10958 {
10959 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10960
10961 if (esalt_size)
10962 {
10963 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10964 }
10965 }
10966 else
10967 {
10968 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10969 }
10970
10971 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10972 {
10973 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10974
10975 if (isSalted)
10976 {
10977 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10978
10979 if (esalt_size)
10980 {
10981 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10982 }
10983 }
10984 else
10985 {
10986 hashes_buf[hash_pos].salt = &salts_buf[0];
10987 }
10988 }
10989
10990 /**
10991 * load hashes, part III: parse hashes or generate them if benchmark
10992 */
10993
10994 uint hashes_cnt = 0;
10995
10996 if (benchmark == 0)
10997 {
10998 if (keyspace == 1)
10999 {
11000 // useless to read hash file for keyspace, cheat a little bit w/ optind
11001 }
11002 else if (hashes_avail == 0)
11003 {
11004 }
11005 else if (hashlist_mode == HL_MODE_ARG)
11006 {
11007 char *input_buf = myargv[optind];
11008
11009 uint input_len = strlen (input_buf);
11010
11011 logfile_top_var_string ("target", input_buf);
11012
11013 char *hash_buf = NULL;
11014 int hash_len = 0;
11015
11016 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11017
11018 bool hash_fmt_error = 0;
11019
11020 if (hash_len < 1) hash_fmt_error = 1;
11021 if (hash_buf == NULL) hash_fmt_error = 1;
11022
11023 if (hash_fmt_error)
11024 {
11025 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11026 }
11027 else
11028 {
11029 if (opts_type & OPTS_TYPE_HASH_COPY)
11030 {
11031 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11032
11033 hash_info_tmp->orighash = mystrdup (hash_buf);
11034 }
11035
11036 if (isSalted)
11037 {
11038 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11039 }
11040
11041 int parser_status = PARSER_OK;
11042
11043 if (hash_mode == 2500)
11044 {
11045 if (hash_len == 0)
11046 {
11047 log_error ("ERROR: hccap file not specified");
11048
11049 return (-1);
11050 }
11051
11052 hashlist_mode = HL_MODE_FILE;
11053
11054 data.hashlist_mode = hashlist_mode;
11055
11056 FILE *fp = fopen (hash_buf, "rb");
11057
11058 if (fp == NULL)
11059 {
11060 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11061
11062 return (-1);
11063 }
11064
11065 if (hashes_avail < 1)
11066 {
11067 log_error ("ERROR: hccap file is empty or corrupt");
11068
11069 fclose (fp);
11070
11071 return (-1);
11072 }
11073
11074 uint hccap_size = sizeof (hccap_t);
11075
11076 char *in = (char *) mymalloc (hccap_size);
11077
11078 while (!feof (fp))
11079 {
11080 int n = fread (in, hccap_size, 1, fp);
11081
11082 if (n != 1)
11083 {
11084 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11085
11086 break;
11087 }
11088
11089 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11090
11091 if (parser_status != PARSER_OK)
11092 {
11093 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11094
11095 continue;
11096 }
11097
11098 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11099
11100 if ((show == 1) || (left == 1))
11101 {
11102 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11103
11104 char *salt_ptr = (char *) tmp_salt->salt_buf;
11105
11106 int cur_pos = tmp_salt->salt_len;
11107 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11108
11109 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11110
11111 // do the appending task
11112
11113 snprintf (salt_ptr + cur_pos,
11114 rem_len,
11115 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11116 wpa->orig_mac1[0],
11117 wpa->orig_mac1[1],
11118 wpa->orig_mac1[2],
11119 wpa->orig_mac1[3],
11120 wpa->orig_mac1[4],
11121 wpa->orig_mac1[5],
11122 wpa->orig_mac2[0],
11123 wpa->orig_mac2[1],
11124 wpa->orig_mac2[2],
11125 wpa->orig_mac2[3],
11126 wpa->orig_mac2[4],
11127 wpa->orig_mac2[5]);
11128
11129 // memset () the remaining part of the salt
11130
11131 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11132 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11133
11134 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11135
11136 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11137 }
11138
11139 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);
11140 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);
11141
11142 hashes_cnt++;
11143 }
11144
11145 fclose (fp);
11146
11147 myfree (in);
11148 }
11149 else if (hash_mode == 3000)
11150 {
11151 if (hash_len == 32)
11152 {
11153 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11154
11155 hash_t *lm_hash_left = NULL;
11156
11157 if (parser_status == PARSER_OK)
11158 {
11159 lm_hash_left = &hashes_buf[hashes_cnt];
11160
11161 hashes_cnt++;
11162 }
11163 else
11164 {
11165 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11166 }
11167
11168 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11169
11170 hash_t *lm_hash_right = NULL;
11171
11172 if (parser_status == PARSER_OK)
11173 {
11174 lm_hash_right = &hashes_buf[hashes_cnt];
11175
11176 hashes_cnt++;
11177 }
11178 else
11179 {
11180 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11181 }
11182
11183 // show / left
11184
11185 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11186 {
11187 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);
11188 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);
11189 }
11190 }
11191 else
11192 {
11193 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11194
11195 if (parser_status == PARSER_OK)
11196 {
11197 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11198 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11199 }
11200
11201 if (parser_status == PARSER_OK)
11202 {
11203 hashes_cnt++;
11204 }
11205 else
11206 {
11207 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11208 }
11209 }
11210 }
11211 else
11212 {
11213 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11214
11215 if (parser_status == PARSER_OK)
11216 {
11217 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11218 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11219 }
11220
11221 if (parser_status == PARSER_OK)
11222 {
11223 hashes_cnt++;
11224 }
11225 else
11226 {
11227 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11228 }
11229 }
11230 }
11231 }
11232 else if (hashlist_mode == HL_MODE_FILE)
11233 {
11234 char *hashfile = data.hashfile;
11235
11236 FILE *fp;
11237
11238 if ((fp = fopen (hashfile, "rb")) == NULL)
11239 {
11240 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11241
11242 return (-1);
11243 }
11244
11245 uint line_num = 0;
11246
11247 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11248
11249 while (!feof (fp))
11250 {
11251 line_num++;
11252
11253 int line_len = fgetl (fp, line_buf);
11254
11255 if (line_len == 0) continue;
11256
11257 char *hash_buf = NULL;
11258 int hash_len = 0;
11259
11260 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11261
11262 bool hash_fmt_error = 0;
11263
11264 if (hash_len < 1) hash_fmt_error = 1;
11265 if (hash_buf == NULL) hash_fmt_error = 1;
11266
11267 if (hash_fmt_error)
11268 {
11269 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11270
11271 continue;
11272 }
11273
11274 if (username)
11275 {
11276 char *user_buf = NULL;
11277 int user_len = 0;
11278
11279 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11280
11281 if (remove || show)
11282 {
11283 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11284
11285 *user = (user_t *) mymalloc (sizeof (user_t));
11286
11287 user_t *user_ptr = *user;
11288
11289 if (user_buf != NULL)
11290 {
11291 user_ptr->user_name = mystrdup (user_buf);
11292 }
11293 else
11294 {
11295 user_ptr->user_name = mystrdup ("");
11296 }
11297
11298 user_ptr->user_len = user_len;
11299 }
11300 }
11301
11302 if (opts_type & OPTS_TYPE_HASH_COPY)
11303 {
11304 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11305
11306 hash_info_tmp->orighash = mystrdup (hash_buf);
11307 }
11308
11309 if (isSalted)
11310 {
11311 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11312 }
11313
11314 if (hash_mode == 3000)
11315 {
11316 if (hash_len == 32)
11317 {
11318 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11319
11320 if (parser_status < PARSER_GLOBAL_ZERO)
11321 {
11322 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11323
11324 continue;
11325 }
11326
11327 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11328
11329 hashes_cnt++;
11330
11331 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11332
11333 if (parser_status < PARSER_GLOBAL_ZERO)
11334 {
11335 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11336
11337 continue;
11338 }
11339
11340 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11341
11342 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);
11343
11344 hashes_cnt++;
11345
11346 // show / left
11347
11348 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);
11349 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);
11350 }
11351 else
11352 {
11353 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11354
11355 if (parser_status < PARSER_GLOBAL_ZERO)
11356 {
11357 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11358
11359 continue;
11360 }
11361
11362 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);
11363
11364 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11365 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11366
11367 hashes_cnt++;
11368 }
11369 }
11370 else
11371 {
11372 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11373
11374 if (parser_status < PARSER_GLOBAL_ZERO)
11375 {
11376 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11377
11378 continue;
11379 }
11380
11381 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);
11382
11383 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11384 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11385
11386 hashes_cnt++;
11387 }
11388 }
11389
11390 myfree (line_buf);
11391
11392 fclose (fp);
11393
11394 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11395
11396 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11397 }
11398 }
11399 else
11400 {
11401 if (isSalted)
11402 {
11403 hashes_buf[0].salt->salt_len = 8;
11404
11405 // special salt handling
11406
11407 switch (hash_mode)
11408 {
11409 case 1500: hashes_buf[0].salt->salt_len = 2;
11410 break;
11411 case 1731: hashes_buf[0].salt->salt_len = 4;
11412 break;
11413 case 2410: hashes_buf[0].salt->salt_len = 4;
11414 break;
11415 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11416 break;
11417 case 3100: hashes_buf[0].salt->salt_len = 1;
11418 break;
11419 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11420 break;
11421 case 5800: hashes_buf[0].salt->salt_len = 16;
11422 break;
11423 case 6800: hashes_buf[0].salt->salt_len = 32;
11424 break;
11425 case 8400: hashes_buf[0].salt->salt_len = 40;
11426 break;
11427 case 8800: hashes_buf[0].salt->salt_len = 16;
11428 break;
11429 case 8900: hashes_buf[0].salt->salt_len = 16;
11430 hashes_buf[0].salt->scrypt_N = 1024;
11431 hashes_buf[0].salt->scrypt_r = 1;
11432 hashes_buf[0].salt->scrypt_p = 1;
11433 break;
11434 case 9100: hashes_buf[0].salt->salt_len = 16;
11435 break;
11436 case 9300: hashes_buf[0].salt->salt_len = 14;
11437 hashes_buf[0].salt->scrypt_N = 16384;
11438 hashes_buf[0].salt->scrypt_r = 1;
11439 hashes_buf[0].salt->scrypt_p = 1;
11440 break;
11441 case 9400: hashes_buf[0].salt->salt_len = 16;
11442 break;
11443 case 9500: hashes_buf[0].salt->salt_len = 16;
11444 break;
11445 case 9600: hashes_buf[0].salt->salt_len = 16;
11446 break;
11447 case 9700: hashes_buf[0].salt->salt_len = 16;
11448 break;
11449 case 9710: hashes_buf[0].salt->salt_len = 16;
11450 break;
11451 case 9720: hashes_buf[0].salt->salt_len = 16;
11452 break;
11453 case 9800: hashes_buf[0].salt->salt_len = 16;
11454 break;
11455 case 9810: hashes_buf[0].salt->salt_len = 16;
11456 break;
11457 case 9820: hashes_buf[0].salt->salt_len = 16;
11458 break;
11459 case 10300: hashes_buf[0].salt->salt_len = 12;
11460 break;
11461 case 11500: hashes_buf[0].salt->salt_len = 4;
11462 break;
11463 case 11600: hashes_buf[0].salt->salt_len = 4;
11464 break;
11465 case 12400: hashes_buf[0].salt->salt_len = 4;
11466 break;
11467 case 12500: hashes_buf[0].salt->salt_len = 8;
11468 break;
11469 case 12600: hashes_buf[0].salt->salt_len = 64;
11470 break;
11471 }
11472
11473 // special esalt handling
11474
11475 switch (hash_mode)
11476 {
11477 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11478 break;
11479 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11480 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11481 break;
11482 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11483 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11484 break;
11485 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11486 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11487 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11488 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11489 break;
11490 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11491 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11492 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11493 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11494 break;
11495 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11496 break;
11497 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11498 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11499 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11500 break;
11501 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11502 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11503 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11504 break;
11505 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11506 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11507 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11508 break;
11509 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11510 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11511 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11512 break;
11513 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11514 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11515 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11516 break;
11517 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11518 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11519 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11520 break;
11521 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11522 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11523 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11524 break;
11525 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11526 break;
11527 }
11528 }
11529
11530 // set hashfile
11531
11532 switch (hash_mode)
11533 {
11534 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11535 break;
11536 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11537 break;
11538 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11539 break;
11540 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11541 break;
11542 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11543 break;
11544 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11545 break;
11546 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11547 break;
11548 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11549 break;
11550 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11551 break;
11552 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11553 break;
11554 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11555 break;
11556 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11557 break;
11558 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11559 break;
11560 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11561 break;
11562 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11563 break;
11564 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11565 break;
11566 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11567 break;
11568 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11569 break;
11570 }
11571
11572 // set default iterations
11573
11574 switch (hash_mode)
11575 {
11576 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11577 break;
11578 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11579 break;
11580 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11581 break;
11582 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11583 break;
11584 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11585 break;
11586 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11587 break;
11588 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11589 break;
11590 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11591 break;
11592 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11593 break;
11594 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11595 break;
11596 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11597 break;
11598 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11599 break;
11600 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11601 break;
11602 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11603 break;
11604 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11605 break;
11606 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11607 break;
11608 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11609 break;
11610 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11611 break;
11612 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11613 break;
11614 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11615 break;
11616 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11617 break;
11618 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11619 break;
11620 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11621 break;
11622 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11623 break;
11624 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11625 break;
11626 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11627 break;
11628 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11629 break;
11630 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11631 break;
11632 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11633 break;
11634 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11635 break;
11636 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11637 break;
11638 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11639 break;
11640 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11641 break;
11642 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11643 break;
11644 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11645 break;
11646 case 8900: hashes_buf[0].salt->salt_iter = 1;
11647 break;
11648 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11649 break;
11650 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11651 break;
11652 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11653 break;
11654 case 9300: hashes_buf[0].salt->salt_iter = 1;
11655 break;
11656 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11657 break;
11658 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11659 break;
11660 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11661 break;
11662 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11663 break;
11664 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11665 break;
11666 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11667 break;
11668 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11669 break;
11670 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11671 break;
11672 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11673 break;
11674 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11675 break;
11676 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11677 break;
11678 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11679 break;
11680 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11681 break;
11682 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11683 break;
11684 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11685 break;
11686 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11687 break;
11688 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11689 break;
11690 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11691 break;
11692 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11693 break;
11694 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11695 break;
11696 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11697 break;
11698 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
11699 break;
11700 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
11701 break;
11702 }
11703
11704 hashes_cnt = 1;
11705 }
11706
11707 if (show == 1 || left == 1)
11708 {
11709 for (uint i = 0; i < pot_cnt; i++)
11710 {
11711 pot_t *pot_ptr = &pot[i];
11712
11713 hash_t *hashes_buf = &pot_ptr->hash;
11714
11715 local_free (hashes_buf->digest);
11716
11717 if (isSalted)
11718 {
11719 local_free (hashes_buf->salt);
11720 }
11721 }
11722
11723 local_free (pot);
11724
11725 if (data.quiet == 0) log_info_nn ("");
11726
11727 return (0);
11728 }
11729
11730 if (keyspace == 0)
11731 {
11732 if (hashes_cnt == 0)
11733 {
11734 log_error ("ERROR: No hashes loaded");
11735
11736 return (-1);
11737 }
11738 }
11739
11740 /**
11741 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11742 */
11743
11744 if (data.outfile != NULL)
11745 {
11746 if (data.hashfile != NULL)
11747 {
11748 #ifdef _POSIX
11749 struct stat tmpstat_outfile;
11750 struct stat tmpstat_hashfile;
11751 #endif
11752
11753 #ifdef _WIN
11754 struct stat64 tmpstat_outfile;
11755 struct stat64 tmpstat_hashfile;
11756 #endif
11757
11758 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11759
11760 if (tmp_outfile_fp)
11761 {
11762 #ifdef _POSIX
11763 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11764 #endif
11765
11766 #ifdef _WIN
11767 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11768 #endif
11769
11770 fclose (tmp_outfile_fp);
11771 }
11772
11773 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11774
11775 if (tmp_hashfile_fp)
11776 {
11777 #ifdef _POSIX
11778 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11779 #endif
11780
11781 #ifdef _WIN
11782 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11783 #endif
11784
11785 fclose (tmp_hashfile_fp);
11786 }
11787
11788 if (tmp_outfile_fp && tmp_outfile_fp)
11789 {
11790 tmpstat_outfile.st_mode = 0;
11791 tmpstat_outfile.st_nlink = 0;
11792 tmpstat_outfile.st_uid = 0;
11793 tmpstat_outfile.st_gid = 0;
11794 tmpstat_outfile.st_rdev = 0;
11795 tmpstat_outfile.st_atime = 0;
11796
11797 tmpstat_hashfile.st_mode = 0;
11798 tmpstat_hashfile.st_nlink = 0;
11799 tmpstat_hashfile.st_uid = 0;
11800 tmpstat_hashfile.st_gid = 0;
11801 tmpstat_hashfile.st_rdev = 0;
11802 tmpstat_hashfile.st_atime = 0;
11803
11804 #ifdef _POSIX
11805 tmpstat_outfile.st_blksize = 0;
11806 tmpstat_outfile.st_blocks = 0;
11807
11808 tmpstat_hashfile.st_blksize = 0;
11809 tmpstat_hashfile.st_blocks = 0;
11810 #endif
11811
11812 #ifdef _POSIX
11813 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11814 {
11815 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11816
11817 return (-1);
11818 }
11819 #endif
11820
11821 #ifdef _WIN
11822 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11823 {
11824 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11825
11826 return (-1);
11827 }
11828 #endif
11829 }
11830 }
11831 }
11832
11833 /**
11834 * Remove duplicates
11835 */
11836
11837 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11838
11839 if (isSalted)
11840 {
11841 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11842 }
11843 else
11844 {
11845 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11846 }
11847
11848 uint hashes_cnt_orig = hashes_cnt;
11849
11850 hashes_cnt = 1;
11851
11852 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11853 {
11854 if (isSalted)
11855 {
11856 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11857 {
11858 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11859 }
11860 }
11861 else
11862 {
11863 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11864 }
11865
11866 if (hashes_pos > hashes_cnt)
11867 {
11868 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11869 }
11870
11871 hashes_cnt++;
11872 }
11873
11874 /**
11875 * Potfile removes
11876 */
11877
11878 uint potfile_remove_cracks = 0;
11879
11880 if (potfile_disable == 0)
11881 {
11882 hash_t hash_buf;
11883
11884 hash_buf.digest = mymalloc (dgst_size);
11885 hash_buf.salt = NULL;
11886 hash_buf.esalt = NULL;
11887 hash_buf.hash_info = NULL;
11888 hash_buf.cracked = 0;
11889
11890 if (isSalted)
11891 {
11892 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11893 }
11894
11895 if (esalt_size)
11896 {
11897 hash_buf.esalt = mymalloc (esalt_size);
11898 }
11899
11900 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11901
11902 // no solution for these special hash types (for instane because they use hashfile in output etc)
11903 if ((hash_mode != 5200) &&
11904 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11905 (hash_mode != 9000))
11906 {
11907 FILE *fp = fopen (potfile, "rb");
11908
11909 if (fp != NULL)
11910 {
11911 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11912
11913 // to be safe work with a copy (because of line_len loop, i etc)
11914 // moved up here because it's easier to handle continue case
11915 // it's just 64kb
11916
11917 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
11918
11919 while (!feof (fp))
11920 {
11921 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
11922
11923 if (ptr == NULL) break;
11924
11925 int line_len = strlen (line_buf);
11926
11927 if (line_len == 0) continue;
11928
11929 int iter = MAX_CUT_TRIES;
11930
11931 for (int i = line_len - 1; i && iter; i--, line_len--)
11932 {
11933 if (line_buf[i] != ':') continue;
11934
11935 if (isSalted)
11936 {
11937 memset (hash_buf.salt, 0, sizeof (salt_t));
11938 }
11939
11940 hash_t *found = NULL;
11941
11942 if (hash_mode == 6800)
11943 {
11944 if (i < 64) // 64 = 16 * uint in salt_buf[]
11945 {
11946 // manipulate salt_buf
11947 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11948
11949 hash_buf.salt->salt_len = i;
11950
11951 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11952 }
11953 }
11954 else if (hash_mode == 2500)
11955 {
11956 if (i < 64) // 64 = 16 * uint in salt_buf[]
11957 {
11958 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11959 // manipulate salt_buf
11960
11961 memcpy (line_buf_cpy, line_buf, i);
11962
11963 char *mac2_pos = strrchr (line_buf_cpy, ':');
11964
11965 if (mac2_pos == NULL) continue;
11966
11967 mac2_pos[0] = 0;
11968 mac2_pos++;
11969
11970 if (strlen (mac2_pos) != 12) continue;
11971
11972 char *mac1_pos = strrchr (line_buf_cpy, ':');
11973
11974 if (mac1_pos == NULL) continue;
11975
11976 mac1_pos[0] = 0;
11977 mac1_pos++;
11978
11979 if (strlen (mac1_pos) != 12) continue;
11980
11981 uint essid_length = mac1_pos - line_buf_cpy - 1;
11982
11983 // here we need the ESSID
11984 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11985
11986 hash_buf.salt->salt_len = essid_length;
11987
11988 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11989
11990 if (found)
11991 {
11992 wpa_t *wpa = (wpa_t *) found->esalt;
11993
11994 // compare hex string(s) vs binary MAC address(es)
11995
11996 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11997 {
11998 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11999 {
12000 found = NULL;
12001
12002 break;
12003 }
12004 }
12005
12006 // early skip ;)
12007 if (!found) continue;
12008
12009 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12010 {
12011 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12012 {
12013 found = NULL;
12014
12015 break;
12016 }
12017 }
12018 }
12019 }
12020 }
12021 else
12022 {
12023 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12024
12025 if (parser_status == PARSER_OK)
12026 {
12027 if (isSalted)
12028 {
12029 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12030 }
12031 else
12032 {
12033 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12034 }
12035 }
12036 }
12037
12038 if (found == NULL) continue;
12039
12040 if (!found->cracked) potfile_remove_cracks++;
12041
12042 found->cracked = 1;
12043
12044 if (found) break;
12045
12046 iter--;
12047 }
12048 }
12049
12050 myfree (line_buf_cpy);
12051
12052 myfree (line_buf);
12053
12054 fclose (fp);
12055 }
12056 }
12057
12058 if (esalt_size)
12059 {
12060 local_free (hash_buf.esalt);
12061 }
12062
12063 if (isSalted)
12064 {
12065 local_free (hash_buf.salt);
12066 }
12067
12068 local_free (hash_buf.digest);
12069 }
12070
12071 /**
12072 * Now generate all the buffers required for later
12073 */
12074
12075 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12076
12077 salt_t *salts_buf_new = NULL;
12078 void *esalts_buf_new = NULL;
12079
12080 if (isSalted)
12081 {
12082 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12083
12084 if (esalt_size)
12085 {
12086 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12087 }
12088 }
12089 else
12090 {
12091 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12092 }
12093
12094 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12095
12096 uint digests_cnt = hashes_cnt;
12097 uint digests_done = 0;
12098
12099 uint size_digests = digests_cnt * dgst_size;
12100 uint size_shown = digests_cnt * sizeof (uint);
12101
12102 uint *digests_shown = (uint *) mymalloc (size_shown);
12103 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12104
12105 uint salts_cnt = 0;
12106 uint salts_done = 0;
12107
12108 hashinfo_t **hash_info = NULL;
12109
12110 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12111 {
12112 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12113
12114 if (username && (remove || show))
12115 {
12116 uint user_pos;
12117
12118 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12119 {
12120 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12121
12122 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12123 }
12124 }
12125 }
12126
12127 uint *salts_shown = (uint *) mymalloc (size_shown);
12128
12129 salt_t *salt_buf;
12130
12131 {
12132 // copied from inner loop
12133
12134 salt_buf = &salts_buf_new[salts_cnt];
12135
12136 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12137
12138 if (esalt_size)
12139 {
12140 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12141 }
12142
12143 salt_buf->digests_cnt = 0;
12144 salt_buf->digests_done = 0;
12145 salt_buf->digests_offset = 0;
12146
12147 salts_cnt++;
12148 }
12149
12150 if (hashes_buf[0].cracked == 1)
12151 {
12152 digests_shown[0] = 1;
12153
12154 digests_done++;
12155
12156 salt_buf->digests_done++;
12157 }
12158
12159 salt_buf->digests_cnt++;
12160
12161 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12162
12163 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12164 {
12165 hash_info[0] = hashes_buf[0].hash_info;
12166 }
12167
12168 // copy from inner loop
12169
12170 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12171 {
12172 if (isSalted)
12173 {
12174 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12175 {
12176 salt_buf = &salts_buf_new[salts_cnt];
12177
12178 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12179
12180 if (esalt_size)
12181 {
12182 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12183 }
12184
12185 salt_buf->digests_cnt = 0;
12186 salt_buf->digests_done = 0;
12187 salt_buf->digests_offset = hashes_pos;
12188
12189 salts_cnt++;
12190 }
12191 }
12192
12193 if (hashes_buf[hashes_pos].cracked == 1)
12194 {
12195 digests_shown[hashes_pos] = 1;
12196
12197 digests_done++;
12198
12199 salt_buf->digests_done++;
12200 }
12201
12202 salt_buf->digests_cnt++;
12203
12204 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12205
12206 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12207 {
12208 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12209 }
12210 }
12211
12212 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12213 {
12214 salt_t *salt_buf = &salts_buf_new[salt_pos];
12215
12216 if (salt_buf->digests_done == salt_buf->digests_cnt)
12217 {
12218 salts_shown[salt_pos] = 1;
12219
12220 salts_done++;
12221 }
12222
12223 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12224 }
12225
12226 local_free (digests_buf);
12227 local_free (salts_buf);
12228 local_free (esalts_buf);
12229
12230 digests_buf = digests_buf_new;
12231 salts_buf = salts_buf_new;
12232 esalts_buf = esalts_buf_new;
12233
12234 local_free (hashes_buf);
12235
12236 /**
12237 * special modification not set from parser
12238 */
12239
12240 switch (hash_mode)
12241 {
12242 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12243 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12244 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12245 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12246 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12247 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12248 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12249 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12250 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12251 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12252 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12253 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12254 }
12255
12256 if (truecrypt_keyfiles)
12257 {
12258 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12259
12260 char *keyfiles = strdup (truecrypt_keyfiles);
12261
12262 char *keyfile = strtok (keyfiles, ",");
12263
12264 do
12265 {
12266 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12267
12268 } while ((keyfile = strtok (NULL, ",")) != NULL);
12269
12270 free (keyfiles);
12271 }
12272
12273 data.digests_cnt = digests_cnt;
12274 data.digests_done = digests_done;
12275 data.digests_buf = digests_buf;
12276 data.digests_shown = digests_shown;
12277 data.digests_shown_tmp = digests_shown_tmp;
12278
12279 data.salts_cnt = salts_cnt;
12280 data.salts_done = salts_done;
12281 data.salts_buf = salts_buf;
12282 data.salts_shown = salts_shown;
12283
12284 data.esalts_buf = esalts_buf;
12285 data.hash_info = hash_info;
12286
12287 /**
12288 * Automatic Optimizers
12289 */
12290
12291 if (salts_cnt == 1)
12292 opti_type |= OPTI_TYPE_SINGLE_SALT;
12293
12294 if (digests_cnt == 1)
12295 opti_type |= OPTI_TYPE_SINGLE_HASH;
12296
12297 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12298 opti_type |= OPTI_TYPE_NOT_ITERATED;
12299
12300 if (attack_mode == ATTACK_MODE_BF)
12301 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12302
12303 data.opti_type = opti_type;
12304
12305 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12306 {
12307 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12308 {
12309 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12310 {
12311 if (opts_type & OPTS_TYPE_ST_ADD80)
12312 {
12313 opts_type &= ~OPTS_TYPE_ST_ADD80;
12314 opts_type |= OPTS_TYPE_PT_ADD80;
12315 }
12316
12317 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12318 {
12319 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12320 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12321 }
12322
12323 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12324 {
12325 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12326 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12327 }
12328 }
12329 }
12330 }
12331
12332 /**
12333 * Some algorithm, like descrypt, can benefit from JIT compilation
12334 */
12335
12336 int force_jit_compilation = -1;
12337
12338 if (hash_mode == 8900)
12339 {
12340 force_jit_compilation = 8900;
12341 }
12342 else if (hash_mode == 9300)
12343 {
12344 force_jit_compilation = 8900;
12345 }
12346 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12347 {
12348 force_jit_compilation = 1500;
12349 }
12350
12351 /**
12352 * generate bitmap tables
12353 */
12354
12355 const uint bitmap_shift1 = 5;
12356 const uint bitmap_shift2 = 13;
12357
12358 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12359
12360 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12361 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12362 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12363 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12364 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12365 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12366 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12367 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12368
12369 uint bitmap_bits;
12370 uint bitmap_nums;
12371 uint bitmap_mask;
12372 uint bitmap_size;
12373
12374 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12375 {
12376 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12377
12378 bitmap_nums = 1 << bitmap_bits;
12379
12380 bitmap_mask = bitmap_nums - 1;
12381
12382 bitmap_size = bitmap_nums * sizeof (uint);
12383
12384 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12385
12386 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;
12387 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;
12388
12389 break;
12390 }
12391
12392 bitmap_nums = 1 << bitmap_bits;
12393
12394 bitmap_mask = bitmap_nums - 1;
12395
12396 bitmap_size = bitmap_nums * sizeof (uint);
12397
12398 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);
12399 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);
12400
12401 /**
12402 * prepare quick rule
12403 */
12404
12405 data.rule_buf_l = rule_buf_l;
12406 data.rule_buf_r = rule_buf_r;
12407
12408 int rule_len_l = (int) strlen (rule_buf_l);
12409 int rule_len_r = (int) strlen (rule_buf_r);
12410
12411 data.rule_len_l = rule_len_l;
12412 data.rule_len_r = rule_len_r;
12413
12414 /**
12415 * load rules
12416 */
12417
12418 uint *all_kernel_rules_cnt = NULL;
12419
12420 kernel_rule_t **all_kernel_rules_buf = NULL;
12421
12422 if (rp_files_cnt)
12423 {
12424 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12425
12426 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12427 }
12428
12429 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12430
12431 int rule_len = 0;
12432
12433 for (uint i = 0; i < rp_files_cnt; i++)
12434 {
12435 uint kernel_rules_avail = 0;
12436
12437 uint kernel_rules_cnt = 0;
12438
12439 kernel_rule_t *kernel_rules_buf = NULL;
12440
12441 char *rp_file = rp_files[i];
12442
12443 char in[BLOCK_SIZE] = { 0 };
12444 char out[BLOCK_SIZE] = { 0 };
12445
12446 FILE *fp = NULL;
12447
12448 uint rule_line = 0;
12449
12450 if ((fp = fopen (rp_file, "rb")) == NULL)
12451 {
12452 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12453
12454 return (-1);
12455 }
12456
12457 while (!feof (fp))
12458 {
12459 memset (rule_buf, 0, HCBUFSIZ);
12460
12461 rule_len = fgetl (fp, rule_buf);
12462
12463 rule_line++;
12464
12465 if (rule_len == 0) continue;
12466
12467 if (rule_buf[0] == '#') continue;
12468
12469 if (kernel_rules_avail == kernel_rules_cnt)
12470 {
12471 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12472
12473 kernel_rules_avail += INCR_RULES;
12474 }
12475
12476 memset (in, 0, BLOCK_SIZE);
12477 memset (out, 0, BLOCK_SIZE);
12478
12479 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12480
12481 if (result == -1)
12482 {
12483 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12484
12485 continue;
12486 }
12487
12488 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12489 {
12490 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12491
12492 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12493
12494 continue;
12495 }
12496
12497 /* its so slow
12498 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12499 {
12500 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12501
12502 continue;
12503 }
12504 */
12505
12506 kernel_rules_cnt++;
12507 }
12508
12509 fclose (fp);
12510
12511 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12512
12513 all_kernel_rules_buf[i] = kernel_rules_buf;
12514 }
12515
12516 /**
12517 * merge rules or automatic rule generator
12518 */
12519
12520 uint kernel_rules_cnt = 0;
12521
12522 kernel_rule_t *kernel_rules_buf = NULL;
12523
12524 if (attack_mode == ATTACK_MODE_STRAIGHT)
12525 {
12526 if (rp_files_cnt)
12527 {
12528 kernel_rules_cnt = 1;
12529
12530 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12531
12532 repeats[0] = kernel_rules_cnt;
12533
12534 for (uint i = 0; i < rp_files_cnt; i++)
12535 {
12536 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12537
12538 repeats[i + 1] = kernel_rules_cnt;
12539 }
12540
12541 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12542
12543 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12544
12545 for (uint i = 0; i < kernel_rules_cnt; i++)
12546 {
12547 uint out_pos = 0;
12548
12549 kernel_rule_t *out = &kernel_rules_buf[i];
12550
12551 for (uint j = 0; j < rp_files_cnt; j++)
12552 {
12553 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12554 uint in_pos;
12555
12556 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12557
12558 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12559 {
12560 if (out_pos == RULES_MAX - 1)
12561 {
12562 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12563
12564 break;
12565 }
12566
12567 out->cmds[out_pos] = in->cmds[in_pos];
12568 }
12569 }
12570 }
12571
12572 local_free (repeats);
12573 }
12574 else if (rp_gen)
12575 {
12576 uint kernel_rules_avail = 0;
12577
12578 while (kernel_rules_cnt < rp_gen)
12579 {
12580 if (kernel_rules_avail == kernel_rules_cnt)
12581 {
12582 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12583
12584 kernel_rules_avail += INCR_RULES;
12585 }
12586
12587 memset (rule_buf, 0, HCBUFSIZ);
12588
12589 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12590
12591 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12592
12593 kernel_rules_cnt++;
12594 }
12595 }
12596 }
12597
12598 myfree (rule_buf);
12599
12600 /**
12601 * generate NOP rules
12602 */
12603
12604 if (kernel_rules_cnt == 0)
12605 {
12606 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12607
12608 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12609
12610 kernel_rules_cnt++;
12611 }
12612
12613 data.kernel_rules_cnt = kernel_rules_cnt;
12614 data.kernel_rules_buf = kernel_rules_buf;
12615
12616 /**
12617 * OpenCL platforms: detect
12618 */
12619
12620 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12621 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12622
12623 cl_uint platforms_cnt = 0;
12624 cl_uint platform_devices_cnt = 0;
12625
12626 if (keyspace == 0)
12627 {
12628 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12629
12630 if (platforms_cnt == 0)
12631 {
12632 log_error ("ERROR: No OpenCL compatible platform found");
12633
12634 return (-1);
12635 }
12636
12637 if (opencl_platforms_filter != (uint) -1)
12638 {
12639 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
12640
12641 if (opencl_platforms_filter > platform_cnt_mask)
12642 {
12643 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
12644
12645 return (-1);
12646 }
12647 }
12648 }
12649
12650 /**
12651 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12652 */
12653
12654 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12655 {
12656 cl_platform_id platform = platforms[platform_id];
12657
12658 char platform_vendor[INFOSZ] = { 0 };
12659
12660 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12661
12662 #ifdef HAVE_HWMON
12663 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12664 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12665 {
12666 // make sure that we do not directly control the fan for NVidia
12667
12668 gpu_temp_retain = 0;
12669
12670 data.gpu_temp_retain = gpu_temp_retain;
12671 }
12672 #endif // HAVE_NVML || HAVE_NVAPI
12673 #endif
12674 }
12675
12676 /**
12677 * OpenCL devices: simply push all devices from all platforms into the same device array
12678 */
12679
12680 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12681
12682 data.devices_param = devices_param;
12683
12684 uint devices_cnt = 0;
12685
12686 uint devices_active = 0;
12687
12688 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12689 {
12690 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12691
12692 cl_platform_id platform = platforms[platform_id];
12693
12694 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12695
12696 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12697 {
12698 size_t param_value_size = 0;
12699
12700 const uint device_id = devices_cnt;
12701
12702 hc_device_param_t *device_param = &data.devices_param[device_id];
12703
12704 device_param->device = platform_devices[platform_devices_id];
12705
12706 device_param->device_id = device_id;
12707
12708 device_param->platform_devices_id = platform_devices_id;
12709
12710 // device_type
12711
12712 cl_device_type device_type;
12713
12714 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12715
12716 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12717
12718 device_param->device_type = device_type;
12719
12720 // vendor_id
12721
12722 cl_uint vendor_id = 0;
12723
12724 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12725
12726 device_param->vendor_id = vendor_id;
12727
12728 // device_name
12729
12730 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12731
12732 char *device_name = (char *) mymalloc (param_value_size);
12733
12734 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12735
12736 device_param->device_name = device_name;
12737
12738 // tuning db
12739
12740 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12741
12742 // device_version
12743
12744 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12745
12746 char *device_version = (char *) mymalloc (param_value_size);
12747
12748 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12749
12750 device_param->device_version = device_version;
12751
12752 // device_opencl_version
12753
12754 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12755
12756 char *device_opencl_version = (char *) mymalloc (param_value_size);
12757
12758 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12759
12760 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12761
12762 myfree (device_opencl_version);
12763
12764 if (strstr (device_version, "pocl"))
12765 {
12766 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12767 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12768
12769 cl_uint vendor_id = VENDOR_ID_GENERIC;
12770
12771 device_param->vendor_id = vendor_id;
12772 }
12773
12774 // vector_width
12775
12776 cl_uint vector_width;
12777
12778 if (opencl_vector_width_chgd == 0)
12779 {
12780 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12781 {
12782 if (opti_type & OPTI_TYPE_USES_BITS_64)
12783 {
12784 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12785 }
12786 else
12787 {
12788 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12789 }
12790 }
12791 else
12792 {
12793 vector_width = (cl_uint) tuningdb_entry->vector_width;
12794 }
12795 }
12796 else
12797 {
12798 vector_width = opencl_vector_width;
12799 }
12800
12801 if (vector_width > 16) vector_width = 16;
12802
12803 device_param->vector_width = vector_width;
12804
12805 // max_compute_units
12806
12807 cl_uint device_processors;
12808
12809 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12810
12811 device_param->device_processors = device_processors;
12812
12813 // max_mem_alloc_size
12814
12815 cl_ulong device_maxmem_alloc;
12816
12817 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12818
12819 device_param->device_maxmem_alloc = device_maxmem_alloc;
12820
12821 // max_mem_alloc_size
12822
12823 cl_ulong device_global_mem;
12824
12825 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12826
12827 device_param->device_global_mem = device_global_mem;
12828
12829 // max_clock_frequency
12830
12831 cl_uint device_maxclock_frequency;
12832
12833 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12834
12835 device_param->device_maxclock_frequency = device_maxclock_frequency;
12836
12837 // skipped
12838
12839 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12840 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12841
12842 device_param->skipped = (skipped1 || skipped2);
12843
12844 // driver_version
12845 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12846
12847 char *driver_version = (char *) mymalloc (param_value_size);
12848
12849 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12850
12851 device_param->driver_version = driver_version;
12852
12853 // device_name_chksum
12854
12855 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12856
12857 #if __x86_64__
12858 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);
12859 #else
12860 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);
12861 #endif
12862
12863 uint device_name_digest[4] = { 0 };
12864
12865 md5_64 ((uint *) device_name_chksum, device_name_digest);
12866
12867 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12868
12869 device_param->device_name_chksum = device_name_chksum;
12870
12871 // device_processor_cores
12872
12873 if (device_type & CL_DEVICE_TYPE_CPU)
12874 {
12875 cl_uint device_processor_cores = 1;
12876
12877 device_param->device_processor_cores = device_processor_cores;
12878 }
12879
12880 if (device_type & CL_DEVICE_TYPE_GPU)
12881 {
12882 if (vendor_id == VENDOR_ID_AMD)
12883 {
12884 cl_uint device_processor_cores = 0;
12885
12886 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12887
12888 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12889
12890 device_param->device_processor_cores = device_processor_cores;
12891 }
12892 else if (vendor_id == VENDOR_ID_NV)
12893 {
12894 cl_uint kernel_exec_timeout = 0;
12895
12896 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12897
12898 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12899
12900 device_param->kernel_exec_timeout = kernel_exec_timeout;
12901
12902 cl_uint device_processor_cores = 0;
12903
12904 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12905
12906 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12907
12908 device_param->device_processor_cores = device_processor_cores;
12909
12910 cl_uint sm_minor = 0;
12911 cl_uint sm_major = 0;
12912
12913 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12914 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12915
12916 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12917 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12918
12919 device_param->sm_minor = sm_minor;
12920 device_param->sm_major = sm_major;
12921 }
12922 else
12923 {
12924 cl_uint device_processor_cores = 1;
12925
12926 device_param->device_processor_cores = device_processor_cores;
12927 }
12928 }
12929
12930 // display results
12931
12932 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12933 {
12934 if (device_param->skipped == 0)
12935 {
12936 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12937 device_id + 1,
12938 device_name,
12939 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12940 (unsigned int) (device_global_mem / 1024 / 1024),
12941 (unsigned int) (device_maxclock_frequency),
12942 (unsigned int) device_processors);
12943 }
12944 else
12945 {
12946 log_info ("Device #%u: %s, skipped",
12947 device_id + 1,
12948 device_name);
12949 }
12950 }
12951
12952 // common driver check
12953
12954 if (device_param->skipped == 0)
12955 {
12956 if (strstr (device_version, "pocl"))
12957 {
12958 if (force == 0)
12959 {
12960 log_info ("");
12961 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12962 log_info ("You are STRONGLY encouraged not to use it");
12963 log_info ("You can use --force to override this but do not post error reports if you do so");
12964 log_info ("");
12965
12966 return (-1);
12967 }
12968 }
12969
12970 if (device_type & CL_DEVICE_TYPE_GPU)
12971 {
12972 if (vendor_id == VENDOR_ID_NV)
12973 {
12974 if (device_param->kernel_exec_timeout != 0)
12975 {
12976 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);
12977 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12978 }
12979 }
12980 else if (vendor_id == VENDOR_ID_AMD)
12981 {
12982 int catalyst_check = (force == 1) ? 0 : 1;
12983
12984 int catalyst_warn = 0;
12985
12986 int catalyst_broken = 0;
12987
12988 if (catalyst_check == 1)
12989 {
12990 catalyst_warn = 1;
12991
12992 // v14.9 and higher
12993 if (atoi (device_param->driver_version) >= 1573)
12994 {
12995 catalyst_warn = 0;
12996 }
12997
12998 catalyst_check = 0;
12999 }
13000
13001 if (catalyst_broken == 1)
13002 {
13003 log_info ("");
13004 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13005 log_info ("It will pass over cracked hashes and does not report them as cracked");
13006 log_info ("You are STRONGLY encouraged not to use it");
13007 log_info ("You can use --force to override this but do not post error reports if you do so");
13008 log_info ("");
13009
13010 return (-1);
13011 }
13012
13013 if (catalyst_warn == 1)
13014 {
13015 log_info ("");
13016 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13017 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13018 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
13019 #ifdef _WIN
13020 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13021 #endif
13022 log_info ("You can use --force to override this but do not post error reports if you do so");
13023 log_info ("");
13024
13025 return (-1);
13026 }
13027 }
13028 }
13029
13030 /**
13031 * kernel accel and loops tuning db adjustment
13032 */
13033
13034 device_param->kernel_accel_min = 1;
13035 device_param->kernel_accel_max = 1024;
13036
13037 device_param->kernel_loops_min = 1;
13038 device_param->kernel_loops_max = 1024;
13039
13040 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13041
13042 if (tuningdb_entry)
13043 {
13044 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13045 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13046
13047 if (_kernel_accel)
13048 {
13049 device_param->kernel_accel_min = _kernel_accel;
13050 device_param->kernel_accel_max = _kernel_accel;
13051 }
13052
13053 if (_kernel_loops)
13054 {
13055 if (workload_profile == 1)
13056 {
13057 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13058 }
13059 else if (workload_profile == 2)
13060 {
13061 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13062 }
13063
13064 device_param->kernel_loops_min = _kernel_loops;
13065 device_param->kernel_loops_max = _kernel_loops;
13066 }
13067 }
13068
13069 // commandline parameters overwrite tuningdb entries
13070
13071 if (kernel_accel)
13072 {
13073 device_param->kernel_accel_min = kernel_accel;
13074 device_param->kernel_accel_max = kernel_accel;
13075 }
13076
13077 if (kernel_loops)
13078 {
13079 device_param->kernel_loops_min = kernel_loops;
13080 device_param->kernel_loops_max = kernel_loops;
13081 }
13082
13083 /**
13084 * activate device
13085 */
13086
13087 devices_active++;
13088 }
13089
13090 // next please
13091
13092 devices_cnt++;
13093 }
13094 }
13095
13096 if (keyspace == 0 && devices_active == 0)
13097 {
13098 log_error ("ERROR: No devices found/left");
13099
13100 return (-1);
13101 }
13102
13103 // 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)
13104
13105 if (devices_filter != (uint) -1)
13106 {
13107 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13108
13109 if (devices_filter > devices_cnt_mask)
13110 {
13111 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13112
13113 return (-1);
13114 }
13115 }
13116
13117 data.devices_cnt = devices_cnt;
13118
13119 data.devices_active = devices_active;
13120
13121 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13122 {
13123 log_info ("");
13124 }
13125
13126 /**
13127 * HM devices: init
13128 */
13129
13130 #ifdef HAVE_HWMON
13131 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13132 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13133 #endif
13134
13135 #ifdef HAVE_ADL
13136 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13137 #endif
13138
13139 if (gpu_temp_disable == 0)
13140 {
13141 #if defined(WIN) && defined(HAVE_NVAPI)
13142 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13143
13144 if (nvapi_init (nvapi) == 0)
13145 data.hm_nv = nvapi;
13146
13147 if (data.hm_nv)
13148 {
13149 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13150 {
13151 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13152
13153 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13154
13155 int tmp_out = 0;
13156
13157 for (int i = 0; i < tmp_in; i++)
13158 {
13159 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13160 }
13161
13162 for (int i = 0; i < tmp_out; i++)
13163 {
13164 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13165
13166 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13167
13168 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;
13169 }
13170 }
13171 }
13172 #endif // WIN && HAVE_NVAPI
13173
13174 #if defined(LINUX) && defined(HAVE_NVML)
13175 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13176
13177 if (nvml_init (nvml) == 0)
13178 data.hm_nv = nvml;
13179
13180 if (data.hm_nv)
13181 {
13182 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13183 {
13184 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13185
13186 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13187
13188 int tmp_out = 0;
13189
13190 for (int i = 0; i < tmp_in; i++)
13191 {
13192 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13193 }
13194
13195 for (int i = 0; i < tmp_out; i++)
13196 {
13197 unsigned int speed;
13198
13199 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;
13200 }
13201 }
13202 }
13203 #endif // LINUX && HAVE_NVML
13204
13205 data.hm_amd = NULL;
13206
13207 #ifdef HAVE_ADL
13208 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13209
13210 if (adl_init (adl) == 0)
13211 data.hm_amd = adl;
13212
13213 if (data.hm_amd)
13214 {
13215 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13216 {
13217 // total number of adapters
13218
13219 int hm_adapters_num;
13220
13221 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13222
13223 // adapter info
13224
13225 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13226
13227 if (lpAdapterInfo == NULL) return (-1);
13228
13229 // get a list (of ids of) valid/usable adapters
13230
13231 int num_adl_adapters = 0;
13232
13233 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13234
13235 if (num_adl_adapters > 0)
13236 {
13237 hc_thread_mutex_lock (mux_adl);
13238
13239 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13240
13241 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13242
13243 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13244 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13245
13246 hc_thread_mutex_unlock (mux_adl);
13247 }
13248
13249 myfree (valid_adl_device_list);
13250 myfree (lpAdapterInfo);
13251 }
13252 }
13253 #endif // HAVE_ADL
13254
13255 if (data.hm_amd == NULL && data.hm_nv == NULL)
13256 {
13257 gpu_temp_disable = 1;
13258 }
13259 }
13260
13261 /**
13262 * OpenCL devices: allocate buffer for device specific information
13263 */
13264
13265 #ifdef HAVE_HWMON
13266 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13267
13268 #ifdef HAVE_ADL
13269 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13270
13271 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13272 #endif // ADL
13273 #endif
13274
13275 /**
13276 * enable custom signal handler(s)
13277 */
13278
13279 if (benchmark == 0)
13280 {
13281 hc_signal (sigHandler_default);
13282 }
13283 else
13284 {
13285 hc_signal (sigHandler_benchmark);
13286 }
13287
13288 /**
13289 * User-defined GPU temp handling
13290 */
13291
13292 #ifdef HAVE_HWMON
13293 if (gpu_temp_disable == 1)
13294 {
13295 gpu_temp_abort = 0;
13296 gpu_temp_retain = 0;
13297 }
13298
13299 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13300 {
13301 if (gpu_temp_abort < gpu_temp_retain)
13302 {
13303 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13304
13305 return (-1);
13306 }
13307 }
13308
13309 data.gpu_temp_disable = gpu_temp_disable;
13310 data.gpu_temp_abort = gpu_temp_abort;
13311 data.gpu_temp_retain = gpu_temp_retain;
13312 #endif
13313
13314 /**
13315 * inform the user
13316 */
13317
13318 if (data.quiet == 0)
13319 {
13320 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13321
13322 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);
13323
13324 if (attack_mode == ATTACK_MODE_STRAIGHT)
13325 {
13326 log_info ("Rules: %u", kernel_rules_cnt);
13327 }
13328
13329 if (opti_type)
13330 {
13331 log_info ("Applicable Optimizers:");
13332
13333 for (uint i = 0; i < 32; i++)
13334 {
13335 const uint opti_bit = 1u << i;
13336
13337 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13338 }
13339 }
13340
13341 /**
13342 * Watchdog and Temperature balance
13343 */
13344
13345 #ifdef HAVE_HWMON
13346 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13347 {
13348 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13349 }
13350
13351 if (gpu_temp_abort == 0)
13352 {
13353 log_info ("Watchdog: Temperature abort trigger disabled");
13354 }
13355 else
13356 {
13357 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13358 }
13359
13360 if (gpu_temp_retain == 0)
13361 {
13362 log_info ("Watchdog: Temperature retain trigger disabled");
13363 }
13364 else
13365 {
13366 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13367 }
13368 #endif
13369 }
13370
13371 if (data.quiet == 0) log_info ("");
13372
13373 /**
13374 * HM devices: copy
13375 */
13376
13377 if (gpu_temp_disable == 0)
13378 {
13379 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13380 {
13381 hc_device_param_t *device_param = &data.devices_param[device_id];
13382
13383 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13384
13385 if (device_param->skipped) continue;
13386
13387 const uint platform_devices_id = device_param->platform_devices_id;
13388
13389 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13390 if (device_param->vendor_id == VENDOR_ID_NV)
13391 {
13392 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13393 }
13394 #endif
13395
13396 #ifdef HAVE_ADL
13397 if (device_param->vendor_id == VENDOR_ID_AMD)
13398 {
13399 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13400 }
13401 #endif
13402 }
13403 }
13404
13405 /*
13406 * Temporary fix:
13407 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13408 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13409 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13410 * Driver / ADL bug?
13411 */
13412
13413 #ifdef HAVE_ADL
13414 if (powertune_enable == 1)
13415 {
13416 hc_thread_mutex_lock (mux_adl);
13417
13418 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13419 {
13420 hc_device_param_t *device_param = &data.devices_param[device_id];
13421
13422 if (device_param->skipped) continue;
13423
13424 if (data.hm_device[device_id].od_version == 6)
13425 {
13426 // set powertune value only
13427
13428 int powertune_supported = 0;
13429
13430 int ADL_rc = 0;
13431
13432 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13433 {
13434 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13435
13436 return (-1);
13437 }
13438
13439 if (powertune_supported != 0)
13440 {
13441 // powertune set
13442 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13443
13444 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13445 {
13446 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13447
13448 return (-1);
13449 }
13450
13451 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13452 {
13453 log_error ("ERROR: Failed to set new ADL PowerControl values");
13454
13455 return (-1);
13456 }
13457 }
13458 }
13459 }
13460
13461 hc_thread_mutex_unlock (mux_adl);
13462 }
13463 #endif // HAVE_ADK
13464 #endif // HAVE_HWMON
13465
13466 #ifdef DEBUG
13467 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13468 #endif
13469
13470 uint kernel_power_all = 0;
13471
13472 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13473 {
13474 /**
13475 * host buffer
13476 */
13477
13478 hc_device_param_t *device_param = &data.devices_param[device_id];
13479
13480 if (device_param->skipped) continue;
13481
13482 /**
13483 * device properties
13484 */
13485
13486 const char *device_name_chksum = device_param->device_name_chksum;
13487 const u32 device_processors = device_param->device_processors;
13488 const u32 device_processor_cores = device_param->device_processor_cores;
13489
13490 /**
13491 * create context for each device
13492 */
13493
13494 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13495
13496 /**
13497 * create command-queue
13498 */
13499
13500 // not supported with NV
13501 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13502
13503 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13504
13505 /**
13506 * create input buffers on device : calculate size of fixed memory buffers
13507 */
13508
13509 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13510 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13511
13512 device_param->size_root_css = size_root_css;
13513 device_param->size_markov_css = size_markov_css;
13514
13515 uint size_results = KERNEL_THREADS * sizeof (uint);
13516
13517 device_param->size_results = size_results;
13518
13519 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13520 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13521
13522 uint size_plains = digests_cnt * sizeof (plain_t);
13523 uint size_salts = salts_cnt * sizeof (salt_t);
13524 uint size_esalts = salts_cnt * esalt_size;
13525
13526 device_param->size_plains = size_plains;
13527 device_param->size_digests = size_digests;
13528 device_param->size_shown = size_shown;
13529 device_param->size_salts = size_salts;
13530
13531 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13532 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13533 uint size_tm = 32 * sizeof (bs_word_t);
13534
13535 // scryptV stuff
13536
13537 u64 size_scryptV = 1;
13538
13539 if ((hash_mode == 8900) || (hash_mode == 9300))
13540 {
13541 uint tmto_start = 0;
13542 uint tmto_stop = 10;
13543
13544 if (scrypt_tmto)
13545 {
13546 tmto_start = scrypt_tmto;
13547 }
13548 else
13549 {
13550 // in case the user did not specify the tmto manually
13551 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13552 // but set the lower end only in case the user has a device with too less memory
13553
13554 if (hash_mode == 8900)
13555 {
13556 if (device_param->vendor_id == VENDOR_ID_AMD)
13557 {
13558 tmto_start = 1;
13559 }
13560 else if (device_param->vendor_id == VENDOR_ID_NV)
13561 {
13562 tmto_start = 3;
13563 }
13564 }
13565 else if (hash_mode == 9300)
13566 {
13567 if (device_param->vendor_id == VENDOR_ID_AMD)
13568 {
13569 tmto_start = 3;
13570 }
13571 else if (device_param->vendor_id == VENDOR_ID_NV)
13572 {
13573 tmto_start = 5;
13574 }
13575 }
13576 }
13577
13578 if (quiet == 0) log_info ("");
13579
13580 uint shader_per_mp = 1;
13581
13582 if (device_param->vendor_id == VENDOR_ID_AMD)
13583 {
13584 shader_per_mp = 8;
13585 }
13586 else if (device_param->vendor_id == VENDOR_ID_NV)
13587 {
13588 shader_per_mp = 32;
13589 }
13590
13591 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13592 {
13593 // TODO: in theory the following calculation needs to be done per salt, not global
13594 // we assume all hashes have the same scrypt settings
13595
13596 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13597
13598 size_scryptV /= 1 << tmto;
13599
13600 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13601
13602 if (size_scryptV > device_param->device_maxmem_alloc)
13603 {
13604 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13605
13606 continue;
13607 }
13608
13609 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13610 {
13611 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13612 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13613 }
13614
13615 break;
13616 }
13617
13618 if (data.salts_buf[0].scrypt_phy == 0)
13619 {
13620 log_error ("ERROR: can't allocate enough device memory");
13621
13622 return -1;
13623 }
13624
13625 if (quiet == 0) log_info ("");
13626 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13627 }
13628
13629 /**
13630 * create input buffers on device : calculate size of dynamic size memory buffers
13631 */
13632
13633 uint kernel_threads = KERNEL_THREADS;
13634
13635 // some algorithms need a fixed kernel-threads count (mostly because of shared memory usage)
13636
13637 if (hash_mode == 3200) kernel_threads = 8;
13638 if (hash_mode == 9000) kernel_threads = 8;
13639
13640 /**
13641 * some algorithms need a fixed kernel-loops count
13642 */
13643
13644 if (hash_mode == 1500)
13645 {
13646 const u32 kernel_loops_fixed = 1024;
13647
13648 device_param->kernel_loops_min = kernel_loops_fixed;
13649 device_param->kernel_loops_max = kernel_loops_fixed;
13650 }
13651
13652 if (hash_mode == 3000)
13653 {
13654 const u32 kernel_loops_fixed = 1024;
13655
13656 device_param->kernel_loops_min = kernel_loops_fixed;
13657 device_param->kernel_loops_max = kernel_loops_fixed;
13658 }
13659
13660 if (hash_mode == 8900)
13661 {
13662 const u32 kernel_loops_fixed = 1;
13663
13664 device_param->kernel_loops_min = kernel_loops_fixed;
13665 device_param->kernel_loops_max = kernel_loops_fixed;
13666 }
13667
13668 if (hash_mode == 9300)
13669 {
13670 const u32 kernel_loops_fixed = 1;
13671
13672 device_param->kernel_loops_min = kernel_loops_fixed;
13673 device_param->kernel_loops_max = kernel_loops_fixed;
13674 }
13675
13676 if (hash_mode == 12500)
13677 {
13678 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13679
13680 device_param->kernel_loops_min = kernel_loops_fixed;
13681 device_param->kernel_loops_max = kernel_loops_fixed;
13682 }
13683
13684 /**
13685 * some algorithms have a maximum kernel-loops count
13686 */
13687
13688 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13689 {
13690 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13691 {
13692 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13693 }
13694 }
13695
13696 /**
13697 * some algorithms need a special kernel-accel
13698 */
13699
13700 if (hash_mode == 8900)
13701 {
13702 device_param->kernel_accel_min = 1;
13703 device_param->kernel_accel_max = 64;
13704 }
13705
13706 if (hash_mode == 9300)
13707 {
13708 device_param->kernel_accel_min = 1;
13709 device_param->kernel_accel_max = 64;
13710 }
13711
13712 u32 kernel_accel_min = device_param->kernel_accel_min;
13713 u32 kernel_accel_max = device_param->kernel_accel_max;
13714
13715 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13716
13717 uint size_pws = 4;
13718 uint size_tmps = 4;
13719 uint size_hooks = 4;
13720
13721 while (kernel_accel_max >= kernel_accel_min)
13722 {
13723 uint kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13724
13725 // size_pws
13726
13727 size_pws = kernel_power_max * sizeof (pw_t);
13728
13729 // size_tmps
13730
13731 switch (hash_mode)
13732 {
13733 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13734 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13735 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13736 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13737 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13738 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13739 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13740 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13741 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13742 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13743 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13744 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13745 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13746 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13747 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13748 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13749 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13750 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13751 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13752 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13753 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13754 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13755 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13756 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13757 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13758 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13759 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13760 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13761 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13762 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13763 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13764 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13765 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13766 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13767 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13768 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13769 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13770 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13771 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13772 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13773 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13774 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13775 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13776 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13777 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13778 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13779 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13780 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13781 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13782 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13783 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13784 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13785 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13786 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13787 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13788 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13789 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13790 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13791 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13792 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13793 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13794 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
13795 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
13796 };
13797
13798 // size_hooks
13799
13800 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13801 {
13802 // none yet
13803 }
13804
13805 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13806 // if not, decrease amplifier and try again
13807
13808 int skip = 0;
13809
13810 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13811 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13812 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13813
13814 if (( bitmap_size
13815 + bitmap_size
13816 + bitmap_size
13817 + bitmap_size
13818 + bitmap_size
13819 + bitmap_size
13820 + bitmap_size
13821 + bitmap_size
13822 + size_bfs
13823 + size_combs
13824 + size_digests
13825 + size_esalts
13826 + size_hooks
13827 + size_markov_css
13828 + size_plains
13829 + size_pws
13830 + size_results
13831 + size_root_css
13832 + size_rules
13833 + size_rules_c
13834 + size_salts
13835 + size_scryptV
13836 + size_shown
13837 + size_tm
13838 + size_tmps) > device_param->device_global_mem) skip = 1;
13839
13840 if (skip == 1)
13841 {
13842 kernel_accel_max--;
13843
13844 continue;
13845 }
13846
13847 break;
13848 }
13849
13850 /*
13851 if (kernel_accel_max == 0)
13852 {
13853 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13854
13855 return -1;
13856 }
13857 */
13858
13859 device_param->kernel_accel_min = kernel_accel_min;
13860 device_param->kernel_accel_max = kernel_accel_max;
13861
13862 /*
13863 if (kernel_accel_max < kernel_accel)
13864 {
13865 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13866
13867 device_param->kernel_accel = kernel_accel_max;
13868 }
13869 */
13870
13871 device_param->size_bfs = size_bfs;
13872 device_param->size_combs = size_combs;
13873 device_param->size_rules = size_rules;
13874 device_param->size_rules_c = size_rules_c;
13875 device_param->size_pws = size_pws;
13876 device_param->size_tmps = size_tmps;
13877 device_param->size_hooks = size_hooks;
13878
13879 // do not confuse kernel_accel_max with kernel_accel here
13880
13881 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13882
13883 device_param->kernel_threads = kernel_threads;
13884 device_param->kernel_power_user = kernel_power;
13885
13886 kernel_power_all += kernel_power;
13887
13888 /**
13889 * default building options
13890 */
13891
13892 char build_opts[1024] = { 0 };
13893
13894 // we don't have sm_* on vendors not NV but it doesn't matter
13895
13896 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);
13897
13898 /**
13899 * main kernel
13900 */
13901
13902 {
13903 /**
13904 * kernel source filename
13905 */
13906
13907 char source_file[256] = { 0 };
13908
13909 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13910
13911 struct stat sst;
13912
13913 if (stat (source_file, &sst) == -1)
13914 {
13915 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13916
13917 return -1;
13918 }
13919
13920 /**
13921 * kernel cached filename
13922 */
13923
13924 char cached_file[256] = { 0 };
13925
13926 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13927
13928 int cached = 1;
13929
13930 struct stat cst;
13931
13932 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13933 {
13934 cached = 0;
13935 }
13936
13937 /**
13938 * kernel compile or load
13939 */
13940
13941 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13942
13943 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13944
13945 if (force_jit_compilation == -1)
13946 {
13947 if (cached == 0)
13948 {
13949 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13950
13951 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13952
13953 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13954
13955 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13956
13957 #ifdef DEBUG
13958 size_t build_log_size = 0;
13959
13960 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
13961
13962 if (build_log_size > 1)
13963 {
13964 char *build_log = (char *) malloc (build_log_size + 1);
13965
13966 memset (build_log, 0, build_log_size + 1);
13967
13968 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
13969
13970 puts (build_log);
13971
13972 free (build_log);
13973 }
13974 #endif
13975
13976 if (rc != 0)
13977 {
13978 device_param->skipped = true;
13979 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13980 continue;
13981 }
13982
13983 size_t binary_size;
13984
13985 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13986
13987 u8 *binary = (u8 *) mymalloc (binary_size);
13988
13989 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13990
13991 writeProgramBin (cached_file, binary, binary_size);
13992
13993 local_free (binary);
13994 }
13995 else
13996 {
13997 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13998
13999 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14000
14001 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14002
14003 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14004 }
14005 }
14006 else
14007 {
14008 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14009
14010 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14011
14012 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14013
14014 char build_opts_update[1024] = { 0 };
14015
14016 if (force_jit_compilation == 1500)
14017 {
14018 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14019 }
14020 else if (force_jit_compilation == 8900)
14021 {
14022 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);
14023 }
14024 else
14025 {
14026 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14027 }
14028
14029 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14030
14031 #ifdef DEBUG
14032 size_t build_log_size = 0;
14033
14034 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14035
14036 if (build_log_size > 1)
14037 {
14038 char *build_log = (char *) malloc (build_log_size + 1);
14039
14040 memset (build_log, 0, build_log_size + 1);
14041
14042 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14043
14044 puts (build_log);
14045
14046 free (build_log);
14047 }
14048 #endif
14049
14050 if (rc != 0)
14051 {
14052 device_param->skipped = true;
14053
14054 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14055 }
14056 }
14057
14058 local_free (kernel_lengths);
14059 local_free (kernel_sources[0]);
14060 local_free (kernel_sources);
14061 }
14062
14063 /**
14064 * word generator kernel
14065 */
14066
14067 if (attack_mode != ATTACK_MODE_STRAIGHT)
14068 {
14069 /**
14070 * kernel mp source filename
14071 */
14072
14073 char source_file[256] = { 0 };
14074
14075 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14076
14077 struct stat sst;
14078
14079 if (stat (source_file, &sst) == -1)
14080 {
14081 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14082
14083 return -1;
14084 }
14085
14086 /**
14087 * kernel mp cached filename
14088 */
14089
14090 char cached_file[256] = { 0 };
14091
14092 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14093
14094 int cached = 1;
14095
14096 struct stat cst;
14097
14098 if (stat (cached_file, &cst) == -1)
14099 {
14100 cached = 0;
14101 }
14102
14103 /**
14104 * kernel compile or load
14105 */
14106
14107 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14108
14109 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14110
14111 if (cached == 0)
14112 {
14113 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14114
14115 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14116
14117 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14118
14119 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14120
14121 if (rc != 0)
14122 {
14123 device_param->skipped = true;
14124 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14125 continue;
14126 }
14127
14128 size_t binary_size;
14129
14130 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14131
14132 u8 *binary = (u8 *) mymalloc (binary_size);
14133
14134 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14135
14136 writeProgramBin (cached_file, binary, binary_size);
14137
14138 local_free (binary);
14139 }
14140 else
14141 {
14142 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14143
14144 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14145
14146 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14147
14148 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14149 }
14150
14151 local_free (kernel_lengths);
14152 local_free (kernel_sources[0]);
14153 local_free (kernel_sources);
14154 }
14155
14156 /**
14157 * amplifier kernel
14158 */
14159
14160 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14161 {
14162
14163 }
14164 else
14165 {
14166 /**
14167 * kernel amp source filename
14168 */
14169
14170 char source_file[256] = { 0 };
14171
14172 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14173
14174 struct stat sst;
14175
14176 if (stat (source_file, &sst) == -1)
14177 {
14178 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14179
14180 return -1;
14181 }
14182
14183 /**
14184 * kernel amp cached filename
14185 */
14186
14187 char cached_file[256] = { 0 };
14188
14189 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14190
14191 int cached = 1;
14192
14193 struct stat cst;
14194
14195 if (stat (cached_file, &cst) == -1)
14196 {
14197 cached = 0;
14198 }
14199
14200 /**
14201 * kernel compile or load
14202 */
14203
14204 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14205
14206 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14207
14208 if (cached == 0)
14209 {
14210 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14211
14212 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14213
14214 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14215
14216 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14217
14218 if (rc != 0)
14219 {
14220 device_param->skipped = true;
14221 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14222 continue;
14223 }
14224
14225 size_t binary_size;
14226
14227 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14228
14229 u8 *binary = (u8 *) mymalloc (binary_size);
14230
14231 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14232
14233 writeProgramBin (cached_file, binary, binary_size);
14234
14235 local_free (binary);
14236 }
14237 else
14238 {
14239 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14240
14241 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14242
14243 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14244
14245 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14246 }
14247
14248 local_free (kernel_lengths);
14249 local_free (kernel_sources[0]);
14250 local_free (kernel_sources);
14251 }
14252
14253 // some algorithm collide too fast, make that impossible
14254
14255 if (benchmark == 1)
14256 {
14257 ((uint *) digests_buf)[0] = -1;
14258 ((uint *) digests_buf)[1] = -1;
14259 ((uint *) digests_buf)[2] = -1;
14260 ((uint *) digests_buf)[3] = -1;
14261 }
14262
14263 /**
14264 * global buffers
14265 */
14266
14267 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14268 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14269 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14270 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14271 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14272 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14273 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14274 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14275 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14276 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14277 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14278 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14279 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14280 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14281 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14282 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14283 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14284 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14285
14286 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);
14287 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);
14288 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);
14289 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);
14290 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);
14291 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);
14292 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);
14293 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);
14294 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14295 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14296 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14297
14298 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14299 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14300 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14301 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14302 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14303 run_kernel_bzero (device_param, device_param->d_result, size_results);
14304
14305 /**
14306 * special buffers
14307 */
14308
14309 if (attack_kern == ATTACK_KERN_STRAIGHT)
14310 {
14311 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14312 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14313
14314 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14315
14316 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14317 }
14318 else if (attack_kern == ATTACK_KERN_COMBI)
14319 {
14320 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14321 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14322 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14323 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14324
14325 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14326 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14327 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14328 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14329 }
14330 else if (attack_kern == ATTACK_KERN_BF)
14331 {
14332 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14333 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14334 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14335 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14336 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14337
14338 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14339 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14340 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14341 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14342 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14343 }
14344
14345 if (size_esalts)
14346 {
14347 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14348
14349 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14350 }
14351
14352 /**
14353 * main host data
14354 */
14355
14356 uint *result = (uint *) mymalloc (size_results);
14357
14358 device_param->result = result;
14359
14360 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14361
14362 device_param->pws_buf = pws_buf;
14363
14364 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14365
14366 device_param->combs_buf = combs_buf;
14367
14368 void *hooks_buf = mymalloc (size_hooks);
14369
14370 device_param->hooks_buf = hooks_buf;
14371
14372 /**
14373 * kernel args
14374 */
14375
14376 device_param->kernel_params_buf32[21] = bitmap_mask;
14377 device_param->kernel_params_buf32[22] = bitmap_shift1;
14378 device_param->kernel_params_buf32[23] = bitmap_shift2;
14379 device_param->kernel_params_buf32[24] = 0; // salt_pos
14380 device_param->kernel_params_buf32[25] = 0; // loop_pos
14381 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14382 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14383 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14384 device_param->kernel_params_buf32[29] = 0; // digests_offset
14385 device_param->kernel_params_buf32[30] = 0; // combs_mode
14386 device_param->kernel_params_buf32[31] = 0; // gid_max
14387
14388 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14389 ? &device_param->d_pws_buf
14390 : &device_param->d_pws_amp_buf;
14391 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14392 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14393 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14394 device_param->kernel_params[ 4] = &device_param->d_tmps;
14395 device_param->kernel_params[ 5] = &device_param->d_hooks;
14396 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14397 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14398 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14399 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14400 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14401 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14402 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14403 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14404 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14405 device_param->kernel_params[15] = &device_param->d_digests_buf;
14406 device_param->kernel_params[16] = &device_param->d_digests_shown;
14407 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14408 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14409 device_param->kernel_params[19] = &device_param->d_result;
14410 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14411 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14412 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14413 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14414 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14415 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14416 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14417 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14418 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14419 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14420 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14421 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14422
14423 device_param->kernel_params_mp_buf64[3] = 0;
14424 device_param->kernel_params_mp_buf32[4] = 0;
14425 device_param->kernel_params_mp_buf32[5] = 0;
14426 device_param->kernel_params_mp_buf32[6] = 0;
14427 device_param->kernel_params_mp_buf32[7] = 0;
14428 device_param->kernel_params_mp_buf32[8] = 0;
14429
14430 device_param->kernel_params_mp[0] = NULL;
14431 device_param->kernel_params_mp[1] = NULL;
14432 device_param->kernel_params_mp[2] = NULL;
14433 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14434 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14435 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14436 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14437 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14438 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14439
14440 device_param->kernel_params_mp_l_buf64[3] = 0;
14441 device_param->kernel_params_mp_l_buf32[4] = 0;
14442 device_param->kernel_params_mp_l_buf32[5] = 0;
14443 device_param->kernel_params_mp_l_buf32[6] = 0;
14444 device_param->kernel_params_mp_l_buf32[7] = 0;
14445 device_param->kernel_params_mp_l_buf32[8] = 0;
14446 device_param->kernel_params_mp_l_buf32[9] = 0;
14447
14448 device_param->kernel_params_mp_l[0] = NULL;
14449 device_param->kernel_params_mp_l[1] = NULL;
14450 device_param->kernel_params_mp_l[2] = NULL;
14451 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14452 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14453 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14454 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14455 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14456 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14457 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14458
14459 device_param->kernel_params_mp_r_buf64[3] = 0;
14460 device_param->kernel_params_mp_r_buf32[4] = 0;
14461 device_param->kernel_params_mp_r_buf32[5] = 0;
14462 device_param->kernel_params_mp_r_buf32[6] = 0;
14463 device_param->kernel_params_mp_r_buf32[7] = 0;
14464 device_param->kernel_params_mp_r_buf32[8] = 0;
14465
14466 device_param->kernel_params_mp_r[0] = NULL;
14467 device_param->kernel_params_mp_r[1] = NULL;
14468 device_param->kernel_params_mp_r[2] = NULL;
14469 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14470 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14471 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14472 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14473 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14474 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14475
14476 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14477 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14478
14479 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14480 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14481 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14482 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14483 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14484 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14485 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14486
14487 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14488 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14489
14490 /**
14491 * kernel name
14492 */
14493
14494 char kernel_name[64] = { 0 };
14495
14496 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14497 {
14498 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14499 {
14500 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14501
14502 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14503
14504 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14505
14506 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14507
14508 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14509
14510 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14511 }
14512 else
14513 {
14514 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14515
14516 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14517
14518 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14519
14520 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14521
14522 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14523
14524 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14525 }
14526
14527 if (data.attack_mode == ATTACK_MODE_BF)
14528 {
14529 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14530 {
14531 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14532
14533 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14534 }
14535 }
14536 }
14537 else
14538 {
14539 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14540
14541 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14542
14543 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14544
14545 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14546
14547 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14548
14549 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14550
14551 if (opts_type & OPTS_TYPE_HOOK12)
14552 {
14553 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14554
14555 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14556 }
14557
14558 if (opts_type & OPTS_TYPE_HOOK23)
14559 {
14560 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14561
14562 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14563 }
14564 }
14565
14566 for (uint i = 0; i <= 20; i++)
14567 {
14568 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14569 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14570 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14571
14572 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14573 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14574 }
14575
14576 for (uint i = 21; i <= 31; i++)
14577 {
14578 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14579 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14580 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14581
14582 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14583 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14584 }
14585
14586 if (attack_mode == ATTACK_MODE_BF)
14587 {
14588 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14589 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14590
14591 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14592 {
14593 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14594 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14595 }
14596 }
14597 else if (attack_mode == ATTACK_MODE_HYBRID1)
14598 {
14599 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14600 }
14601 else if (attack_mode == ATTACK_MODE_HYBRID2)
14602 {
14603 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14604 }
14605
14606 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14607 {
14608 // nothing to do
14609 }
14610 else
14611 {
14612 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14613 }
14614
14615 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14616 {
14617 // nothing to do
14618 }
14619 else
14620 {
14621 for (uint i = 0; i < 5; i++)
14622 {
14623 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14624 }
14625
14626 for (uint i = 5; i < 7; i++)
14627 {
14628 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14629 }
14630 }
14631
14632 /**
14633 * Store initial fanspeed if gpu_temp_retain is enabled
14634 */
14635
14636 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14637 int gpu_temp_retain_set = 0;
14638
14639 if (gpu_temp_disable == 0)
14640 {
14641 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14642 {
14643 hc_thread_mutex_lock (mux_adl);
14644
14645 if (data.hm_device[device_id].fan_supported == 1)
14646 {
14647 if (gpu_temp_retain_chgd == 0)
14648 {
14649 uint cur_temp = 0;
14650 uint default_temp = 0;
14651
14652 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);
14653
14654 if (ADL_rc == ADL_OK)
14655 {
14656 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14657
14658 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14659
14660 // special case with multi gpu setups: always use minimum retain
14661
14662 if (gpu_temp_retain_set == 0)
14663 {
14664 gpu_temp_retain = gpu_temp_retain_target;
14665 gpu_temp_retain_set = 1;
14666 }
14667 else
14668 {
14669 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14670 }
14671
14672 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14673 }
14674 }
14675
14676 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14677
14678 temp_retain_fanspeed_value[device_id] = fan_speed;
14679
14680 if (fan_speed == -1)
14681 {
14682 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14683
14684 temp_retain_fanspeed_value[device_id] = 0;
14685 }
14686 }
14687
14688 hc_thread_mutex_unlock (mux_adl);
14689 }
14690 }
14691
14692 /**
14693 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14694 */
14695
14696 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14697 {
14698 hc_thread_mutex_lock (mux_adl);
14699
14700 if (data.hm_device[device_id].od_version == 6)
14701 {
14702 int ADL_rc;
14703
14704 // check powertune capabilities first, if not available then skip device
14705
14706 int powertune_supported = 0;
14707
14708 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14709 {
14710 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14711
14712 return (-1);
14713 }
14714
14715 if (powertune_supported != 0)
14716 {
14717 // powercontrol settings
14718
14719 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14720
14721 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14722 {
14723 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14724 }
14725
14726 if (ADL_rc != ADL_OK)
14727 {
14728 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14729
14730 return (-1);
14731 }
14732
14733 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14734 {
14735 log_error ("ERROR: Failed to set new ADL PowerControl values");
14736
14737 return (-1);
14738 }
14739
14740 // clocks
14741
14742 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14743
14744 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14745
14746 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)
14747 {
14748 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14749
14750 return (-1);
14751 }
14752
14753 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14754
14755 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14756
14757 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14758 {
14759 log_error ("ERROR: Failed to get ADL device capabilities");
14760
14761 return (-1);
14762 }
14763
14764 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14765 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14766
14767 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14768 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14769
14770 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14771 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14772
14773 // warning if profile has too low max values
14774
14775 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14776 {
14777 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14778 }
14779
14780 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14781 {
14782 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14783 }
14784
14785 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14786
14787 performance_state->iNumberOfPerformanceLevels = 2;
14788
14789 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14790 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14791 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14792 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14793
14794 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)
14795 {
14796 log_info ("ERROR: Failed to set ADL performance state");
14797
14798 return (-1);
14799 }
14800
14801 local_free (performance_state);
14802 }
14803 }
14804
14805 hc_thread_mutex_unlock (mux_adl);
14806 }
14807 #endif // HAVE_HWMON && HAVE_ADL
14808 }
14809
14810 data.kernel_power_all = kernel_power_all;
14811
14812 if (data.quiet == 0) log_info ("");
14813
14814 /**
14815 * Inform user which algorithm is checked and at which workload setting
14816 */
14817
14818 if (benchmark == 1)
14819 {
14820 quiet = 0;
14821
14822 data.quiet = quiet;
14823
14824 char *hash_type = strhashtype (data.hash_mode); // not a bug
14825
14826 log_info ("Hashtype: %s", hash_type);
14827 log_info ("");
14828 }
14829
14830 /**
14831 * keep track of the progress
14832 */
14833
14834 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14835 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14836 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14837
14838 /**
14839 * open filehandles
14840 */
14841
14842 #if _WIN
14843 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14844 {
14845 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14846
14847 return (-1);
14848 }
14849
14850 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14851 {
14852 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14853
14854 return (-1);
14855 }
14856
14857 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14858 {
14859 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14860
14861 return (-1);
14862 }
14863 #endif
14864
14865 /**
14866 * dictionary pad
14867 */
14868
14869 segment_size *= (1024 * 1024);
14870
14871 data.segment_size = segment_size;
14872
14873 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14874
14875 wl_data->buf = (char *) mymalloc (segment_size);
14876 wl_data->avail = segment_size;
14877 wl_data->incr = segment_size;
14878 wl_data->cnt = 0;
14879 wl_data->pos = 0;
14880
14881 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14882
14883 data.wordlist_mode = wordlist_mode;
14884
14885 cs_t *css_buf = NULL;
14886 uint css_cnt = 0;
14887 uint dictcnt = 0;
14888 uint maskcnt = 1;
14889 char **masks = NULL;
14890 char **dictfiles = NULL;
14891
14892 uint mask_from_file = 0;
14893
14894 if (attack_mode == ATTACK_MODE_STRAIGHT)
14895 {
14896 if (wordlist_mode == WL_MODE_FILE)
14897 {
14898 int wls_left = myargc - (optind + 1);
14899
14900 for (int i = 0; i < wls_left; i++)
14901 {
14902 char *l0_filename = myargv[optind + 1 + i];
14903
14904 struct stat l0_stat;
14905
14906 if (stat (l0_filename, &l0_stat) == -1)
14907 {
14908 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14909
14910 return (-1);
14911 }
14912
14913 uint is_dir = S_ISDIR (l0_stat.st_mode);
14914
14915 if (is_dir == 0)
14916 {
14917 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14918
14919 dictcnt++;
14920
14921 dictfiles[dictcnt - 1] = l0_filename;
14922 }
14923 else
14924 {
14925 // do not allow --keyspace w/ a directory
14926
14927 if (keyspace == 1)
14928 {
14929 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14930
14931 return (-1);
14932 }
14933
14934 char **dictionary_files = NULL;
14935
14936 dictionary_files = scan_directory (l0_filename);
14937
14938 if (dictionary_files != NULL)
14939 {
14940 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14941
14942 for (int d = 0; dictionary_files[d] != NULL; d++)
14943 {
14944 char *l1_filename = dictionary_files[d];
14945
14946 struct stat l1_stat;
14947
14948 if (stat (l1_filename, &l1_stat) == -1)
14949 {
14950 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14951
14952 return (-1);
14953 }
14954
14955 if (S_ISREG (l1_stat.st_mode))
14956 {
14957 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14958
14959 dictcnt++;
14960
14961 dictfiles[dictcnt - 1] = strdup (l1_filename);
14962 }
14963 }
14964 }
14965
14966 local_free (dictionary_files);
14967 }
14968 }
14969
14970 if (dictcnt < 1)
14971 {
14972 log_error ("ERROR: No usable dictionary file found.");
14973
14974 return (-1);
14975 }
14976 }
14977 else if (wordlist_mode == WL_MODE_STDIN)
14978 {
14979 dictcnt = 1;
14980 }
14981 }
14982 else if (attack_mode == ATTACK_MODE_COMBI)
14983 {
14984 // display
14985
14986 char *dictfile1 = myargv[optind + 1 + 0];
14987 char *dictfile2 = myargv[optind + 1 + 1];
14988
14989 // find the bigger dictionary and use as base
14990
14991 FILE *fp1 = NULL;
14992 FILE *fp2 = NULL;
14993
14994 struct stat tmp_stat;
14995
14996 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14997 {
14998 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14999
15000 return (-1);
15001 }
15002
15003 if (stat (dictfile1, &tmp_stat) == -1)
15004 {
15005 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15006
15007 fclose (fp1);
15008
15009 return (-1);
15010 }
15011
15012 if (S_ISDIR (tmp_stat.st_mode))
15013 {
15014 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15015
15016 fclose (fp1);
15017
15018 return (-1);
15019 }
15020
15021 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15022 {
15023 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15024
15025 fclose (fp1);
15026
15027 return (-1);
15028 }
15029
15030 if (stat (dictfile2, &tmp_stat) == -1)
15031 {
15032 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15033
15034 fclose (fp1);
15035 fclose (fp2);
15036
15037 return (-1);
15038 }
15039
15040 if (S_ISDIR (tmp_stat.st_mode))
15041 {
15042 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15043
15044 fclose (fp1);
15045 fclose (fp2);
15046
15047 return (-1);
15048 }
15049
15050 data.combs_cnt = 1;
15051
15052 data.quiet = 1;
15053
15054 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15055
15056 data.quiet = quiet;
15057
15058 if (words1_cnt == 0)
15059 {
15060 log_error ("ERROR: %s: empty file", dictfile1);
15061
15062 fclose (fp1);
15063 fclose (fp2);
15064
15065 return (-1);
15066 }
15067
15068 data.combs_cnt = 1;
15069
15070 data.quiet = 1;
15071
15072 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15073
15074 data.quiet = quiet;
15075
15076 if (words2_cnt == 0)
15077 {
15078 log_error ("ERROR: %s: empty file", dictfile2);
15079
15080 fclose (fp1);
15081 fclose (fp2);
15082
15083 return (-1);
15084 }
15085
15086 fclose (fp1);
15087 fclose (fp2);
15088
15089 data.dictfile = dictfile1;
15090 data.dictfile2 = dictfile2;
15091
15092 if (words1_cnt >= words2_cnt)
15093 {
15094 data.combs_cnt = words2_cnt;
15095 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15096
15097 dictfiles = &data.dictfile;
15098
15099 dictcnt = 1;
15100 }
15101 else
15102 {
15103 data.combs_cnt = words1_cnt;
15104 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15105
15106 dictfiles = &data.dictfile2;
15107
15108 dictcnt = 1;
15109
15110 // we also have to switch wordlist related rules!
15111
15112 char *tmpc = data.rule_buf_l;
15113
15114 data.rule_buf_l = data.rule_buf_r;
15115 data.rule_buf_r = tmpc;
15116
15117 int tmpi = data.rule_len_l;
15118
15119 data.rule_len_l = data.rule_len_r;
15120 data.rule_len_r = tmpi;
15121 }
15122 }
15123 else if (attack_mode == ATTACK_MODE_BF)
15124 {
15125 char *mask = NULL;
15126
15127 maskcnt = 0;
15128
15129 if (benchmark == 0)
15130 {
15131 mask = myargv[optind + 1];
15132
15133 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15134
15135 if ((optind + 2) <= myargc)
15136 {
15137 struct stat file_stat;
15138
15139 if (stat (mask, &file_stat) == -1)
15140 {
15141 maskcnt = 1;
15142
15143 masks[maskcnt - 1] = mystrdup (mask);
15144 }
15145 else
15146 {
15147 int wls_left = myargc - (optind + 1);
15148
15149 uint masks_avail = INCR_MASKS;
15150
15151 for (int i = 0; i < wls_left; i++)
15152 {
15153 if (i != 0)
15154 {
15155 mask = myargv[optind + 1 + i];
15156
15157 if (stat (mask, &file_stat) == -1)
15158 {
15159 log_error ("ERROR: %s: %s", mask, strerror (errno));
15160
15161 return (-1);
15162 }
15163 }
15164
15165 uint is_file = S_ISREG (file_stat.st_mode);
15166
15167 if (is_file == 1)
15168 {
15169 FILE *mask_fp;
15170
15171 if ((mask_fp = fopen (mask, "r")) == NULL)
15172 {
15173 log_error ("ERROR: %s: %s", mask, strerror (errno));
15174
15175 return (-1);
15176 }
15177
15178 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15179
15180 while (!feof (mask_fp))
15181 {
15182 memset (line_buf, 0, HCBUFSIZ);
15183
15184 int line_len = fgetl (mask_fp, line_buf);
15185
15186 if (line_len == 0) continue;
15187
15188 if (line_buf[0] == '#') continue;
15189
15190 if (masks_avail == maskcnt)
15191 {
15192 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15193
15194 masks_avail += INCR_MASKS;
15195 }
15196
15197 masks[maskcnt] = mystrdup (line_buf);
15198
15199 maskcnt++;
15200 }
15201
15202 myfree (line_buf);
15203
15204 fclose (mask_fp);
15205 }
15206 else
15207 {
15208 log_error ("ERROR: %s: unsupported file-type", mask);
15209
15210 return (-1);
15211 }
15212 }
15213
15214 mask_from_file = 1;
15215 }
15216 }
15217 else
15218 {
15219 custom_charset_1 = (char *) "?l?d?u";
15220 custom_charset_2 = (char *) "?l?d";
15221 custom_charset_3 = (char *) "?l?d*!$@_";
15222
15223 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15224 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15225 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15226
15227 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15228
15229 wordlist_mode = WL_MODE_MASK;
15230
15231 data.wordlist_mode = wordlist_mode;
15232
15233 increment = 1;
15234
15235 maskcnt = 1;
15236 }
15237 }
15238 else
15239 {
15240 /**
15241 * generate full masks and charsets
15242 */
15243
15244 masks = (char **) mymalloc (sizeof (char *));
15245
15246 switch (hash_mode)
15247 {
15248 case 1731: pw_min = 5;
15249 pw_max = 5;
15250 mask = mystrdup ("?b?b?b?b?b");
15251 break;
15252 case 12500: pw_min = 5;
15253 pw_max = 5;
15254 mask = mystrdup ("?b?b?b?b?b");
15255 break;
15256 default: pw_min = 7;
15257 pw_max = 7;
15258 mask = mystrdup ("?b?b?b?b?b?b?b");
15259 break;
15260 }
15261
15262 maskcnt = 1;
15263
15264 masks[maskcnt - 1] = mystrdup (mask);
15265
15266 wordlist_mode = WL_MODE_MASK;
15267
15268 data.wordlist_mode = wordlist_mode;
15269
15270 increment = 1;
15271 }
15272
15273 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15274
15275 if (increment)
15276 {
15277 if (increment_min > pw_min) pw_min = increment_min;
15278
15279 if (increment_max < pw_max) pw_max = increment_max;
15280 }
15281 }
15282 else if (attack_mode == ATTACK_MODE_HYBRID1)
15283 {
15284 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15285
15286 // display
15287
15288 char *mask = myargv[myargc - 1];
15289
15290 maskcnt = 0;
15291
15292 masks = (char **) mymalloc (1 * sizeof (char *));
15293
15294 // mod
15295
15296 struct stat file_stat;
15297
15298 if (stat (mask, &file_stat) == -1)
15299 {
15300 maskcnt = 1;
15301
15302 masks[maskcnt - 1] = mystrdup (mask);
15303 }
15304 else
15305 {
15306 uint is_file = S_ISREG (file_stat.st_mode);
15307
15308 if (is_file == 1)
15309 {
15310 FILE *mask_fp;
15311
15312 if ((mask_fp = fopen (mask, "r")) == NULL)
15313 {
15314 log_error ("ERROR: %s: %s", mask, strerror (errno));
15315
15316 return (-1);
15317 }
15318
15319 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15320
15321 uint masks_avail = 1;
15322
15323 while (!feof (mask_fp))
15324 {
15325 memset (line_buf, 0, HCBUFSIZ);
15326
15327 int line_len = fgetl (mask_fp, line_buf);
15328
15329 if (line_len == 0) continue;
15330
15331 if (line_buf[0] == '#') continue;
15332
15333 if (masks_avail == maskcnt)
15334 {
15335 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15336
15337 masks_avail += INCR_MASKS;
15338 }
15339
15340 masks[maskcnt] = mystrdup (line_buf);
15341
15342 maskcnt++;
15343 }
15344
15345 myfree (line_buf);
15346
15347 fclose (mask_fp);
15348
15349 mask_from_file = 1;
15350 }
15351 else
15352 {
15353 maskcnt = 1;
15354
15355 masks[maskcnt - 1] = mystrdup (mask);
15356 }
15357 }
15358
15359 // base
15360
15361 int wls_left = myargc - (optind + 2);
15362
15363 for (int i = 0; i < wls_left; i++)
15364 {
15365 char *filename = myargv[optind + 1 + i];
15366
15367 struct stat file_stat;
15368
15369 if (stat (filename, &file_stat) == -1)
15370 {
15371 log_error ("ERROR: %s: %s", filename, strerror (errno));
15372
15373 return (-1);
15374 }
15375
15376 uint is_dir = S_ISDIR (file_stat.st_mode);
15377
15378 if (is_dir == 0)
15379 {
15380 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15381
15382 dictcnt++;
15383
15384 dictfiles[dictcnt - 1] = filename;
15385 }
15386 else
15387 {
15388 // do not allow --keyspace w/ a directory
15389
15390 if (keyspace == 1)
15391 {
15392 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15393
15394 return (-1);
15395 }
15396
15397 char **dictionary_files = NULL;
15398
15399 dictionary_files = scan_directory (filename);
15400
15401 if (dictionary_files != NULL)
15402 {
15403 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15404
15405 for (int d = 0; dictionary_files[d] != NULL; d++)
15406 {
15407 char *l1_filename = dictionary_files[d];
15408
15409 struct stat l1_stat;
15410
15411 if (stat (l1_filename, &l1_stat) == -1)
15412 {
15413 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15414
15415 return (-1);
15416 }
15417
15418 if (S_ISREG (l1_stat.st_mode))
15419 {
15420 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15421
15422 dictcnt++;
15423
15424 dictfiles[dictcnt - 1] = strdup (l1_filename);
15425 }
15426 }
15427 }
15428
15429 local_free (dictionary_files);
15430 }
15431 }
15432
15433 if (dictcnt < 1)
15434 {
15435 log_error ("ERROR: No usable dictionary file found.");
15436
15437 return (-1);
15438 }
15439
15440 if (increment)
15441 {
15442 maskcnt = 0;
15443
15444 uint mask_min = increment_min; // we can't reject smaller masks here
15445 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15446
15447 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15448 {
15449 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15450
15451 if (cur_mask == NULL) break;
15452
15453 masks[maskcnt] = cur_mask;
15454
15455 maskcnt++;
15456
15457 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15458 }
15459 }
15460 }
15461 else if (attack_mode == ATTACK_MODE_HYBRID2)
15462 {
15463 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15464
15465 // display
15466
15467 char *mask = myargv[optind + 1 + 0];
15468
15469 maskcnt = 0;
15470
15471 masks = (char **) mymalloc (1 * sizeof (char *));
15472
15473 // mod
15474
15475 struct stat file_stat;
15476
15477 if (stat (mask, &file_stat) == -1)
15478 {
15479 maskcnt = 1;
15480
15481 masks[maskcnt - 1] = mystrdup (mask);
15482 }
15483 else
15484 {
15485 uint is_file = S_ISREG (file_stat.st_mode);
15486
15487 if (is_file == 1)
15488 {
15489 FILE *mask_fp;
15490
15491 if ((mask_fp = fopen (mask, "r")) == NULL)
15492 {
15493 log_error ("ERROR: %s: %s", mask, strerror (errno));
15494
15495 return (-1);
15496 }
15497
15498 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15499
15500 uint masks_avail = 1;
15501
15502 while (!feof (mask_fp))
15503 {
15504 memset (line_buf, 0, HCBUFSIZ);
15505
15506 int line_len = fgetl (mask_fp, line_buf);
15507
15508 if (line_len == 0) continue;
15509
15510 if (line_buf[0] == '#') continue;
15511
15512 if (masks_avail == maskcnt)
15513 {
15514 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15515
15516 masks_avail += INCR_MASKS;
15517 }
15518
15519 masks[maskcnt] = mystrdup (line_buf);
15520
15521 maskcnt++;
15522 }
15523
15524 myfree (line_buf);
15525
15526 fclose (mask_fp);
15527
15528 mask_from_file = 1;
15529 }
15530 else
15531 {
15532 maskcnt = 1;
15533
15534 masks[maskcnt - 1] = mystrdup (mask);
15535 }
15536 }
15537
15538 // base
15539
15540 int wls_left = myargc - (optind + 2);
15541
15542 for (int i = 0; i < wls_left; i++)
15543 {
15544 char *filename = myargv[optind + 2 + i];
15545
15546 struct stat file_stat;
15547
15548 if (stat (filename, &file_stat) == -1)
15549 {
15550 log_error ("ERROR: %s: %s", filename, strerror (errno));
15551
15552 return (-1);
15553 }
15554
15555 uint is_dir = S_ISDIR (file_stat.st_mode);
15556
15557 if (is_dir == 0)
15558 {
15559 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15560
15561 dictcnt++;
15562
15563 dictfiles[dictcnt - 1] = filename;
15564 }
15565 else
15566 {
15567 // do not allow --keyspace w/ a directory
15568
15569 if (keyspace == 1)
15570 {
15571 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15572
15573 return (-1);
15574 }
15575
15576 char **dictionary_files = NULL;
15577
15578 dictionary_files = scan_directory (filename);
15579
15580 if (dictionary_files != NULL)
15581 {
15582 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15583
15584 for (int d = 0; dictionary_files[d] != NULL; d++)
15585 {
15586 char *l1_filename = dictionary_files[d];
15587
15588 struct stat l1_stat;
15589
15590 if (stat (l1_filename, &l1_stat) == -1)
15591 {
15592 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15593
15594 return (-1);
15595 }
15596
15597 if (S_ISREG (l1_stat.st_mode))
15598 {
15599 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15600
15601 dictcnt++;
15602
15603 dictfiles[dictcnt - 1] = strdup (l1_filename);
15604 }
15605 }
15606 }
15607
15608 local_free (dictionary_files);
15609 }
15610 }
15611
15612 if (dictcnt < 1)
15613 {
15614 log_error ("ERROR: No usable dictionary file found.");
15615
15616 return (-1);
15617 }
15618
15619 if (increment)
15620 {
15621 maskcnt = 0;
15622
15623 uint mask_min = increment_min; // we can't reject smaller masks here
15624 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15625
15626 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15627 {
15628 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15629
15630 if (cur_mask == NULL) break;
15631
15632 masks[maskcnt] = cur_mask;
15633
15634 maskcnt++;
15635
15636 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15637 }
15638 }
15639 }
15640
15641 data.pw_min = pw_min;
15642 data.pw_max = pw_max;
15643
15644 /**
15645 * weak hash check
15646 */
15647
15648 if (weak_hash_threshold >= salts_cnt)
15649 {
15650 hc_device_param_t *device_param = NULL;
15651
15652 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15653 {
15654 device_param = &data.devices_param[device_id];
15655
15656 if (device_param->skipped) continue;
15657
15658 break;
15659 }
15660
15661 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15662
15663 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15664 {
15665 weak_hash_check (device_param, salt_pos);
15666 }
15667 }
15668
15669 // Display hack, guarantee that there is at least one \r before real start
15670
15671 if (data.quiet == 0) log_info_nn ("");
15672
15673 /**
15674 * status and monitor threads
15675 */
15676
15677 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15678
15679 hc_thread_t i_thread = 0;
15680
15681 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15682 {
15683 hc_thread_create (i_thread, thread_keypress, &benchmark);
15684 }
15685
15686 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15687
15688 uint ni_threads_cnt = 0;
15689
15690 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15691
15692 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15693
15694 ni_threads_cnt++;
15695
15696 /**
15697 * Outfile remove
15698 */
15699
15700 if (keyspace == 0)
15701 {
15702 if (outfile_check_timer != 0)
15703 {
15704 if (data.outfile_check_directory != NULL)
15705 {
15706 if ((hash_mode != 5200) &&
15707 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15708 (hash_mode != 9000))
15709 {
15710 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15711
15712 ni_threads_cnt++;
15713 }
15714 else
15715 {
15716 outfile_check_timer = 0;
15717 }
15718 }
15719 else
15720 {
15721 outfile_check_timer = 0;
15722 }
15723 }
15724 }
15725
15726 /**
15727 * Inform the user if we got some hashes remove because of the pot file remove feature
15728 */
15729
15730 if (data.quiet == 0)
15731 {
15732 if (potfile_remove_cracks > 0)
15733 {
15734 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15735 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15736 }
15737 }
15738
15739 data.outfile_check_timer = outfile_check_timer;
15740
15741 /**
15742 * main loop
15743 */
15744
15745 char **induction_dictionaries = NULL;
15746
15747 int induction_dictionaries_cnt = 0;
15748
15749 hcstat_table_t *root_table_buf = NULL;
15750 hcstat_table_t *markov_table_buf = NULL;
15751
15752 uint initial_restore_done = 0;
15753
15754 data.maskcnt = maskcnt;
15755
15756 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15757 {
15758 if (data.devices_status == STATUS_CRACKED) break;
15759
15760 data.devices_status = STATUS_INIT;
15761
15762 if (maskpos > rd->maskpos)
15763 {
15764 rd->dictpos = 0;
15765 }
15766
15767 rd->maskpos = maskpos;
15768 data.maskpos = maskpos;
15769
15770 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15771 {
15772 char *mask = masks[maskpos];
15773
15774 if (mask_from_file == 1)
15775 {
15776 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15777
15778 char *str_ptr;
15779 uint str_pos;
15780
15781 uint mask_offset = 0;
15782
15783 uint separator_cnt;
15784
15785 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15786 {
15787 str_ptr = strstr (mask + mask_offset, ",");
15788
15789 if (str_ptr == NULL) break;
15790
15791 str_pos = str_ptr - mask;
15792
15793 // escaped separator, i.e. "\,"
15794
15795 if (str_pos > 0)
15796 {
15797 if (mask[str_pos - 1] == '\\')
15798 {
15799 separator_cnt --;
15800
15801 mask_offset = str_pos + 1;
15802
15803 continue;
15804 }
15805 }
15806
15807 // reset the offset
15808
15809 mask_offset = 0;
15810
15811 mask[str_pos] = '\0';
15812
15813 switch (separator_cnt)
15814 {
15815 case 0:
15816 mp_reset_usr (mp_usr, 0);
15817
15818 custom_charset_1 = mask;
15819 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15820 break;
15821
15822 case 1:
15823 mp_reset_usr (mp_usr, 1);
15824
15825 custom_charset_2 = mask;
15826 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15827 break;
15828
15829 case 2:
15830 mp_reset_usr (mp_usr, 2);
15831
15832 custom_charset_3 = mask;
15833 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15834 break;
15835
15836 case 3:
15837 mp_reset_usr (mp_usr, 3);
15838
15839 custom_charset_4 = mask;
15840 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15841 break;
15842 }
15843
15844 mask = mask + str_pos + 1;
15845 }
15846 }
15847
15848 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15849 {
15850 if (maskpos > 0)
15851 {
15852 local_free (css_buf);
15853 local_free (data.root_css_buf);
15854 local_free (data.markov_css_buf);
15855
15856 local_free (masks[maskpos - 1]);
15857 }
15858
15859 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15860
15861 data.mask = mask;
15862 data.css_cnt = css_cnt;
15863 data.css_buf = css_buf;
15864
15865 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15866
15867 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15868
15869 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15870 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15871
15872 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15873
15874 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15875
15876 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15877 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15878
15879 data.root_css_buf = root_css_buf;
15880 data.markov_css_buf = markov_css_buf;
15881
15882 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15883
15884 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15885
15886 local_free (root_table_buf);
15887 local_free (markov_table_buf);
15888
15889 // args
15890
15891 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15892 {
15893 hc_device_param_t *device_param = &data.devices_param[device_id];
15894
15895 if (device_param->skipped) continue;
15896
15897 device_param->kernel_params_mp[0] = &device_param->d_combs;
15898 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15899 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15900
15901 device_param->kernel_params_mp_buf64[3] = 0;
15902 device_param->kernel_params_mp_buf32[4] = css_cnt;
15903 device_param->kernel_params_mp_buf32[5] = 0;
15904 device_param->kernel_params_mp_buf32[6] = 0;
15905 device_param->kernel_params_mp_buf32[7] = 0;
15906
15907 if (attack_mode == ATTACK_MODE_HYBRID1)
15908 {
15909 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15910 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15911 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15912 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15913 }
15914 else if (attack_mode == ATTACK_MODE_HYBRID2)
15915 {
15916 device_param->kernel_params_mp_buf32[5] = 0;
15917 device_param->kernel_params_mp_buf32[6] = 0;
15918 device_param->kernel_params_mp_buf32[7] = 0;
15919 }
15920
15921 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]);
15922 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]);
15923 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]);
15924
15925 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);
15926 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);
15927 }
15928 }
15929 else if (attack_mode == ATTACK_MODE_BF)
15930 {
15931 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15932
15933 if (increment)
15934 {
15935 for (uint i = 0; i < dictcnt; i++)
15936 {
15937 local_free (dictfiles[i]);
15938 }
15939
15940 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15941 {
15942 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15943
15944 if (l1_filename == NULL) break;
15945
15946 dictcnt++;
15947
15948 dictfiles[dictcnt - 1] = l1_filename;
15949 }
15950 }
15951 else
15952 {
15953 dictcnt++;
15954
15955 dictfiles[dictcnt - 1] = mask;
15956 }
15957
15958 if (dictcnt == 0)
15959 {
15960 log_error ("ERROR: Mask is too small");
15961
15962 return (-1);
15963 }
15964 }
15965 }
15966
15967 free (induction_dictionaries);
15968
15969 // induction_dictionaries_cnt = 0; // implied
15970
15971 if (attack_mode != ATTACK_MODE_BF)
15972 {
15973 if (keyspace == 0)
15974 {
15975 induction_dictionaries = scan_directory (induction_directory);
15976
15977 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15978 }
15979 }
15980
15981 if (induction_dictionaries_cnt)
15982 {
15983 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15984 }
15985
15986 /**
15987 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15988 */
15989 if (keyspace == 1)
15990 {
15991 if ((maskcnt > 1) || (dictcnt > 1))
15992 {
15993 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15994
15995 return (-1);
15996 }
15997 }
15998
15999 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16000 {
16001 char *subid = logfile_generate_subid ();
16002
16003 data.subid = subid;
16004
16005 logfile_sub_msg ("START");
16006
16007 data.devices_status = STATUS_INIT;
16008
16009 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16010 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16011 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16012
16013 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16014
16015 data.cpt_pos = 0;
16016
16017 data.cpt_start = time (NULL);
16018
16019 data.cpt_total = 0;
16020
16021 if (data.restore == 0)
16022 {
16023 rd->words_cur = skip;
16024
16025 skip = 0;
16026
16027 data.skip = 0;
16028 }
16029
16030 data.ms_paused = 0;
16031
16032 data.words_cur = rd->words_cur;
16033
16034 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16035 {
16036 hc_device_param_t *device_param = &data.devices_param[device_id];
16037
16038 if (device_param->skipped) continue;
16039
16040 device_param->speed_pos = 0;
16041
16042 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16043 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
16044 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
16045
16046 device_param->exec_pos = 0;
16047
16048 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16049
16050 device_param->kernel_power = device_param->kernel_power_user;
16051
16052 device_param->outerloop_pos = 0;
16053 device_param->outerloop_left = 0;
16054 device_param->innerloop_pos = 0;
16055 device_param->innerloop_left = 0;
16056
16057 // some more resets:
16058
16059 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16060
16061 device_param->pws_cnt = 0;
16062
16063 device_param->words_off = 0;
16064 device_param->words_done = 0;
16065 }
16066
16067 data.kernel_power_div = 0;
16068
16069 // figure out some workload
16070
16071 if (attack_mode == ATTACK_MODE_STRAIGHT)
16072 {
16073 if (data.wordlist_mode == WL_MODE_FILE)
16074 {
16075 char *dictfile = NULL;
16076
16077 if (induction_dictionaries_cnt)
16078 {
16079 dictfile = induction_dictionaries[0];
16080 }
16081 else
16082 {
16083 dictfile = dictfiles[dictpos];
16084 }
16085
16086 data.dictfile = dictfile;
16087
16088 logfile_sub_string (dictfile);
16089
16090 for (uint i = 0; i < rp_files_cnt; i++)
16091 {
16092 logfile_sub_var_string ("rulefile", rp_files[i]);
16093 }
16094
16095 FILE *fd2 = fopen (dictfile, "rb");
16096
16097 if (fd2 == NULL)
16098 {
16099 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16100
16101 return (-1);
16102 }
16103
16104 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16105
16106 fclose (fd2);
16107
16108 if (data.words_cnt == 0)
16109 {
16110 if (data.devices_status == STATUS_CRACKED) break;
16111 if (data.devices_status == STATUS_ABORTED) break;
16112
16113 dictpos++;
16114
16115 continue;
16116 }
16117 }
16118 }
16119 else if (attack_mode == ATTACK_MODE_COMBI)
16120 {
16121 char *dictfile = data.dictfile;
16122 char *dictfile2 = data.dictfile2;
16123
16124 logfile_sub_string (dictfile);
16125 logfile_sub_string (dictfile2);
16126
16127 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16128 {
16129 FILE *fd2 = fopen (dictfile, "rb");
16130
16131 if (fd2 == NULL)
16132 {
16133 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16134
16135 return (-1);
16136 }
16137
16138 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16139
16140 fclose (fd2);
16141 }
16142 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16143 {
16144 FILE *fd2 = fopen (dictfile2, "rb");
16145
16146 if (fd2 == NULL)
16147 {
16148 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16149
16150 return (-1);
16151 }
16152
16153 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16154
16155 fclose (fd2);
16156 }
16157
16158 if (data.words_cnt == 0)
16159 {
16160 if (data.devices_status == STATUS_CRACKED) break;
16161 if (data.devices_status == STATUS_ABORTED) break;
16162
16163 dictpos++;
16164
16165 continue;
16166 }
16167 }
16168 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16169 {
16170 char *dictfile = NULL;
16171
16172 if (induction_dictionaries_cnt)
16173 {
16174 dictfile = induction_dictionaries[0];
16175 }
16176 else
16177 {
16178 dictfile = dictfiles[dictpos];
16179 }
16180
16181 data.dictfile = dictfile;
16182
16183 char *mask = data.mask;
16184
16185 logfile_sub_string (dictfile);
16186 logfile_sub_string (mask);
16187
16188 FILE *fd2 = fopen (dictfile, "rb");
16189
16190 if (fd2 == NULL)
16191 {
16192 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16193
16194 return (-1);
16195 }
16196
16197 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16198
16199 fclose (fd2);
16200
16201 if (data.words_cnt == 0)
16202 {
16203 if (data.devices_status == STATUS_CRACKED) break;
16204 if (data.devices_status == STATUS_ABORTED) break;
16205
16206 dictpos++;
16207
16208 continue;
16209 }
16210 }
16211 else if (attack_mode == ATTACK_MODE_BF)
16212 {
16213 local_free (css_buf);
16214 local_free (data.root_css_buf);
16215 local_free (data.markov_css_buf);
16216
16217 char *mask = dictfiles[dictpos];
16218
16219 logfile_sub_string (mask);
16220
16221 // base
16222
16223 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16224
16225 if (opts_type & OPTS_TYPE_PT_UNICODE)
16226 {
16227 uint css_cnt_unicode = css_cnt * 2;
16228
16229 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16230
16231 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16232 {
16233 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16234
16235 css_buf_unicode[j + 1].cs_buf[0] = 0;
16236 css_buf_unicode[j + 1].cs_len = 1;
16237 }
16238
16239 free (css_buf);
16240
16241 css_buf = css_buf_unicode;
16242 css_cnt = css_cnt_unicode;
16243 }
16244
16245 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16246
16247 uint mask_min = pw_min;
16248 uint mask_max = pw_max;
16249
16250 if (opts_type & OPTS_TYPE_PT_UNICODE)
16251 {
16252 mask_min *= 2;
16253 mask_max *= 2;
16254 }
16255
16256 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16257 {
16258 if (css_cnt < mask_min)
16259 {
16260 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16261 }
16262
16263 if (css_cnt > mask_max)
16264 {
16265 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16266 }
16267
16268 // skip to next mask
16269
16270 dictpos++;
16271
16272 rd->dictpos = dictpos;
16273
16274 logfile_sub_msg ("STOP");
16275
16276 continue;
16277 }
16278
16279 uint save_css_cnt = css_cnt;
16280
16281 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16282 {
16283 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16284 {
16285 uint salt_len = (uint) data.salts_buf[0].salt_len;
16286 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16287
16288 uint css_cnt_salt = css_cnt + salt_len;
16289
16290 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16291
16292 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16293
16294 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16295 {
16296 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16297 css_buf_salt[j].cs_len = 1;
16298 }
16299
16300 free (css_buf);
16301
16302 css_buf = css_buf_salt;
16303 css_cnt = css_cnt_salt;
16304 }
16305 }
16306
16307 data.mask = mask;
16308 data.css_cnt = css_cnt;
16309 data.css_buf = css_buf;
16310
16311 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16312
16313 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16314
16315 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16316
16317 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16318 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16319
16320 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16321
16322 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16323
16324 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16325 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16326
16327 data.root_css_buf = root_css_buf;
16328 data.markov_css_buf = markov_css_buf;
16329
16330 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16331
16332 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16333
16334 local_free (root_table_buf);
16335 local_free (markov_table_buf);
16336
16337 // copy + args
16338
16339 uint css_cnt_l = css_cnt;
16340 uint css_cnt_r;
16341
16342 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16343 {
16344 if (save_css_cnt < 6)
16345 {
16346 css_cnt_r = 1;
16347 }
16348 else if (save_css_cnt == 6)
16349 {
16350 css_cnt_r = 2;
16351 }
16352 else
16353 {
16354 if (opts_type & OPTS_TYPE_PT_UNICODE)
16355 {
16356 if (save_css_cnt == 8 || save_css_cnt == 10)
16357 {
16358 css_cnt_r = 2;
16359 }
16360 else
16361 {
16362 css_cnt_r = 4;
16363 }
16364 }
16365 else
16366 {
16367 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16368 {
16369 css_cnt_r = 3;
16370 }
16371 else
16372 {
16373 css_cnt_r = 4;
16374 }
16375 }
16376 }
16377 }
16378 else
16379 {
16380 css_cnt_r = 1;
16381
16382 /* unfinished code?
16383 int sum = css_buf[css_cnt_r - 1].cs_len;
16384
16385 for (uint i = 1; i < 4 && i < css_cnt; i++)
16386 {
16387 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16388
16389 css_cnt_r++;
16390
16391 sum *= css_buf[css_cnt_r - 1].cs_len;
16392 }
16393 */
16394 }
16395
16396 css_cnt_l -= css_cnt_r;
16397
16398 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16399
16400 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16401 {
16402 hc_device_param_t *device_param = &data.devices_param[device_id];
16403
16404 if (device_param->skipped) continue;
16405
16406 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16407 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16408 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16409
16410 device_param->kernel_params_mp_l_buf64[3] = 0;
16411 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16412 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16413 device_param->kernel_params_mp_l_buf32[6] = 0;
16414 device_param->kernel_params_mp_l_buf32[7] = 0;
16415 device_param->kernel_params_mp_l_buf32[8] = 0;
16416
16417 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16418 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16419 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16420 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16421
16422 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16423 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16424 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16425
16426 device_param->kernel_params_mp_r_buf64[3] = 0;
16427 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16428 device_param->kernel_params_mp_r_buf32[5] = 0;
16429 device_param->kernel_params_mp_r_buf32[6] = 0;
16430 device_param->kernel_params_mp_r_buf32[7] = 0;
16431
16432 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]);
16433 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]);
16434 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]);
16435
16436 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]);
16437 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]);
16438 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]);
16439
16440 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);
16441 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);
16442 }
16443 }
16444
16445 u64 words_base = data.words_cnt;
16446
16447 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16448 {
16449 if (data.kernel_rules_cnt)
16450 {
16451 words_base /= data.kernel_rules_cnt;
16452 }
16453 }
16454 else if (data.attack_kern == ATTACK_KERN_COMBI)
16455 {
16456 if (data.combs_cnt)
16457 {
16458 words_base /= data.combs_cnt;
16459 }
16460 }
16461 else if (data.attack_kern == ATTACK_KERN_BF)
16462 {
16463 if (data.bfs_cnt)
16464 {
16465 words_base /= data.bfs_cnt;
16466 }
16467 }
16468
16469 data.words_base = words_base;
16470
16471 if (keyspace == 1)
16472 {
16473 log_info ("%llu", (unsigned long long int) words_base);
16474
16475 return (0);
16476 }
16477
16478 if (data.words_cur > data.words_base)
16479 {
16480 log_error ("ERROR: restore value greater keyspace");
16481
16482 return (-1);
16483 }
16484
16485 if (data.words_cur)
16486 {
16487 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16488 {
16489 for (uint i = 0; i < data.salts_cnt; i++)
16490 {
16491 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16492 }
16493 }
16494 else if (data.attack_kern == ATTACK_KERN_COMBI)
16495 {
16496 for (uint i = 0; i < data.salts_cnt; i++)
16497 {
16498 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16499 }
16500 }
16501 else if (data.attack_kern == ATTACK_KERN_BF)
16502 {
16503 for (uint i = 0; i < data.salts_cnt; i++)
16504 {
16505 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16506 }
16507 }
16508 }
16509
16510 /*
16511 * Inform user about possible slow speeds
16512 */
16513
16514 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16515 {
16516 if (data.words_base < kernel_power_all)
16517 {
16518 if (quiet == 0)
16519 {
16520 log_info ("");
16521 log_info ("ATTENTION!");
16522 log_info (" The wordlist or mask you are using is too small.");
16523 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16524 log_info (" The cracking speed will drop.");
16525 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16526 log_info ("");
16527 }
16528 }
16529 }
16530
16531 /*
16532 * Update loopback file
16533 */
16534
16535 if (loopback == 1)
16536 {
16537 time_t now;
16538
16539 time (&now);
16540
16541 uint random_num = get_random_num (0, 9999);
16542
16543 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16544
16545 data.loopback_file = loopback_file;
16546 }
16547
16548 /*
16549 * Update dictionary statistic
16550 */
16551
16552 if (keyspace == 0)
16553 {
16554 dictstat_fp = fopen (dictstat, "wb");
16555
16556 if (dictstat_fp)
16557 {
16558 lock_file (dictstat_fp);
16559
16560 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16561
16562 fclose (dictstat_fp);
16563 }
16564 }
16565
16566 data.devices_status = STATUS_RUNNING;
16567
16568 if (initial_restore_done == 0)
16569 {
16570 if (data.restore_disable == 0) cycle_restore ();
16571
16572 initial_restore_done = 1;
16573 }
16574
16575 hc_timer_set (&data.timer_running);
16576
16577 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16578 {
16579 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16580 {
16581 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16582 if (quiet == 0) fflush (stdout);
16583 }
16584 }
16585 else if (wordlist_mode == WL_MODE_STDIN)
16586 {
16587 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16588 if (data.quiet == 0) log_info ("");
16589 }
16590
16591 time_t runtime_start;
16592
16593 time (&runtime_start);
16594
16595 data.runtime_start = runtime_start;
16596
16597 /**
16598 * create cracker threads
16599 */
16600
16601 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16602
16603 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16604 {
16605 hc_device_param_t *device_param = &devices_param[device_id];
16606
16607 if (wordlist_mode == WL_MODE_STDIN)
16608 {
16609 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16610 }
16611 else
16612 {
16613 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16614 }
16615 }
16616
16617 // wait for crack threads to exit
16618
16619 hc_thread_wait (data.devices_cnt, c_threads);
16620
16621 local_free (c_threads);
16622
16623 data.restore = 0;
16624
16625 // finalize task
16626
16627 logfile_sub_var_uint ("status-after-work", data.devices_status);
16628
16629 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16630
16631 if (data.devices_status == STATUS_CRACKED) break;
16632 if (data.devices_status == STATUS_ABORTED) break;
16633
16634 if (data.devices_status == STATUS_BYPASS)
16635 {
16636 data.devices_status = STATUS_RUNNING;
16637 }
16638
16639 if (induction_dictionaries_cnt)
16640 {
16641 unlink (induction_dictionaries[0]);
16642 }
16643
16644 free (induction_dictionaries);
16645
16646 if (attack_mode != ATTACK_MODE_BF)
16647 {
16648 induction_dictionaries = scan_directory (induction_directory);
16649
16650 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16651 }
16652
16653 if (benchmark == 0)
16654 {
16655 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16656 {
16657 if (quiet == 0) clear_prompt ();
16658
16659 if (quiet == 0) log_info ("");
16660
16661 if (status == 1)
16662 {
16663 status_display ();
16664 }
16665 else
16666 {
16667 if (quiet == 0) status_display ();
16668 }
16669
16670 if (quiet == 0) log_info ("");
16671 }
16672 }
16673
16674 if (attack_mode == ATTACK_MODE_BF)
16675 {
16676 dictpos++;
16677
16678 rd->dictpos = dictpos;
16679 }
16680 else
16681 {
16682 if (induction_dictionaries_cnt)
16683 {
16684 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16685 }
16686 else
16687 {
16688 dictpos++;
16689
16690 rd->dictpos = dictpos;
16691 }
16692 }
16693
16694 time_t runtime_stop;
16695
16696 time (&runtime_stop);
16697
16698 data.runtime_stop = runtime_stop;
16699
16700 logfile_sub_uint (runtime_start);
16701 logfile_sub_uint (runtime_stop);
16702
16703 logfile_sub_msg ("STOP");
16704
16705 global_free (subid);
16706 }
16707
16708 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16709
16710 if (data.devices_status == STATUS_CRACKED) break;
16711 if (data.devices_status == STATUS_ABORTED) break;
16712 if (data.devices_status == STATUS_QUIT) break;
16713
16714 if (data.devices_status == STATUS_BYPASS)
16715 {
16716 data.devices_status = STATUS_RUNNING;
16717 }
16718 }
16719
16720 // 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
16721
16722 if (attack_mode == ATTACK_MODE_STRAIGHT)
16723 {
16724 if (data.wordlist_mode == WL_MODE_FILE)
16725 {
16726 if (data.dictfile == NULL)
16727 {
16728 if (dictfiles != NULL)
16729 {
16730 data.dictfile = dictfiles[0];
16731
16732 hc_timer_set (&data.timer_running);
16733 }
16734 }
16735 }
16736 }
16737 // NOTE: combi is okay because it is already set beforehand
16738 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16739 {
16740 if (data.dictfile == NULL)
16741 {
16742 if (dictfiles != NULL)
16743 {
16744 hc_timer_set (&data.timer_running);
16745
16746 data.dictfile = dictfiles[0];
16747 }
16748 }
16749 }
16750 else if (attack_mode == ATTACK_MODE_BF)
16751 {
16752 if (data.mask == NULL)
16753 {
16754 hc_timer_set (&data.timer_running);
16755
16756 data.mask = masks[0];
16757 }
16758 }
16759
16760 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16761 {
16762 data.devices_status = STATUS_EXHAUSTED;
16763 }
16764
16765 // if cracked / aborted remove last induction dictionary
16766
16767 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16768 {
16769 struct stat induct_stat;
16770
16771 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16772 {
16773 unlink (induction_dictionaries[file_pos]);
16774 }
16775 }
16776
16777 // wait for non-interactive threads
16778
16779 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16780 {
16781 hc_thread_wait (1, &ni_threads[thread_idx]);
16782 }
16783
16784 local_free (ni_threads);
16785
16786 // wait for interactive threads
16787
16788 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16789 {
16790 hc_thread_wait (1, &i_thread);
16791 }
16792
16793 // we dont need restore file anymore
16794 if (data.restore_disable == 0)
16795 {
16796 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16797 {
16798 unlink (eff_restore_file);
16799 unlink (new_restore_file);
16800 }
16801 else
16802 {
16803 cycle_restore ();
16804 }
16805 }
16806
16807 // finally save left hashes
16808
16809 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16810 {
16811 save_hash ();
16812 }
16813
16814 /**
16815 * Clean up
16816 */
16817
16818 if (benchmark == 1)
16819 {
16820 status_benchmark ();
16821
16822 log_info ("");
16823 }
16824 else
16825 {
16826 if (quiet == 0) clear_prompt ();
16827
16828 if (quiet == 0) log_info ("");
16829
16830 if (status == 1)
16831 {
16832 status_display ();
16833 }
16834 else
16835 {
16836 if (quiet == 0) status_display ();
16837 }
16838
16839 if (quiet == 0) log_info ("");
16840 }
16841
16842 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16843 {
16844 hc_device_param_t *device_param = &data.devices_param[device_id];
16845
16846 if (device_param->skipped) continue;
16847
16848 local_free (device_param->result);
16849
16850 local_free (device_param->combs_buf);
16851
16852 local_free (device_param->hooks_buf);
16853
16854 local_free (device_param->device_name);
16855
16856 local_free (device_param->device_name_chksum);
16857
16858 local_free (device_param->device_version);
16859
16860 local_free (device_param->driver_version);
16861
16862 if (device_param->pws_buf) myfree (device_param->pws_buf);
16863 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16864 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16865 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16866 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16867 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16868 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16869 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16870 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16871 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16872 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16873 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16874 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16875 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16876 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16877 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16878 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16879 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16880 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16881 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16882 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16883 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16884 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16885 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16886 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16887 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16888 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16889 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16890 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16891
16892 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16893 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16894 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16895 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16896 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16897 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16898 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16899 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16900 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16901 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16902
16903 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16904 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16905 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16906
16907 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16908 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16909 }
16910
16911 // reset default fan speed
16912
16913 #ifdef HAVE_HWMON
16914 if (gpu_temp_disable == 0)
16915 {
16916 #ifdef HAVE_ADL
16917 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16918 {
16919 hc_thread_mutex_lock (mux_adl);
16920
16921 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16922 {
16923 hc_device_param_t *device_param = &data.devices_param[device_id];
16924
16925 if (device_param->skipped) continue;
16926
16927 if (data.hm_device[device_id].fan_supported == 1)
16928 {
16929 int fanspeed = temp_retain_fanspeed_value[device_id];
16930
16931 if (fanspeed == -1) continue;
16932
16933 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16934
16935 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16936 }
16937 }
16938
16939 hc_thread_mutex_unlock (mux_adl);
16940 }
16941 #endif // HAVE_ADL
16942 }
16943
16944 #ifdef HAVE_ADL
16945 // reset power tuning
16946
16947 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16948 {
16949 hc_thread_mutex_lock (mux_adl);
16950
16951 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16952 {
16953 hc_device_param_t *device_param = &data.devices_param[device_id];
16954
16955 if (device_param->skipped) continue;
16956
16957 if (data.hm_device[device_id].od_version == 6)
16958 {
16959 // check powertune capabilities first, if not available then skip device
16960
16961 int powertune_supported = 0;
16962
16963 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16964 {
16965 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16966
16967 return (-1);
16968 }
16969
16970 if (powertune_supported != 0)
16971 {
16972 // powercontrol settings
16973
16974 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)
16975 {
16976 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16977
16978 return (-1);
16979 }
16980
16981 // clocks
16982
16983 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16984
16985 performance_state->iNumberOfPerformanceLevels = 2;
16986
16987 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16988 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16989 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16990 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16991
16992 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)
16993 {
16994 log_info ("ERROR: Failed to restore ADL performance state");
16995
16996 return (-1);
16997 }
16998
16999 local_free (performance_state);
17000 }
17001 }
17002 }
17003
17004 hc_thread_mutex_unlock (mux_adl);
17005 }
17006 #endif // HAVE_ADL
17007
17008 if (gpu_temp_disable == 0)
17009 {
17010 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17011 if (data.hm_nv)
17012 {
17013 #if defined(LINUX) && defined(HAVE_NVML)
17014
17015 hm_NVML_nvmlShutdown (data.hm_nv);
17016
17017 nvml_close (data.hm_nv);
17018
17019 #elif defined(WIN) && (HAVE_NVAPI)
17020
17021 hm_NvAPI_Unload (data.hm_nv);
17022
17023 nvapi_close (data.hm_nv);
17024
17025 #endif
17026
17027 data.hm_nv = NULL;
17028 }
17029 #endif
17030
17031 #ifdef HAVE_ADL
17032 if (data.hm_amd)
17033 {
17034 hm_ADL_Main_Control_Destroy (data.hm_amd);
17035
17036 adl_close (data.hm_amd);
17037 data.hm_amd = NULL;
17038 }
17039 #endif
17040 }
17041 #endif // HAVE_HWMON
17042
17043 // free memory
17044
17045 local_free (masks);
17046
17047 local_free (dictstat_base);
17048
17049 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17050 {
17051 pot_t *pot_ptr = &pot[pot_pos];
17052
17053 hash_t *hash = &pot_ptr->hash;
17054
17055 local_free (hash->digest);
17056
17057 if (isSalted)
17058 {
17059 local_free (hash->salt);
17060 }
17061 }
17062
17063 local_free (pot);
17064
17065 local_free (all_kernel_rules_cnt);
17066 local_free (all_kernel_rules_buf);
17067
17068 local_free (wl_data->buf);
17069 local_free (wl_data);
17070
17071 local_free (bitmap_s1_a);
17072 local_free (bitmap_s1_b);
17073 local_free (bitmap_s1_c);
17074 local_free (bitmap_s1_d);
17075 local_free (bitmap_s2_a);
17076 local_free (bitmap_s2_b);
17077 local_free (bitmap_s2_c);
17078 local_free (bitmap_s2_d);
17079
17080 #ifdef HAVE_HWMON
17081 local_free (temp_retain_fanspeed_value);
17082 #ifdef HAVE_ADL
17083 local_free (od_clock_mem_status);
17084 local_free (od_power_control_status);
17085 #endif // ADL
17086 #endif
17087
17088 global_free (devices_param);
17089
17090 global_free (kernel_rules_buf);
17091
17092 global_free (root_css_buf);
17093 global_free (markov_css_buf);
17094
17095 global_free (digests_buf);
17096 global_free (digests_shown);
17097 global_free (digests_shown_tmp);
17098
17099 global_free (salts_buf);
17100 global_free (salts_shown);
17101
17102 global_free (esalts_buf);
17103
17104 global_free (words_progress_done);
17105 global_free (words_progress_rejected);
17106 global_free (words_progress_restored);
17107
17108 if (pot_fp) fclose (pot_fp);
17109
17110 if (data.devices_status == STATUS_QUIT) break;
17111 }
17112
17113 // destroy others mutex
17114
17115 hc_thread_mutex_delete (mux_dispatcher);
17116 hc_thread_mutex_delete (mux_counter);
17117 hc_thread_mutex_delete (mux_display);
17118 hc_thread_mutex_delete (mux_adl);
17119
17120 // free memory
17121
17122 local_free (eff_restore_file);
17123 local_free (new_restore_file);
17124
17125 local_free (rd);
17126
17127 // tuning db
17128
17129 tuning_db_destroy (tuning_db);
17130
17131 // loopback
17132
17133 local_free (loopback_file);
17134
17135 if (loopback == 1) unlink (loopback_file);
17136
17137 // induction directory
17138
17139 if (induction_dir == NULL)
17140 {
17141 if (attack_mode != ATTACK_MODE_BF)
17142 {
17143 if (rmdir (induction_directory) == -1)
17144 {
17145 if (errno == ENOENT)
17146 {
17147 // good, we can ignore
17148 }
17149 else if (errno == ENOTEMPTY)
17150 {
17151 // good, we can ignore
17152 }
17153 else
17154 {
17155 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17156
17157 return (-1);
17158 }
17159 }
17160
17161 local_free (induction_directory);
17162 }
17163 }
17164
17165 // outfile-check directory
17166
17167 if (outfile_check_dir == NULL)
17168 {
17169 if (rmdir (outfile_check_directory) == -1)
17170 {
17171 if (errno == ENOENT)
17172 {
17173 // good, we can ignore
17174 }
17175 else if (errno == ENOTEMPTY)
17176 {
17177 // good, we can ignore
17178 }
17179 else
17180 {
17181 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17182
17183 return (-1);
17184 }
17185 }
17186
17187 local_free (outfile_check_directory);
17188 }
17189
17190 time_t proc_stop;
17191
17192 time (&proc_stop);
17193
17194 logfile_top_uint (proc_start);
17195 logfile_top_uint (proc_stop);
17196
17197 logfile_top_msg ("STOP");
17198
17199 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17200 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17201
17202 if (data.ocl) ocl_close (data.ocl);
17203
17204 if (data.devices_status == STATUS_ABORTED) return 2;
17205 if (data.devices_status == STATUS_QUIT) return 2;
17206 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17207 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17208 if (data.devices_status == STATUS_CRACKED) return 0;
17209
17210 return -1;
17211 }
Hashcat additions to support pwdhash