projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Fix for 0H/s issue on different algorithms
[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 100
37 #define RESTORE 0
38 #define RESTORE_TIMER 60
39 #define RESTORE_DISABLE 0
40 #define STATUS 0
41 #define STATUS_TIMER 10
42 #define STATUS_AUTOMAT 0
43 #define LOOPBACK 0
44 #define WEAK_HASH_THRESHOLD 100
45 #define SHOW 0
46 #define LEFT 0
47 #define USERNAME 0
48 #define REMOVE 0
49 #define REMOVE_TIMER 60
50 #define SKIP 0
51 #define LIMIT 0
52 #define KEYSPACE 0
53 #define POTFILE_DISABLE 0
54 #define DEBUG_MODE 0
55 #define RP_GEN 0
56 #define RP_GEN_FUNC_MIN 1
57 #define RP_GEN_FUNC_MAX 4
58 #define RP_GEN_SEED 0
59 #define RULE_BUF_L ":"
60 #define RULE_BUF_R ":"
61 #define FORCE 0
62 #define RUNTIME 0
63 #define HEX_CHARSET 0
64 #define HEX_SALT 0
65 #define HEX_WORDLIST 0
66 #define OUTFILE_FORMAT 3
67 #define OUTFILE_AUTOHEX 1
68 #define OUTFILE_CHECK_TIMER 5
69 #define ATTACK_MODE 0
70 #define HASH_MODE 0
71 #define SEGMENT_SIZE 32
72 #define INCREMENT 0
73 #define INCREMENT_MIN 1
74 #define INCREMENT_MAX PW_MAX
75 #define SEPARATOR ':'
76 #define BITMAP_MIN 16
77 #define BITMAP_MAX 24
78 #define GPU_TEMP_DISABLE 0
79 #define GPU_TEMP_ABORT 90
80 #define GPU_TEMP_RETAIN 80
81 #define WORKLOAD_PROFILE 2
82 #define KERNEL_ACCEL 0
83 #define KERNEL_LOOPS 0
84 #define KERNEL_RULES 1024
85 #define KERNEL_COMBS 1024
86 #define KERNEL_BFS 1024
87 #define KERNEL_THREADS 64
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 135
152
153 #define global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
168 {
169 900,
170 0,
171 5100,
172 100,
173 1400,
174 10800,
175 1700,
176 5000,
177 10100,
178 6000,
179 6100,
180 6900,
181 11700,
182 11800,
183 400,
184 8900,
185 11900,
186 12000,
187 10900,
188 12100,
189 23,
190 2500,
191 5300,
192 5400,
193 5500,
194 5600,
195 7300,
196 7500,
197 13100,
198 8300,
199 11100,
200 11200,
201 11400,
202 121,
203 2611,
204 2711,
205 2811,
206 8400,
207 11,
208 2612,
209 7900,
210 21,
211 11000,
212 124,
213 10000,
214 3711,
215 7600,
216 12,
217 131,
218 132,
219 1731,
220 200,
221 300,
222 3100,
223 112,
224 12300,
225 8000,
226 141,
227 1441,
228 1600,
229 12600,
230 1421,
231 101,
232 111,
233 1711,
234 3000,
235 1000,
236 1100,
237 2100,
238 12800,
239 1500,
240 12400,
241 500,
242 3200,
243 7400,
244 1800,
245 122,
246 1722,
247 7100,
248 6300,
249 6700,
250 6400,
251 6500,
252 2400,
253 2410,
254 5700,
255 9200,
256 9300,
257 22,
258 501,
259 5800,
260 8100,
261 8500,
262 7200,
263 9900,
264 7700,
265 7800,
266 10300,
267 8600,
268 8700,
269 9100,
270 133,
271 11600,
272 12500,
273 13000,
274 13200,
275 13300,
276 6211,
277 6221,
278 6231,
279 6241,
280 8800,
281 12900,
282 12200,
283 9700,
284 9710,
285 9800,
286 9810,
287 9400,
288 9500,
289 9600,
290 10400,
291 10410,
292 10500,
293 10600,
294 10700,
295 9000,
296 5200,
297 6800,
298 6600,
299 8200,
300 11300,
301 12700,
302 13400,
303 125
304 };
305
306 /**
307 * types
308 */
309
310 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
311
312 /**
313 * globals
314 */
315
316 static unsigned int full01 = 0x01010101;
317 static unsigned int full80 = 0x80808080;
318
319 int SUPPRESS_OUTPUT = 0;
320
321 hc_thread_mutex_t mux_adl;
322 hc_thread_mutex_t mux_counter;
323 hc_thread_mutex_t mux_dispatcher;
324 hc_thread_mutex_t mux_display;
325
326 hc_global_data_t data;
327
328 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
329
330 const char *USAGE_MINI[] =
331 {
332 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
333 "",
334 "Try --help for more help.",
335 NULL
336 };
337
338 const char *USAGE_BIG[] =
339 {
340 "%s, advanced password recovery",
341 "",
342 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
343 "",
344 "=======",
345 "Options",
346 "=======",
347 "",
348 "* General:",
349 "",
350 " -m, --hash-type=NUM Hash-type, see references below",
351 " -a, --attack-mode=NUM Attack-mode, see references below",
352 " -V, --version Print version",
353 " -h, --help Print help",
354 " --quiet Suppress output",
355 "",
356 "* Misc:",
357 "",
358 " --hex-charset Assume charset is given in hex",
359 " --hex-salt Assume salt is given in hex",
360 " --hex-wordlist Assume words in wordlist is given in hex",
361 " --force Ignore warnings",
362 " --status Enable automatic update of the status-screen",
363 " --status-timer=NUM Seconds between status-screen update",
364 " --status-automat Display the status view in a machine readable format",
365 " --loopback Add new plains to induct directory",
366 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
367 "",
368 "* Markov:",
369 "",
370 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
371 " --markov-disable Disables markov-chains, emulates classic brute-force",
372 " --markov-classic Enables classic markov-chains, no per-position enhancement",
373 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
374 "",
375 "* Session:",
376 "",
377 " --runtime=NUM Abort session after NUM seconds of runtime",
378 " --session=STR Define specific session name",
379 " --restore Restore session from --session",
380 " --restore-disable Do not write restore file",
381 "",
382 "* Files:",
383 "",
384 " -o, --outfile=FILE Define outfile for recovered hash",
385 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
386 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
387 " --outfile-check-timer=NUM Seconds between outfile checks",
388 " -p, --separator=CHAR Separator char for hashlists and outfile",
389 " --show Show cracked passwords only",
390 " --left Show un-cracked passwords only",
391 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
392 " --remove Enable remove of hash once it is cracked",
393 " --remove-timer=NUM Update input hash file each NUM seconds",
394 " --potfile-disable Do not write potfile",
395 " --potfile-path Specific path to potfile",
396 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
397 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
398 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
399 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
400 " --logfile-disable Disable the logfile",
401 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
402 "",
403 "* Resources:",
404 "",
405 " -b, --benchmark Run benchmark",
406 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
407 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
408 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
409 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
410 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
411 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
412 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
413 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
414 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
415 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
416 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
417 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
418 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
419 #ifdef HAVE_HWMON
420 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
421 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
422 #ifdef HAVE_ADL
423 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
424 #endif
425 #endif
426 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
427 "",
428 "* Distributed:",
429 "",
430 " -s, --skip=NUM Skip number of words",
431 " -l, --limit=NUM Limit number of words",
432 " --keyspace Show keyspace base:mod values and quit",
433 "",
434 "* Rules:",
435 "",
436 " -j, --rule-left=RULE Single rule applied to each word from left dict",
437 " -k, --rule-right=RULE Single rule applied to each word from right dict",
438 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
439 " -g, --generate-rules=NUM Generate NUM random rules",
440 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
441 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
442 " --generate-rules-seed=NUM Force RNG seed to NUM",
443 "",
444 "* Custom charsets:",
445 "",
446 " -1, --custom-charset1=CS User-defined charsets",
447 " -2, --custom-charset2=CS Example:",
448 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
449 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
450 "",
451 "* Increment:",
452 "",
453 " -i, --increment Enable increment mode",
454 " --increment-min=NUM Start incrementing at NUM",
455 " --increment-max=NUM Stop incrementing at NUM",
456 "",
457 "==========",
458 "References",
459 "==========",
460 "",
461 "* Workload Profile:",
462 "",
463 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
464 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
465 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
466 "",
467 "* OpenCL device-types:",
468 "",
469 " 1 = CPU devices",
470 " 2 = GPU devices",
471 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
472 "",
473 "* Outfile Formats:",
474 "",
475 " 1 = hash[:salt]",
476 " 2 = plain",
477 " 3 = hash[:salt]:plain",
478 " 4 = hex_plain",
479 " 5 = hash[:salt]:hex_plain",
480 " 6 = plain:hex_plain",
481 " 7 = hash[:salt]:plain:hex_plain",
482 " 8 = crackpos",
483 " 9 = hash[:salt]:crackpos",
484 " 10 = plain:crackpos",
485 " 11 = hash[:salt]:plain:crackpos",
486 " 12 = hex_plain:crackpos",
487 " 13 = hash[:salt]:hex_plain:crackpos",
488 " 14 = plain:hex_plain:crackpos",
489 " 15 = hash[:salt]:plain:hex_plain:crackpos",
490 "",
491 "* Debug mode output formats (for hybrid mode only, by using rules):",
492 "",
493 " 1 = save finding rule",
494 " 2 = save original word",
495 " 3 = save original word and finding rule",
496 " 4 = save original word, finding rule and modified plain",
497 "",
498 "* Built-in charsets:",
499 "",
500 " ?l = abcdefghijklmnopqrstuvwxyz",
501 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
502 " ?d = 0123456789",
503 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
504 " ?a = ?l?u?d?s",
505 " ?b = 0x00 - 0xff",
506 "",
507 "* Attack modes:",
508 "",
509 " 0 = Straight",
510 " 1 = Combination",
511 " 3 = Brute-force",
512 " 6 = Hybrid dict + mask",
513 " 7 = Hybrid mask + dict",
514 "",
515 "* Hash types:",
516 "",
517 "[[ Roll-your-own: Raw Hashes ]]",
518 "",
519 " 900 = MD4",
520 " 0 = MD5",
521 " 5100 = Half MD5",
522 " 100 = SHA1",
523 " 10800 = SHA-384",
524 " 1400 = SHA-256",
525 " 1700 = SHA-512",
526 " 5000 = SHA-3(Keccak)",
527 " 10100 = SipHash",
528 " 6000 = RipeMD160",
529 " 6100 = Whirlpool",
530 " 6900 = GOST R 34.11-94",
531 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
532 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
533 "",
534 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
535 "",
536 " 10 = md5($pass.$salt)",
537 " 20 = md5($salt.$pass)",
538 " 30 = md5(unicode($pass).$salt)",
539 " 40 = md5($salt.unicode($pass))",
540 " 3800 = md5($salt.$pass.$salt)",
541 " 3710 = md5($salt.md5($pass))",
542 " 2600 = md5(md5($pass)",
543 " 4300 = md5(strtoupper(md5($pass)))",
544 " 4400 = md5(sha1($pass))",
545 " 110 = sha1($pass.$salt)",
546 " 120 = sha1($salt.$pass)",
547 " 130 = sha1(unicode($pass).$salt)",
548 " 140 = sha1($salt.unicode($pass))",
549 " 4500 = sha1(sha1($pass)",
550 " 4700 = sha1(md5($pass))",
551 " 4900 = sha1($salt.$pass.$salt)",
552 " 1410 = sha256($pass.$salt)",
553 " 1420 = sha256($salt.$pass)",
554 " 1430 = sha256(unicode($pass).$salt)",
555 " 1440 = sha256($salt.unicode($pass))",
556 " 1710 = sha512($pass.$salt)",
557 " 1720 = sha512($salt.$pass)",
558 " 1730 = sha512(unicode($pass).$salt)",
559 " 1740 = sha512($salt.unicode($pass))",
560 "",
561 "[[ Roll-your-own: Authenticated Hashes ]]",
562 "",
563 " 50 = HMAC-MD5 (key = $pass)",
564 " 60 = HMAC-MD5 (key = $salt)",
565 " 150 = HMAC-SHA1 (key = $pass)",
566 " 160 = HMAC-SHA1 (key = $salt)",
567 " 1450 = HMAC-SHA256 (key = $pass)",
568 " 1460 = HMAC-SHA256 (key = $salt)",
569 " 1750 = HMAC-SHA512 (key = $pass)",
570 " 1760 = HMAC-SHA512 (key = $salt)",
571 "",
572 "[[ Generic KDF ]]",
573 "",
574 " 400 = phpass",
575 " 8900 = scrypt",
576 " 11900 = PBKDF2-HMAC-MD5",
577 " 12000 = PBKDF2-HMAC-SHA1",
578 " 10900 = PBKDF2-HMAC-SHA256",
579 " 12100 = PBKDF2-HMAC-SHA512",
580 "",
581 "[[ Network protocols, Challenge-Response ]]",
582 "",
583 " 23 = Skype",
584 " 2500 = WPA/WPA2",
585 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
586 " 5300 = IKE-PSK MD5",
587 " 5400 = IKE-PSK SHA1",
588 " 5500 = NetNTLMv1",
589 " 5500 = NetNTLMv1 + ESS",
590 " 5600 = NetNTLMv2",
591 " 7300 = IPMI2 RAKP HMAC-SHA1",
592 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
593 " 8300 = DNSSEC (NSEC3)",
594 " 10200 = Cram MD5",
595 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
596 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
597 " 11400 = SIP digest authentication (MD5)",
598 " 13100 = Kerberos 5 TGS-REP etype 23",
599 "",
600 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
601 "",
602 " 121 = SMF (Simple Machines Forum)",
603 " 400 = phpBB3",
604 " 2611 = vBulletin < v3.8.5",
605 " 2711 = vBulletin > v3.8.5",
606 " 2811 = MyBB",
607 " 2811 = IPB (Invison Power Board)",
608 " 8400 = WBB3 (Woltlab Burning Board)",
609 " 11 = Joomla < 2.5.18",
610 " 400 = Joomla > 2.5.18",
611 " 400 = Wordpress",
612 " 2612 = PHPS",
613 " 7900 = Drupal7",
614 " 21 = osCommerce",
615 " 21 = xt:Commerce",
616 " 11000 = PrestaShop",
617 " 124 = Django (SHA-1)",
618 " 10000 = Django (PBKDF2-SHA256)",
619 " 3711 = Mediawiki B type",
620 " 7600 = Redmine",
621 "",
622 "[[ Database Server ]]",
623 "",
624 " 12 = PostgreSQL",
625 " 131 = MSSQL(2000)",
626 " 132 = MSSQL(2005)",
627 " 1731 = MSSQL(2012)",
628 " 1731 = MSSQL(2014)",
629 " 200 = MySQL323",
630 " 300 = MySQL4.1/MySQL5",
631 " 3100 = Oracle H: Type (Oracle 7+)",
632 " 112 = Oracle S: Type (Oracle 11+)",
633 " 12300 = Oracle T: Type (Oracle 12+)",
634 " 8000 = Sybase ASE",
635 "",
636 "[[ HTTP, SMTP, LDAP Server ]]",
637 "",
638 " 141 = EPiServer 6.x < v4",
639 " 1441 = EPiServer 6.x > v4",
640 " 1600 = Apache $apr1$",
641 " 12600 = ColdFusion 10+",
642 " 1421 = hMailServer",
643 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
644 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
645 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
646 "",
647 "[[ Checksums ]]",
648 "",
649 " 11500 = CRC32",
650 "",
651 "[[ Operating-Systems ]]",
652 "",
653 " 3000 = LM",
654 " 1000 = NTLM",
655 " 1100 = Domain Cached Credentials (DCC), MS Cache",
656 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
657 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
658 " 1500 = descrypt, DES(Unix), Traditional DES",
659 " 12400 = BSDiCrypt, Extended DES",
660 " 500 = md5crypt $1$, MD5(Unix)",
661 " 3200 = bcrypt $2*$, Blowfish(Unix)",
662 " 7400 = sha256crypt $5$, SHA256(Unix)",
663 " 1800 = sha512crypt $6$, SHA512(Unix)",
664 " 122 = OSX v10.4",
665 " 122 = OSX v10.5",
666 " 122 = OSX v10.6",
667 " 1722 = OSX v10.7",
668 " 7100 = OSX v10.8",
669 " 7100 = OSX v10.9",
670 " 7100 = OSX v10.10",
671 " 6300 = AIX {smd5}",
672 " 6700 = AIX {ssha1}",
673 " 6400 = AIX {ssha256}",
674 " 6500 = AIX {ssha512}",
675 " 2400 = Cisco-PIX",
676 " 2410 = Cisco-ASA",
677 " 500 = Cisco-IOS $1$",
678 " 5700 = Cisco-IOS $4$",
679 " 9200 = Cisco-IOS $8$",
680 " 9300 = Cisco-IOS $9$",
681 " 22 = Juniper Netscreen/SSG (ScreenOS)",
682 " 501 = Juniper IVE",
683 " 5800 = Android PIN",
684 " 8100 = Citrix Netscaler",
685 " 8500 = RACF",
686 " 7200 = GRUB 2",
687 " 9900 = Radmin2",
688 " 125 = ArubaOS",
689 "",
690 "[[ Enterprise Application Software (EAS) ]]",
691 "",
692 " 7700 = SAP CODVN B (BCODE)",
693 " 7800 = SAP CODVN F/G (PASSCODE)",
694 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
695 " 8600 = Lotus Notes/Domino 5",
696 " 8700 = Lotus Notes/Domino 6",
697 " 9100 = Lotus Notes/Domino 8",
698 " 133 = PeopleSoft",
699 "",
700 "[[ Archives ]]",
701 "",
702 " 11600 = 7-Zip",
703 " 12500 = RAR3-hp",
704 " 13000 = RAR5",
705 " 13200 = AxCrypt",
706 " 13300 = AxCrypt in memory SHA1",
707 "",
708 "[[ Full-Disk encryptions (FDE) ]]",
709 "",
710 " 62XY = TrueCrypt 5.0+",
711 " X = 1 = PBKDF2-HMAC-RipeMD160",
712 " X = 2 = PBKDF2-HMAC-SHA512",
713 " X = 3 = PBKDF2-HMAC-Whirlpool",
714 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
715 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
716 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
717 " Y = 3 = XTS 1536 bit (Ciphers: All)",
718 " 8800 = Android FDE < v4.3",
719 " 12900 = Android FDE (Samsung DEK)",
720 " 12200 = eCryptfs",
721 "",
722 "[[ Documents ]]",
723 "",
724 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
725 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
726 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
727 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
728 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
729 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
730 " 9400 = MS Office 2007",
731 " 9500 = MS Office 2010",
732 " 9600 = MS Office 2013",
733 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
734 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
735 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
736 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
737 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
738 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
739 "",
740 "[[ Password Managers ]]",
741 "",
742 " 9000 = Password Safe v2",
743 " 5200 = Password Safe v3",
744 " 6800 = Lastpass",
745 " 6600 = 1Password, agilekeychain",
746 " 8200 = 1Password, cloudkeychain",
747 " 11300 = Bitcoin/Litecoin wallet.dat",
748 " 12700 = Blockchain, My Wallet",
749 " 13400 = Keepass 1 (AES/Twofish) and Keepass 2 (AES)",
750 "",
751 NULL
752 };
753
754 /**
755 * oclHashcat specific functions
756 */
757
758 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
759 {
760 int exec_pos = (int) device_param->exec_pos - last_num_entries;
761
762 if (exec_pos < 0) exec_pos += EXEC_CACHE;
763
764 double exec_ms_sum = 0;
765
766 int exec_ms_cnt = 0;
767
768 for (int i = 0; i < last_num_entries; i++)
769 {
770 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
771
772 if (exec_ms)
773 {
774 exec_ms_sum += exec_ms;
775
776 exec_ms_cnt++;
777 }
778 }
779
780 if (exec_ms_cnt == 0) return 0;
781
782 return exec_ms_sum / exec_ms_cnt;
783 }
784
785 void status_display_automat ()
786 {
787 FILE *out = stdout;
788
789 fprintf (out, "STATUS\t%u\t", data.devices_status);
790
791 /**
792 * speed new
793 */
794
795 fprintf (out, "SPEED\t");
796
797 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
798 {
799 hc_device_param_t *device_param = &data.devices_param[device_id];
800
801 if (device_param->skipped) continue;
802
803 u64 speed_cnt = 0;
804 double speed_ms = 0;
805
806 for (int i = 0; i < SPEED_CACHE; i++)
807 {
808 speed_cnt += device_param->speed_cnt[i];
809 speed_ms += device_param->speed_ms[i];
810 }
811
812 speed_cnt /= SPEED_CACHE;
813 speed_ms /= SPEED_CACHE;
814
815 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
816 }
817
818 /**
819 * exec time
820 */
821
822 fprintf (out, "EXEC_RUNTIME\t");
823
824 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
825 {
826 hc_device_param_t *device_param = &data.devices_param[device_id];
827
828 if (device_param->skipped) continue;
829
830 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
831
832 fprintf (out, "%f\t", exec_ms_avg);
833 }
834
835 /**
836 * words_cur
837 */
838
839 u64 words_cur = get_lowest_words_done ();
840
841 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
842
843 /**
844 * counter
845 */
846
847 u64 progress_total = data.words_cnt * data.salts_cnt;
848
849 u64 all_done = 0;
850 u64 all_rejected = 0;
851 u64 all_restored = 0;
852
853 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
854 {
855 all_done += data.words_progress_done[salt_pos];
856 all_rejected += data.words_progress_rejected[salt_pos];
857 all_restored += data.words_progress_restored[salt_pos];
858 }
859
860 u64 progress_cur = all_restored + all_done + all_rejected;
861 u64 progress_end = progress_total;
862
863 u64 progress_skip = 0;
864
865 if (data.skip)
866 {
867 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
868
869 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
870 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
871 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
872 }
873
874 if (data.limit)
875 {
876 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
877
878 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
879 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
880 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
881 }
882
883 u64 progress_cur_relative_skip = progress_cur - progress_skip;
884 u64 progress_end_relative_skip = progress_end - progress_skip;
885
886 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
887
888 /**
889 * cracks
890 */
891
892 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
893 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
894
895 /**
896 * temperature
897 */
898
899 #ifdef HAVE_HWMON
900 if (data.gpu_temp_disable == 0)
901 {
902 fprintf (out, "TEMP\t");
903
904 hc_thread_mutex_lock (mux_adl);
905
906 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
907 {
908 hc_device_param_t *device_param = &data.devices_param[device_id];
909
910 if (device_param->skipped) continue;
911
912 int temp = hm_get_temperature_with_device_id (device_id);
913
914 fprintf (out, "%d\t", temp);
915 }
916
917 hc_thread_mutex_unlock (mux_adl);
918 }
919 #endif // HAVE_HWMON
920
921 /**
922 * flush
923 */
924
925 #ifdef _WIN
926 fputc ('\r', out);
927 fputc ('\n', out);
928 #endif
929
930 #ifdef _POSIX
931 fputc ('\n', out);
932 #endif
933
934 fflush (out);
935 }
936
937 void status_display ()
938 {
939 if (data.devices_status == STATUS_INIT) return;
940 if (data.devices_status == STATUS_STARTING) return;
941 if (data.devices_status == STATUS_BYPASS) return;
942
943 if (data.status_automat == 1)
944 {
945 status_display_automat ();
946
947 return;
948 }
949
950 char tmp_buf[1000] = { 0 };
951
952 uint tmp_len = 0;
953
954 log_info ("Session.Name...: %s", data.session);
955
956 char *status_type = strstatus (data.devices_status);
957
958 uint hash_mode = data.hash_mode;
959
960 char *hash_type = strhashtype (hash_mode); // not a bug
961
962 log_info ("Status.........: %s", status_type);
963
964 /**
965 * show rules
966 */
967
968 if (data.rp_files_cnt)
969 {
970 uint i;
971
972 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
973 {
974 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
975 }
976
977 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
978
979 log_info ("Rules.Type.....: %s", tmp_buf);
980
981 tmp_len = 0;
982 }
983
984 if (data.rp_gen)
985 {
986 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
987
988 if (data.rp_gen_seed)
989 {
990 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
991 }
992 }
993
994 /**
995 * show input
996 */
997
998 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
999 {
1000 if (data.wordlist_mode == WL_MODE_FILE)
1001 {
1002 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1003 }
1004 else if (data.wordlist_mode == WL_MODE_STDIN)
1005 {
1006 log_info ("Input.Mode.....: Pipe");
1007 }
1008 }
1009 else if (data.attack_mode == ATTACK_MODE_COMBI)
1010 {
1011 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1012 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1013 }
1014 else if (data.attack_mode == ATTACK_MODE_BF)
1015 {
1016 char *mask = data.mask;
1017
1018 if (mask != NULL)
1019 {
1020 uint mask_len = data.css_cnt;
1021
1022 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1023
1024 if (mask_len > 0)
1025 {
1026 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1027 {
1028 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1029 {
1030 mask_len -= data.salts_buf[0].salt_len;
1031 }
1032 }
1033
1034 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1035
1036 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1037 }
1038
1039 if (data.maskcnt > 1)
1040 {
1041 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1042
1043 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1044 }
1045
1046 log_info ("Input.Mode.....: %s", tmp_buf);
1047 }
1048
1049 tmp_len = 0;
1050 }
1051 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1052 {
1053 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1054 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1055 }
1056 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1057 {
1058 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1059 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1060 }
1061
1062 if (data.digests_cnt == 1)
1063 {
1064 if (data.hash_mode == 2500)
1065 {
1066 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1067
1068 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1069 (char *) data.salts_buf[0].salt_buf,
1070 wpa->orig_mac1[0],
1071 wpa->orig_mac1[1],
1072 wpa->orig_mac1[2],
1073 wpa->orig_mac1[3],
1074 wpa->orig_mac1[4],
1075 wpa->orig_mac1[5],
1076 wpa->orig_mac2[0],
1077 wpa->orig_mac2[1],
1078 wpa->orig_mac2[2],
1079 wpa->orig_mac2[3],
1080 wpa->orig_mac2[4],
1081 wpa->orig_mac2[5]);
1082 }
1083 else if (data.hash_mode == 5200)
1084 {
1085 log_info ("Hash.Target....: File (%s)", data.hashfile);
1086 }
1087 else if (data.hash_mode == 9000)
1088 {
1089 log_info ("Hash.Target....: File (%s)", data.hashfile);
1090 }
1091 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1092 {
1093 log_info ("Hash.Target....: File (%s)", data.hashfile);
1094 }
1095 else
1096 {
1097 char out_buf[HCBUFSIZ] = { 0 };
1098
1099 ascii_digest (out_buf, 0, 0);
1100
1101 // limit length
1102 if (strlen (out_buf) > 40)
1103 {
1104 out_buf[41] = '.';
1105 out_buf[42] = '.';
1106 out_buf[43] = '.';
1107 out_buf[44] = 0;
1108 }
1109
1110 log_info ("Hash.Target....: %s", out_buf);
1111 }
1112 }
1113 else
1114 {
1115 if (data.hash_mode == 3000)
1116 {
1117 char out_buf1[32] = { 0 };
1118 char out_buf2[32] = { 0 };
1119
1120 ascii_digest (out_buf1, 0, 0);
1121 ascii_digest (out_buf2, 0, 1);
1122
1123 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1124 }
1125 else
1126 {
1127 log_info ("Hash.Target....: File (%s)", data.hashfile);
1128 }
1129 }
1130
1131 log_info ("Hash.Type......: %s", hash_type);
1132
1133 /**
1134 * speed new
1135 */
1136
1137 u64 speed_cnt[DEVICES_MAX] = { 0 };
1138 double speed_ms[DEVICES_MAX] = { 0 };
1139
1140 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1141 {
1142 hc_device_param_t *device_param = &data.devices_param[device_id];
1143
1144 if (device_param->skipped) continue;
1145
1146 speed_cnt[device_id] = 0;
1147 speed_ms[device_id] = 0;
1148
1149 for (int i = 0; i < SPEED_CACHE; i++)
1150 {
1151 speed_cnt[device_id] += device_param->speed_cnt[i];
1152 speed_ms[device_id] += device_param->speed_ms[i];
1153 }
1154
1155 speed_cnt[device_id] /= SPEED_CACHE;
1156 speed_ms[device_id] /= SPEED_CACHE;
1157 }
1158
1159 float hashes_all_ms = 0;
1160
1161 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1162
1163 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1164 {
1165 hc_device_param_t *device_param = &data.devices_param[device_id];
1166
1167 if (device_param->skipped) continue;
1168
1169 hashes_dev_ms[device_id] = 0;
1170
1171 if (speed_ms[device_id])
1172 {
1173 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1174
1175 hashes_all_ms += hashes_dev_ms[device_id];
1176 }
1177 }
1178
1179 /**
1180 * exec time
1181 */
1182
1183 double exec_all_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 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1192
1193 exec_all_ms[device_id] = exec_ms_avg;
1194 }
1195
1196 /**
1197 * timers
1198 */
1199
1200 double ms_running = 0;
1201
1202 hc_timer_get (data.timer_running, ms_running);
1203
1204 double ms_paused = data.ms_paused;
1205
1206 if (data.devices_status == STATUS_PAUSED)
1207 {
1208 double ms_paused_tmp = 0;
1209
1210 hc_timer_get (data.timer_paused, ms_paused_tmp);
1211
1212 ms_paused += ms_paused_tmp;
1213 }
1214
1215 #ifdef WIN
1216
1217 __time64_t sec_run = ms_running / 1000;
1218
1219 #else
1220
1221 time_t sec_run = ms_running / 1000;
1222
1223 #endif
1224
1225 if (sec_run)
1226 {
1227 char display_run[32] = { 0 };
1228
1229 struct tm tm_run;
1230
1231 struct tm *tmp = NULL;
1232
1233 #ifdef WIN
1234
1235 tmp = _gmtime64 (&sec_run);
1236
1237 #else
1238
1239 tmp = gmtime (&sec_run);
1240
1241 #endif
1242
1243 if (tmp != NULL)
1244 {
1245 memset (&tm_run, 0, sizeof (tm_run));
1246
1247 memcpy (&tm_run, tmp, sizeof (tm_run));
1248
1249 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1250
1251 char *start = ctime (&data.proc_start);
1252
1253 size_t start_len = strlen (start);
1254
1255 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1256 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1257
1258 log_info ("Time.Started...: %s (%s)", start, display_run);
1259 }
1260 }
1261 else
1262 {
1263 log_info ("Time.Started...: 0 secs");
1264 }
1265
1266 /**
1267 * counters
1268 */
1269
1270 u64 progress_total = data.words_cnt * data.salts_cnt;
1271
1272 u64 all_done = 0;
1273 u64 all_rejected = 0;
1274 u64 all_restored = 0;
1275
1276 u64 progress_noneed = 0;
1277
1278 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1279 {
1280 all_done += data.words_progress_done[salt_pos];
1281 all_rejected += data.words_progress_rejected[salt_pos];
1282 all_restored += data.words_progress_restored[salt_pos];
1283
1284 // Important for ETA only
1285
1286 if (data.salts_shown[salt_pos] == 1)
1287 {
1288 const u64 all = data.words_progress_done[salt_pos]
1289 + data.words_progress_rejected[salt_pos]
1290 + data.words_progress_restored[salt_pos];
1291
1292 const u64 left = data.words_cnt - all;
1293
1294 progress_noneed += left;
1295 }
1296 }
1297
1298 u64 progress_cur = all_restored + all_done + all_rejected;
1299 u64 progress_end = progress_total;
1300
1301 u64 progress_skip = 0;
1302
1303 if (data.skip)
1304 {
1305 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1306
1307 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1308 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1309 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1310 }
1311
1312 if (data.limit)
1313 {
1314 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1315
1316 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1317 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1318 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1319 }
1320
1321 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1322 u64 progress_end_relative_skip = progress_end - progress_skip;
1323
1324 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1325 {
1326 if (data.devices_status != STATUS_CRACKED)
1327 {
1328 #ifdef WIN
1329 __time64_t sec_etc = 0;
1330 #else
1331 time_t sec_etc = 0;
1332 #endif
1333
1334 if (hashes_all_ms)
1335 {
1336 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1337
1338 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1339
1340 sec_etc = ms_left / 1000;
1341 }
1342
1343 if (sec_etc == 0)
1344 {
1345 //log_info ("Time.Estimated.: 0 secs");
1346 }
1347 else if ((u64) sec_etc > ETC_MAX)
1348 {
1349 log_info ("Time.Estimated.: > 10 Years");
1350 }
1351 else
1352 {
1353 char display_etc[32] = { 0 };
1354
1355 struct tm tm_etc;
1356
1357 struct tm *tmp = NULL;
1358
1359 #ifdef WIN
1360
1361 tmp = _gmtime64 (&sec_etc);
1362
1363 #else
1364
1365 tmp = gmtime (&sec_etc);
1366
1367 #endif
1368
1369 if (tmp != NULL)
1370 {
1371 memset (&tm_etc, 0, sizeof (tm_etc));
1372
1373 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1374
1375 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1376
1377 time_t now;
1378
1379 time (&now);
1380
1381 now += sec_etc;
1382
1383 char *etc = ctime (&now);
1384
1385 size_t etc_len = strlen (etc);
1386
1387 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1388 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1389
1390 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1391 }
1392 }
1393 }
1394 }
1395
1396 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1397 {
1398 hc_device_param_t *device_param = &data.devices_param[device_id];
1399
1400 if (device_param->skipped) continue;
1401
1402 char display_dev_cur[16] = { 0 };
1403
1404 strncpy (display_dev_cur, "0.00", 4);
1405
1406 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1407
1408 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1409 }
1410
1411 char display_all_cur[16] = { 0 };
1412
1413 strncpy (display_all_cur, "0.00", 4);
1414
1415 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1416
1417 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1418
1419 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1420 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1421
1422 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);
1423
1424 // crack-per-time
1425
1426 if (data.digests_cnt > 100)
1427 {
1428 time_t now = time (NULL);
1429
1430 int cpt_cur_min = 0;
1431 int cpt_cur_hour = 0;
1432 int cpt_cur_day = 0;
1433
1434 for (int i = 0; i < CPT_BUF; i++)
1435 {
1436 const uint cracked = data.cpt_buf[i].cracked;
1437 const time_t timestamp = data.cpt_buf[i].timestamp;
1438
1439 if ((timestamp + 60) > now)
1440 {
1441 cpt_cur_min += cracked;
1442 }
1443
1444 if ((timestamp + 3600) > now)
1445 {
1446 cpt_cur_hour += cracked;
1447 }
1448
1449 if ((timestamp + 86400) > now)
1450 {
1451 cpt_cur_day += cracked;
1452 }
1453 }
1454
1455 double ms_real = ms_running - ms_paused;
1456
1457 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1458 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1459 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1460
1461 if ((data.cpt_start + 86400) < now)
1462 {
1463 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1464 cpt_cur_min,
1465 cpt_cur_hour,
1466 cpt_cur_day,
1467 cpt_avg_min,
1468 cpt_avg_hour,
1469 cpt_avg_day);
1470 }
1471 else if ((data.cpt_start + 3600) < now)
1472 {
1473 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1474 cpt_cur_min,
1475 cpt_cur_hour,
1476 cpt_avg_min,
1477 cpt_avg_hour,
1478 cpt_avg_day);
1479 }
1480 else if ((data.cpt_start + 60) < now)
1481 {
1482 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1483 cpt_cur_min,
1484 cpt_avg_min,
1485 cpt_avg_hour,
1486 cpt_avg_day);
1487 }
1488 else
1489 {
1490 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1491 cpt_avg_min,
1492 cpt_avg_hour,
1493 cpt_avg_day);
1494 }
1495 }
1496
1497 // Restore point
1498
1499 u64 restore_point = get_lowest_words_done ();
1500
1501 u64 restore_total = data.words_base;
1502
1503 float percent_restore = 0;
1504
1505 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1506
1507 if (progress_end_relative_skip)
1508 {
1509 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1510 {
1511 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1512 float percent_rejected = 0.0;
1513
1514 if (progress_cur)
1515 {
1516 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1517 }
1518
1519 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);
1520 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1521
1522 if (data.restore_disable == 0)
1523 {
1524 if (percent_finished != 1)
1525 {
1526 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1527 }
1528 }
1529 }
1530 }
1531 else
1532 {
1533 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1534 {
1535 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1536 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1537
1538 if (data.restore_disable == 0)
1539 {
1540 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1541 }
1542 }
1543 else
1544 {
1545 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1546 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1547
1548 // --restore not allowed if stdin is used -- really? why?
1549
1550 //if (data.restore_disable == 0)
1551 //{
1552 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1553 //}
1554 }
1555 }
1556
1557 #ifdef HAVE_HWMON
1558 if (data.gpu_temp_disable == 0)
1559 {
1560 hc_thread_mutex_lock (mux_adl);
1561
1562 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1563 {
1564 hc_device_param_t *device_param = &data.devices_param[device_id];
1565
1566 if (device_param->skipped) continue;
1567
1568 #define HM_STR_BUF_SIZE 255
1569
1570 if (data.hm_device[device_id].fan_supported == 1)
1571 {
1572 char utilization[HM_STR_BUF_SIZE] = { 0 };
1573 char temperature[HM_STR_BUF_SIZE] = { 0 };
1574 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1575
1576 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1577 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1578
1579 if (device_param->vendor_id == VENDOR_ID_AMD)
1580 {
1581 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1582 }
1583 else if (device_param->vendor_id == VENDOR_ID_NV)
1584 {
1585 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1586 }
1587
1588 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1589 }
1590 else
1591 {
1592 char utilization[HM_STR_BUF_SIZE] = { 0 };
1593 char temperature[HM_STR_BUF_SIZE] = { 0 };
1594
1595 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1596 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1597
1598 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1599 }
1600 }
1601
1602 hc_thread_mutex_unlock (mux_adl);
1603 }
1604 #endif // HAVE_HWMON
1605 }
1606
1607 static void status_benchmark ()
1608 {
1609 if (data.devices_status == STATUS_INIT) return;
1610 if (data.devices_status == STATUS_STARTING) return;
1611
1612 if (data.words_cnt == 0) return;
1613
1614 u64 speed_cnt[DEVICES_MAX] = { 0 };
1615 double speed_ms[DEVICES_MAX] = { 0 };
1616
1617 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1618 {
1619 hc_device_param_t *device_param = &data.devices_param[device_id];
1620
1621 if (device_param->skipped) continue;
1622
1623 speed_cnt[device_id] = device_param->speed_cnt[0];
1624 speed_ms[device_id] = device_param->speed_ms[0];
1625 }
1626
1627 float hashes_all_ms = 0;
1628
1629 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1630
1631 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1632 {
1633 hc_device_param_t *device_param = &data.devices_param[device_id];
1634
1635 if (device_param->skipped) continue;
1636
1637 hashes_dev_ms[device_id] = 0;
1638
1639 if (speed_ms[device_id])
1640 {
1641 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1642
1643 hashes_all_ms += hashes_dev_ms[device_id];
1644 }
1645 }
1646
1647 /**
1648 * exec time
1649 */
1650
1651 double exec_all_ms[DEVICES_MAX] = { 0 };
1652
1653 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1654 {
1655 hc_device_param_t *device_param = &data.devices_param[device_id];
1656
1657 if (device_param->skipped) continue;
1658
1659 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1660
1661 exec_all_ms[device_id] = exec_ms_avg;
1662 }
1663
1664 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1665 {
1666 hc_device_param_t *device_param = &data.devices_param[device_id];
1667
1668 if (device_param->skipped) continue;
1669
1670 char display_dev_cur[16] = { 0 };
1671
1672 strncpy (display_dev_cur, "0.00", 4);
1673
1674 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1675
1676 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1677 }
1678
1679 char display_all_cur[16] = { 0 };
1680
1681 strncpy (display_all_cur, "0.00", 4);
1682
1683 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1684
1685 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1686 }
1687
1688 /**
1689 * oclHashcat -only- functions
1690 */
1691
1692 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1693 {
1694 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1695 {
1696 if (attack_kern == ATTACK_KERN_STRAIGHT)
1697 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1698 else if (attack_kern == ATTACK_KERN_COMBI)
1699 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1700 else if (attack_kern == ATTACK_KERN_BF)
1701 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1702 }
1703 else
1704 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1705 }
1706
1707 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)
1708 {
1709 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1710 {
1711 if (attack_kern == ATTACK_KERN_STRAIGHT)
1712 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1713 else if (attack_kern == ATTACK_KERN_COMBI)
1714 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1715 else if (attack_kern == ATTACK_KERN_BF)
1716 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1717 }
1718 else
1719 {
1720 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1721 }
1722 }
1723
1724 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1725 {
1726 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1727 {
1728 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1729 }
1730 else
1731 {
1732 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1733 }
1734 }
1735
1736 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)
1737 {
1738 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1739 {
1740 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1741 }
1742 else
1743 {
1744 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1745 }
1746 }
1747
1748 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1749 {
1750 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1751 }
1752
1753 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1754 {
1755 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1756 }
1757
1758 static uint convert_from_hex (char *line_buf, const uint line_len)
1759 {
1760 if (line_len & 1) return (line_len); // not in hex
1761
1762 if (data.hex_wordlist == 1)
1763 {
1764 uint i;
1765 uint j;
1766
1767 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1768 {
1769 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1770 }
1771
1772 memset (line_buf + i, 0, line_len - i);
1773
1774 return (i);
1775 }
1776 else if (line_len >= 6) // $HEX[] = 6
1777 {
1778 if (line_buf[0] != '$') return (line_len);
1779 if (line_buf[1] != 'H') return (line_len);
1780 if (line_buf[2] != 'E') return (line_len);
1781 if (line_buf[3] != 'X') return (line_len);
1782 if (line_buf[4] != '[') return (line_len);
1783 if (line_buf[line_len - 1] != ']') return (line_len);
1784
1785 uint i;
1786 uint j;
1787
1788 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1789 {
1790 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1791 }
1792
1793 memset (line_buf + i, 0, line_len - i);
1794
1795 return (i);
1796 }
1797
1798 return (line_len);
1799 }
1800
1801 static void clear_prompt ()
1802 {
1803 fputc ('\r', stdout);
1804
1805 for (size_t i = 0; i < strlen (PROMPT); i++)
1806 {
1807 fputc (' ', stdout);
1808 }
1809
1810 fputc ('\r', stdout);
1811
1812 fflush (stdout);
1813 }
1814
1815 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1816 {
1817 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);
1818 }
1819
1820 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1821 {
1822 char *outfile = data.outfile;
1823 uint quiet = data.quiet;
1824 FILE *pot_fp = data.pot_fp;
1825 uint loopback = data.loopback;
1826 uint debug_mode = data.debug_mode;
1827 char *debug_file = data.debug_file;
1828
1829 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1830 int debug_rule_len = 0; // -1 error
1831 uint debug_plain_len = 0;
1832
1833 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1834
1835 // hash
1836
1837 char out_buf[HCBUFSIZ] = { 0 };
1838
1839 ascii_digest (out_buf, salt_pos, digest_pos);
1840
1841 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1842
1843 // plain
1844
1845 plain_t plain;
1846
1847 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);
1848
1849 uint gidvid = plain.gidvid;
1850 uint il_pos = plain.il_pos;
1851
1852 u64 crackpos = device_param->words_off;
1853
1854 uint plain_buf[16] = { 0 };
1855
1856 u8 *plain_ptr = (u8 *) plain_buf;
1857 unsigned int plain_len = 0;
1858
1859 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1860 {
1861 u64 gidd = gidvid;
1862 u64 gidm = 0;
1863
1864 pw_t pw;
1865
1866 gidd_to_pw_t (device_param, gidd, &pw);
1867
1868 for (int i = 0, j = gidm; i < 16; i++, j++)
1869 {
1870 plain_buf[i] = pw.i[j];
1871 }
1872
1873 plain_len = pw.pw_len;
1874
1875 const uint off = device_param->innerloop_pos + il_pos;
1876
1877 if (debug_mode > 0)
1878 {
1879 debug_rule_len = 0;
1880
1881 // save rule
1882 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1883 {
1884 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1885
1886 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1887 }
1888
1889 // save plain
1890 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1891 {
1892 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1893
1894 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1895
1896 debug_plain_len = plain_len;
1897 }
1898 }
1899
1900 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1901
1902 crackpos += gidvid;
1903 crackpos *= data.kernel_rules_cnt;
1904 crackpos += device_param->innerloop_pos + il_pos;
1905
1906 if (plain_len > data.pw_max) plain_len = data.pw_max;
1907 }
1908 else if (data.attack_mode == ATTACK_MODE_COMBI)
1909 {
1910 u64 gidd = gidvid;
1911 u64 gidm = 0;
1912
1913 pw_t pw;
1914
1915 gidd_to_pw_t (device_param, gidd, &pw);
1916
1917 for (int i = 0, j = gidm; i < 16; i++, j++)
1918 {
1919 plain_buf[i] = pw.i[j];
1920 }
1921
1922 plain_len = pw.pw_len;
1923
1924 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1925 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1926
1927 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1928 {
1929 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1930 }
1931 else
1932 {
1933 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1934
1935 memcpy (plain_ptr, comb_buf, comb_len);
1936 }
1937
1938 plain_len += comb_len;
1939
1940 crackpos += gidvid;
1941 crackpos *= data.combs_cnt;
1942 crackpos += device_param->innerloop_pos + il_pos;
1943
1944 if (data.pw_max != PW_DICTMAX1)
1945 {
1946 if (plain_len > data.pw_max) plain_len = data.pw_max;
1947 }
1948 }
1949 else if (data.attack_mode == ATTACK_MODE_BF)
1950 {
1951 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1952 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1953
1954 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1955 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1956
1957 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1958 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1959
1960 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1961 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1962
1963 plain_len = data.css_cnt;
1964
1965 crackpos += gidvid;
1966 crackpos *= data.bfs_cnt;
1967 crackpos += device_param->innerloop_pos + il_pos;
1968 }
1969 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1970 {
1971 u64 gidd = gidvid;
1972 u64 gidm = 0;
1973
1974 pw_t pw;
1975
1976 gidd_to_pw_t (device_param, gidd, &pw);
1977
1978 for (int i = 0, j = gidm; i < 16; i++, j++)
1979 {
1980 plain_buf[i] = pw.i[j];
1981 }
1982
1983 plain_len = pw.pw_len;
1984
1985 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
1986
1987 uint start = 0;
1988 uint stop = device_param->kernel_params_mp_buf32[4];
1989
1990 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1991
1992 plain_len += start + stop;
1993
1994 crackpos += gidvid;
1995 crackpos *= data.combs_cnt;
1996 crackpos += device_param->innerloop_pos + il_pos;
1997
1998 if (data.pw_max != PW_DICTMAX1)
1999 {
2000 if (plain_len > data.pw_max) plain_len = data.pw_max;
2001 }
2002 }
2003 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2004 {
2005 u64 gidd = gidvid;
2006 u64 gidm = 0;
2007
2008 pw_t pw;
2009
2010 gidd_to_pw_t (device_param, gidd, &pw);
2011
2012 for (int i = 0, j = gidm; i < 16; i++, j++)
2013 {
2014 plain_buf[i] = pw.i[j];
2015 }
2016
2017 plain_len = pw.pw_len;
2018
2019 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2020
2021 uint start = 0;
2022 uint stop = device_param->kernel_params_mp_buf32[4];
2023
2024 memmove (plain_ptr + stop, plain_ptr, plain_len);
2025
2026 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2027
2028 plain_len += start + stop;
2029
2030 crackpos += gidvid;
2031 crackpos *= data.combs_cnt;
2032 crackpos += device_param->innerloop_pos + il_pos;
2033
2034 if (data.pw_max != PW_DICTMAX1)
2035 {
2036 if (plain_len > data.pw_max) plain_len = data.pw_max;
2037 }
2038 }
2039
2040 if (data.attack_mode == ATTACK_MODE_BF)
2041 {
2042 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2043 {
2044 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2045 {
2046 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2047 {
2048 plain_len = plain_len - data.salts_buf[0].salt_len;
2049 }
2050 }
2051
2052 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2053 {
2054 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2055 {
2056 plain_ptr[j] = plain_ptr[i];
2057 }
2058
2059 plain_len = plain_len / 2;
2060 }
2061 }
2062 }
2063
2064 // if enabled, update also the potfile
2065
2066 if (pot_fp)
2067 {
2068 lock_file (pot_fp);
2069
2070 fprintf (pot_fp, "%s:", out_buf);
2071
2072 format_plain (pot_fp, plain_ptr, plain_len, 1);
2073
2074 fputc ('\n', pot_fp);
2075
2076 fflush (pot_fp);
2077
2078 unlock_file (pot_fp);
2079 }
2080
2081 // outfile
2082
2083 FILE *out_fp = NULL;
2084
2085 if (outfile != NULL)
2086 {
2087 if ((out_fp = fopen (outfile, "ab")) == NULL)
2088 {
2089 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2090
2091 out_fp = stdout;
2092 }
2093 lock_file (out_fp);
2094 }
2095 else
2096 {
2097 out_fp = stdout;
2098
2099 if (quiet == 0) clear_prompt ();
2100 }
2101
2102 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2103
2104 if (outfile != NULL)
2105 {
2106 if (out_fp != stdout)
2107 {
2108 fclose (out_fp);
2109 }
2110 }
2111 else
2112 {
2113 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2114 {
2115 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2116 {
2117 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2118 if (quiet == 0) fflush (stdout);
2119 }
2120 }
2121 }
2122
2123 // loopback
2124
2125 if (loopback)
2126 {
2127 char *loopback_file = data.loopback_file;
2128
2129 FILE *fb_fp = NULL;
2130
2131 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2132 {
2133 lock_file (fb_fp);
2134
2135 format_plain (fb_fp, plain_ptr, plain_len, 1);
2136
2137 fputc ('\n', fb_fp);
2138
2139 fclose (fb_fp);
2140 }
2141 }
2142
2143 // (rule) debug mode
2144
2145 // the next check implies that:
2146 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2147 // - debug_mode > 0
2148
2149 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2150 {
2151 if (debug_rule_len < 0) debug_rule_len = 0;
2152
2153 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2154
2155 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2156
2157 if ((quiet == 0) && (debug_file == NULL))
2158 {
2159 fprintf (stdout, "%s", PROMPT);
2160 fflush (stdout);
2161 }
2162 }
2163 }
2164
2165 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2166 {
2167 salt_t *salt_buf = &data.salts_buf[salt_pos];
2168
2169 int found = 0;
2170
2171 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);
2172
2173 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2174
2175 if (found == 1)
2176 {
2177 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2178
2179 log_info_nn ("");
2180
2181 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);
2182
2183 uint cpt_cracked = 0;
2184
2185 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2186 {
2187 uint idx = salt_buf->digests_offset + digest_pos;
2188
2189 if (data.digests_shown_tmp[idx] == 0) continue;
2190
2191 if (data.digests_shown[idx] == 1) continue;
2192
2193 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2194 {
2195 data.digests_shown[idx] = 1;
2196
2197 data.digests_done++;
2198
2199 cpt_cracked++;
2200
2201 salt_buf->digests_done++;
2202
2203 if (salt_buf->digests_done == salt_buf->digests_cnt)
2204 {
2205 data.salts_shown[salt_pos] = 1;
2206
2207 data.salts_done++;
2208 }
2209 }
2210
2211 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2212
2213 check_hash (device_param, salt_pos, digest_pos);
2214 }
2215
2216 if (cpt_cracked > 0)
2217 {
2218 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2219 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2220
2221 data.cpt_pos++;
2222
2223 data.cpt_total += cpt_cracked;
2224
2225 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2226 }
2227
2228 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2229 {
2230 // we need to reset cracked state on the device
2231 // otherwise host thinks again and again the hash was cracked
2232 // and returns invalid password each time
2233
2234 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2235
2236 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);
2237 }
2238
2239 memset (device_param->result, 0, device_param->size_results);
2240
2241 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);
2242 }
2243 }
2244
2245 static void save_hash ()
2246 {
2247 char *hashfile = data.hashfile;
2248
2249 char new_hashfile[256] = { 0 };
2250 char old_hashfile[256] = { 0 };
2251
2252 snprintf (new_hashfile, 255, "%s.new", hashfile);
2253 snprintf (old_hashfile, 255, "%s.old", hashfile);
2254
2255 unlink (new_hashfile);
2256
2257 char separator = data.separator;
2258
2259 FILE *fp = fopen (new_hashfile, "wb");
2260
2261 if (fp == NULL)
2262 {
2263 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2264
2265 exit (-1);
2266 }
2267
2268 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2269 {
2270 if (data.salts_shown[salt_pos] == 1) continue;
2271
2272 salt_t *salt_buf = &data.salts_buf[salt_pos];
2273
2274 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2275 {
2276 uint idx = salt_buf->digests_offset + digest_pos;
2277
2278 if (data.digests_shown[idx] == 1) continue;
2279
2280 if (data.hash_mode != 2500)
2281 {
2282 char out_buf[HCBUFSIZ] = { 0 };
2283
2284 if (data.username == 1)
2285 {
2286 user_t *user = data.hash_info[idx]->user;
2287
2288 uint i;
2289
2290 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2291
2292 fputc (separator, fp);
2293 }
2294
2295 ascii_digest (out_buf, salt_pos, digest_pos);
2296
2297 fputs (out_buf, fp);
2298
2299 log_out (fp, "");
2300 }
2301 else
2302 {
2303 hccap_t hccap;
2304
2305 to_hccap_t (&hccap, salt_pos, digest_pos);
2306
2307 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2308 }
2309 }
2310 }
2311
2312 fflush (fp);
2313
2314 fclose (fp);
2315
2316 unlink (old_hashfile);
2317
2318 if (rename (hashfile, old_hashfile) != 0)
2319 {
2320 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2321
2322 exit (-1);
2323 }
2324
2325 unlink (hashfile);
2326
2327 if (rename (new_hashfile, hashfile) != 0)
2328 {
2329 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2330
2331 exit (-1);
2332 }
2333
2334 unlink (old_hashfile);
2335 }
2336
2337 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2338 {
2339 // function called only in case kernel_power_all > words_left
2340
2341 float kernel_power_div = (float) (total_left) / kernel_power_all;
2342
2343 kernel_power_div += kernel_power_div / 100;
2344
2345 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2346
2347 while (kernel_power_new < total_left)
2348 {
2349 kernel_power_div += kernel_power_div / 100;
2350
2351 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2352 }
2353
2354 if (data.quiet == 0)
2355 {
2356 clear_prompt ();
2357
2358 log_info ("");
2359
2360 log_info ("INFO: approaching final keyspace, workload adjusted");
2361
2362 log_info ("");
2363
2364 fprintf (stdout, "%s", PROMPT);
2365
2366 fflush (stdout);
2367 }
2368
2369 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2370
2371 return kernel_power_div;
2372 }
2373
2374 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2375 {
2376 uint num_elements = num;
2377
2378 device_param->kernel_params_buf32[30] = data.combs_mode;
2379 device_param->kernel_params_buf32[31] = num;
2380
2381 uint kernel_threads = device_param->kernel_threads;
2382
2383 while (num_elements % kernel_threads) num_elements++;
2384
2385 cl_kernel kernel = NULL;
2386
2387 switch (kern_run)
2388 {
2389 case KERN_RUN_1: kernel = device_param->kernel1; break;
2390 case KERN_RUN_12: kernel = device_param->kernel12; break;
2391 case KERN_RUN_2: kernel = device_param->kernel2; break;
2392 case KERN_RUN_23: kernel = device_param->kernel23; break;
2393 case KERN_RUN_3: kernel = device_param->kernel3; break;
2394 }
2395
2396 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2397 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2398 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2399 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2400 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2401 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2402 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2403 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2404 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2405 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2406 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2407
2408 hc_timer_t timer;
2409
2410 hc_timer_set (&timer);
2411
2412 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2413 {
2414 const size_t global_work_size[3] = { num_elements, 32, 1 };
2415 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2416
2417 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2418 }
2419 else
2420 {
2421 size_t workgroup_size = 0;
2422
2423 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2424
2425 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2426
2427 const size_t global_work_size[3] = { num_elements, 1, 1 };
2428 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2429
2430 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2431 }
2432
2433 hc_clFlush (data.ocl, device_param->command_queue);
2434
2435 hc_clFinish (data.ocl, device_param->command_queue);
2436
2437 if (event_update)
2438 {
2439 double exec_time;
2440
2441 hc_timer_get (timer, exec_time);
2442
2443 uint exec_pos = device_param->exec_pos;
2444
2445 device_param->exec_ms[exec_pos] = exec_time;
2446
2447 exec_pos++;
2448
2449 if (exec_pos == EXEC_CACHE)
2450 {
2451 exec_pos = 0;
2452 }
2453
2454 device_param->exec_pos = exec_pos;
2455 }
2456 }
2457
2458 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2459 {
2460 uint num_elements = num;
2461
2462 switch (kern_run)
2463 {
2464 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2465 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2466 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2467 }
2468
2469 // causes problems with special threads like in bcrypt
2470 // const uint kernel_threads = device_param->kernel_threads;
2471
2472 uint kernel_threads = KERNEL_THREADS;
2473
2474 while (num_elements % kernel_threads) num_elements++;
2475
2476 cl_kernel kernel = NULL;
2477
2478 switch (kern_run)
2479 {
2480 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2481 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2482 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2483 }
2484
2485 switch (kern_run)
2486 {
2487 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2488 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2489 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2490 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2491 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2492 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2493 break;
2494 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2495 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2496 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2497 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2498 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2499 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2500 break;
2501 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2502 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2503 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2504 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2505 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2506 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2507 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2508 break;
2509 }
2510
2511 size_t workgroup_size = 0;
2512 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
2513 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2514
2515 const size_t global_work_size[3] = { num_elements, 1, 1 };
2516 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2517
2518 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2519
2520 hc_clFlush (data.ocl, device_param->command_queue);
2521
2522 hc_clFinish (data.ocl, device_param->command_queue);
2523 }
2524
2525 static void run_kernel_tm (hc_device_param_t *device_param)
2526 {
2527 const uint num_elements = 1024; // fixed
2528
2529 uint kernel_threads = 32;
2530
2531 cl_kernel kernel = device_param->kernel_tm;
2532
2533 size_t workgroup_size = 0;
2534 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2535 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2536
2537 const size_t global_work_size[3] = { num_elements, 1, 1 };
2538 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2539
2540 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2541
2542 hc_clFlush (data.ocl, device_param->command_queue);
2543
2544 hc_clFinish (data.ocl, device_param->command_queue);
2545 }
2546
2547 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2548 {
2549 uint num_elements = num;
2550
2551 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2552 device_param->kernel_params_amp_buf32[6] = num_elements;
2553
2554 // causes problems with special threads like in bcrypt
2555 // const uint kernel_threads = device_param->kernel_threads;
2556
2557 uint kernel_threads = KERNEL_THREADS;
2558
2559 while (num_elements % kernel_threads) num_elements++;
2560
2561 cl_kernel kernel = device_param->kernel_amp;
2562
2563 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2564 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2565
2566 size_t workgroup_size = 0;
2567 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2568 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2569
2570 const size_t global_work_size[3] = { num_elements, 1, 1 };
2571 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2572
2573 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2574
2575 hc_clFlush (data.ocl, device_param->command_queue);
2576
2577 hc_clFinish (data.ocl, device_param->command_queue);
2578 }
2579
2580 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2581 {
2582 int rc = -1;
2583
2584 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2585 {
2586 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2587
2588 const cl_uchar zero = 0;
2589
2590 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2591 }
2592
2593 if (rc != 0)
2594 {
2595 // NOTE: clEnqueueFillBuffer () always fails with -59
2596 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2597 // How's that possible, OpenCL 1.2 support is advertised??
2598 // We need to workaround...
2599
2600 #define FILLSZ 0x100000
2601
2602 char *tmp = (char *) mymalloc (FILLSZ);
2603
2604 for (uint i = 0; i < size; i += FILLSZ)
2605 {
2606 const int left = size - i;
2607
2608 const int fillsz = MIN (FILLSZ, left);
2609
2610 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2611 }
2612
2613 myfree (tmp);
2614 }
2615 }
2616
2617 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)
2618 {
2619 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2620 {
2621 if (attack_mode == ATTACK_MODE_BF)
2622 {
2623 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2624 {
2625 const uint size_tm = 32 * sizeof (bs_word_t);
2626
2627 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2628
2629 run_kernel_tm (device_param);
2630
2631 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);
2632 }
2633 }
2634
2635 if (highest_pw_len < 16)
2636 {
2637 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2638 }
2639 else if (highest_pw_len < 32)
2640 {
2641 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2642 }
2643 else
2644 {
2645 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2646 }
2647 }
2648 else
2649 {
2650 run_kernel_amp (device_param, pws_cnt);
2651
2652 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2653
2654 if (opts_type & OPTS_TYPE_HOOK12)
2655 {
2656 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2657 }
2658
2659 uint iter = salt_buf->salt_iter;
2660
2661 uint loop_step = device_param->kernel_loops;
2662
2663 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2664 {
2665 uint loop_left = iter - loop_pos;
2666
2667 loop_left = MIN (loop_left, loop_step);
2668
2669 device_param->kernel_params_buf32[25] = loop_pos;
2670 device_param->kernel_params_buf32[26] = loop_left;
2671
2672 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2673
2674 if (data.devices_status == STATUS_CRACKED) break;
2675 if (data.devices_status == STATUS_ABORTED) break;
2676 if (data.devices_status == STATUS_QUIT) break;
2677
2678 /**
2679 * speed
2680 */
2681
2682 const float iter_part = (float) (loop_pos + loop_left) / iter;
2683
2684 const u64 perf_sum_all = pws_cnt * iter_part;
2685
2686 double speed_ms;
2687
2688 hc_timer_get (device_param->timer_speed, speed_ms);
2689
2690 const u32 speed_pos = device_param->speed_pos;
2691
2692 device_param->speed_cnt[speed_pos] = perf_sum_all;
2693
2694 device_param->speed_ms[speed_pos] = speed_ms;
2695 }
2696
2697 if (opts_type & OPTS_TYPE_HOOK23)
2698 {
2699 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2700
2701 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);
2702
2703 // do something with data
2704
2705 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);
2706 }
2707
2708 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2709 }
2710 }
2711
2712 static int run_rule_engine (const int rule_len, const char *rule_buf)
2713 {
2714 if (rule_len == 0)
2715 {
2716 return 0;
2717 }
2718 else if (rule_len == 1)
2719 {
2720 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2721 }
2722
2723 return 1;
2724 }
2725
2726 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2727 {
2728 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2729 {
2730 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);
2731 }
2732 else if (data.attack_kern == ATTACK_KERN_COMBI)
2733 {
2734 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2735 {
2736 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2737 {
2738 for (u32 i = 0; i < pws_cnt; i++)
2739 {
2740 const u32 pw_len = device_param->pws_buf[i].pw_len;
2741
2742 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2743
2744 ptr[pw_len] = 0x01;
2745 }
2746 }
2747 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2748 {
2749 for (u32 i = 0; i < pws_cnt; i++)
2750 {
2751 const u32 pw_len = device_param->pws_buf[i].pw_len;
2752
2753 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2754
2755 ptr[pw_len] = 0x80;
2756 }
2757 }
2758 }
2759
2760 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);
2761 }
2762 else if (data.attack_kern == ATTACK_KERN_BF)
2763 {
2764 const u64 off = device_param->words_off;
2765
2766 device_param->kernel_params_mp_l_buf64[3] = off;
2767
2768 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2769 }
2770 }
2771
2772 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops, const int repeat)
2773 {
2774 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2775
2776 device_param->kernel_params_buf32[26] = kernel_loops;
2777 device_param->kernel_params_buf32[27] = kernel_loops;
2778
2779 // init some fake words
2780
2781 for (u32 i = 0; i < kernel_power; i++)
2782 {
2783 device_param->pws_buf[i].i[0] = i;
2784 device_param->pws_buf[i].i[1] = 0x01234567;
2785 device_param->pws_buf[i].pw_len = 4 + (i & 3);
2786 }
2787
2788 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);
2789
2790 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2791 {
2792 run_kernel_amp (device_param, kernel_power);
2793 }
2794
2795 // caching run
2796
2797 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2798 {
2799 run_kernel (KERN_RUN_1, device_param, kernel_power, false);
2800 }
2801 else
2802 {
2803 run_kernel (KERN_RUN_2, device_param, kernel_power, false);
2804 }
2805
2806 // now user repeats
2807
2808 for (int i = 0; i < repeat; i++)
2809 {
2810 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2811 {
2812 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2813 }
2814 else
2815 {
2816 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2817 }
2818 }
2819
2820 const double exec_ms_prev = get_avg_exec_time (device_param, repeat);
2821
2822 // reset fake words
2823
2824 memset (device_param->pws_buf, 0, kernel_power * sizeof (pw_t));
2825
2826 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);
2827 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);
2828
2829 return exec_ms_prev;
2830 }
2831
2832 static void autotune (hc_device_param_t *device_param)
2833 {
2834 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2835
2836 const u32 kernel_accel_min = device_param->kernel_accel_min;
2837 const u32 kernel_accel_max = device_param->kernel_accel_max;
2838
2839 const u32 kernel_loops_min = device_param->kernel_loops_min;
2840 const u32 kernel_loops_max = device_param->kernel_loops_max;
2841
2842 u32 kernel_accel = kernel_accel_min;
2843 u32 kernel_loops = kernel_loops_min;
2844
2845 // steps
2846
2847 #define STEPS_CNT 10
2848
2849 #define STEPS_ACCEL_CNT (STEPS_CNT + 2)
2850 #define STEPS_LOOPS_CNT (STEPS_CNT + 2)
2851
2852 u32 steps_accel[STEPS_ACCEL_CNT];
2853 u32 steps_loops[STEPS_LOOPS_CNT];
2854
2855 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2856 {
2857 steps_accel[i] = 1 << i;
2858 }
2859
2860 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2861 {
2862 steps_loops[i] = 1 << i;
2863 }
2864
2865 steps_accel[STEPS_CNT + 0] = kernel_accel_min;
2866 steps_accel[STEPS_CNT + 1] = kernel_accel_max;
2867
2868 steps_loops[STEPS_CNT + 0] = kernel_loops_min;
2869 steps_loops[STEPS_CNT + 1] = kernel_loops_max;
2870
2871 qsort (steps_accel, STEPS_ACCEL_CNT, sizeof (u32), sort_by_u32);
2872 qsort (steps_loops, STEPS_LOOPS_CNT, sizeof (u32), sort_by_u32);
2873
2874 // find out highest kernel-loops that stays below target_ms, we can use it later for multiplication as this is a linear function
2875
2876 u32 kernel_loops_tmp;
2877
2878 for (kernel_loops_tmp = kernel_loops_max; kernel_loops_tmp > kernel_loops_min; kernel_loops_tmp >>= 1)
2879 {
2880 const double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops_tmp, 1);
2881
2882 if (exec_ms < target_ms) break;
2883 }
2884
2885 // kernel-accel
2886
2887 if (kernel_accel_min < kernel_accel_max)
2888 {
2889 double e_best = 0;
2890
2891 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2892 {
2893 const u32 kernel_accel_try = steps_accel[i];
2894
2895 if (kernel_accel_try < kernel_accel_min) continue;
2896 if (kernel_accel_try > kernel_accel_max) break;
2897
2898 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_tmp, 1);
2899
2900 if (exec_ms > target_ms) break;
2901
2902 const double e = kernel_accel_try / exec_ms;
2903
2904 if (e > e_best)
2905 {
2906 kernel_accel = kernel_accel_try;
2907
2908 e_best = e;
2909 }
2910 }
2911 }
2912
2913 // kernel-loops final
2914
2915 if (kernel_loops_min < kernel_loops_max)
2916 {
2917 double e_best = 0;
2918
2919 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2920 {
2921 const u32 kernel_loops_try = steps_loops[i];
2922
2923 if (kernel_loops_try < kernel_loops_min) continue;
2924 if (kernel_loops_try > kernel_loops_max) break;
2925
2926 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops_try, 1);
2927
2928 if (exec_ms > target_ms) break;
2929
2930 const double e = kernel_loops_try / exec_ms;
2931
2932 if (e > e_best)
2933 {
2934 kernel_loops = kernel_loops_try;
2935
2936 e_best = e;
2937 }
2938 }
2939 }
2940
2941 // final balance
2942
2943 u32 kernel_accel_best = kernel_accel;
2944 u32 kernel_loops_best = kernel_loops;
2945
2946 u32 exec_best = -1;
2947
2948 if ((kernel_accel_min < kernel_accel_max) || (kernel_loops_min < kernel_loops_max))
2949 {
2950 const double exec_ms = try_run (device_param, kernel_accel_best, kernel_loops_best, 1);
2951
2952 exec_best = exec_ms;
2953 }
2954
2955 // reset
2956
2957 if (kernel_accel_min < kernel_accel_max)
2958 {
2959 u32 kernel_accel_try = kernel_accel;
2960 u32 kernel_loops_try = kernel_loops;
2961
2962 for (int i = 0; i < 2; i++)
2963 {
2964 kernel_accel_try >>= 1;
2965 kernel_loops_try <<= 1;
2966
2967 if (kernel_accel_try < kernel_accel_min) break;
2968 if (kernel_loops_try > kernel_loops_max) break;
2969
2970 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
2971
2972 if (exec_ms < exec_best)
2973 {
2974 kernel_accel_best = kernel_accel_try;
2975 kernel_loops_best = kernel_loops_try;
2976
2977 exec_best = exec_ms;
2978 }
2979 }
2980 }
2981
2982 // reset
2983
2984 if (kernel_loops_min < kernel_loops_max)
2985 {
2986 u32 kernel_accel_try = kernel_accel;
2987 u32 kernel_loops_try = kernel_loops;
2988
2989 for (int i = 0; i < 2; i++)
2990 {
2991 kernel_accel_try <<= 1;
2992 kernel_loops_try >>= 1;
2993
2994 if (kernel_accel_try > kernel_accel_max) break;
2995 if (kernel_loops_try < kernel_loops_min) break;
2996
2997 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
2998
2999 if (exec_ms < exec_best)
3000 {
3001 kernel_accel_best = kernel_accel_try;
3002 kernel_loops_best = kernel_loops_try;
3003
3004 exec_best = exec_ms;
3005 }
3006 }
3007 }
3008
3009 // reset timer
3010
3011 device_param->exec_pos = 0;
3012
3013 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3014
3015 // store
3016
3017 kernel_accel = kernel_accel_best;
3018 kernel_loops = kernel_loops_best;
3019
3020 device_param->kernel_accel = kernel_accel;
3021 device_param->kernel_loops = kernel_loops;
3022
3023 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3024
3025 device_param->kernel_power = kernel_power;
3026
3027 #ifdef DEBUG
3028
3029 if (data.quiet == 0)
3030 {
3031 clear_prompt ();
3032
3033 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3034 "Device #%u: autotuned kernel-loops to %u\n",
3035 device_param->device_id + 1,
3036 kernel_accel,
3037 device_param->device_id + 1,
3038 kernel_loops);
3039
3040 fprintf (stdout, "%s", PROMPT);
3041 fflush (stdout);
3042 }
3043
3044 #endif
3045 }
3046
3047 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3048 {
3049 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3050
3051 // init speed timer
3052
3053 uint speed_pos = device_param->speed_pos;
3054
3055 #ifdef _POSIX
3056 if (device_param->timer_speed.tv_sec == 0)
3057 {
3058 hc_timer_set (&device_param->timer_speed);
3059 }
3060 #endif
3061
3062 #ifdef _WIN
3063 if (device_param->timer_speed.QuadPart == 0)
3064 {
3065 hc_timer_set (&device_param->timer_speed);
3066 }
3067 #endif
3068
3069 // find higest password length, this is for optimization stuff
3070
3071 uint highest_pw_len = 0;
3072
3073 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3074 {
3075 }
3076 else if (data.attack_kern == ATTACK_KERN_COMBI)
3077 {
3078 }
3079 else if (data.attack_kern == ATTACK_KERN_BF)
3080 {
3081 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3082 + device_param->kernel_params_mp_l_buf32[5];
3083 }
3084
3085 // iteration type
3086
3087 uint innerloop_step = 0;
3088 uint innerloop_cnt = 0;
3089
3090 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3091 else innerloop_step = 1;
3092
3093 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3094 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3095 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3096
3097 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3098
3099 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3100 {
3101 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3102
3103 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3104
3105 if (data.devices_status == STATUS_CRACKED) break;
3106 if (data.devices_status == STATUS_ABORTED) break;
3107 if (data.devices_status == STATUS_QUIT) break;
3108 if (data.devices_status == STATUS_BYPASS) break;
3109
3110 salt_t *salt_buf = &data.salts_buf[salt_pos];
3111
3112 device_param->kernel_params_buf32[24] = salt_pos;
3113 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3114 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3115
3116 FILE *combs_fp = device_param->combs_fp;
3117
3118 if (data.attack_mode == ATTACK_MODE_COMBI)
3119 {
3120 rewind (combs_fp);
3121 }
3122
3123 // innerloops
3124
3125 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3126 {
3127 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3128
3129 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3130
3131 if (data.devices_status == STATUS_CRACKED) break;
3132 if (data.devices_status == STATUS_ABORTED) break;
3133 if (data.devices_status == STATUS_QUIT) break;
3134 if (data.devices_status == STATUS_BYPASS) break;
3135
3136 uint innerloop_left = innerloop_cnt - innerloop_pos;
3137
3138 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3139
3140 device_param->innerloop_pos = innerloop_pos;
3141 device_param->innerloop_left = innerloop_left;
3142
3143 device_param->kernel_params_buf32[27] = innerloop_left;
3144
3145 // i think we can get rid of this
3146 if (innerloop_left == 0)
3147 {
3148 puts ("bug, how should this happen????\n");
3149
3150 continue;
3151 }
3152
3153 if (data.salts_shown[salt_pos] == 1)
3154 {
3155 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3156
3157 continue;
3158 }
3159
3160 // initialize amplifiers
3161
3162 if (data.attack_mode == ATTACK_MODE_COMBI)
3163 {
3164 uint i = 0;
3165
3166 while (i < innerloop_left)
3167 {
3168 if (feof (combs_fp)) break;
3169
3170 int line_len = fgetl (combs_fp, line_buf);
3171
3172 if (line_len >= PW_MAX1) continue;
3173
3174 line_len = convert_from_hex (line_buf, line_len);
3175
3176 char *line_buf_new = line_buf;
3177
3178 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3179 {
3180 char rule_buf_out[BLOCK_SIZE] = { 0 };
3181
3182 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3183
3184 if (rule_len_out < 0)
3185 {
3186 data.words_progress_rejected[salt_pos] += pws_cnt;
3187
3188 continue;
3189 }
3190
3191 line_len = rule_len_out;
3192
3193 line_buf_new = rule_buf_out;
3194 }
3195
3196 line_len = MIN (line_len, PW_DICTMAX);
3197
3198 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3199
3200 memcpy (ptr, line_buf_new, line_len);
3201
3202 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3203
3204 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3205 {
3206 uppercase (ptr, line_len);
3207 }
3208
3209 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3210 {
3211 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3212 {
3213 ptr[line_len] = 0x80;
3214 }
3215
3216 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3217 {
3218 ptr[line_len] = 0x01;
3219 }
3220 }
3221
3222 device_param->combs_buf[i].pw_len = line_len;
3223
3224 i++;
3225 }
3226
3227 for (uint j = i; j < innerloop_left; j++)
3228 {
3229 device_param->combs_buf[j].i[0] = 0;
3230 device_param->combs_buf[j].i[1] = 0;
3231 device_param->combs_buf[j].i[2] = 0;
3232 device_param->combs_buf[j].i[3] = 0;
3233 device_param->combs_buf[j].i[4] = 0;
3234 device_param->combs_buf[j].i[5] = 0;
3235 device_param->combs_buf[j].i[6] = 0;
3236 device_param->combs_buf[j].i[7] = 0;
3237
3238 device_param->combs_buf[j].pw_len = 0;
3239 }
3240
3241 innerloop_left = i;
3242 }
3243 else if (data.attack_mode == ATTACK_MODE_BF)
3244 {
3245 u64 off = innerloop_pos;
3246
3247 device_param->kernel_params_mp_r_buf64[3] = off;
3248
3249 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3250 }
3251 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3252 {
3253 u64 off = innerloop_pos;
3254
3255 device_param->kernel_params_mp_buf64[3] = off;
3256
3257 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3258 }
3259 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3260 {
3261 u64 off = innerloop_pos;
3262
3263 device_param->kernel_params_mp_buf64[3] = off;
3264
3265 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3266 }
3267
3268 // copy amplifiers
3269
3270 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3271 {
3272 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);
3273 }
3274 else if (data.attack_mode == ATTACK_MODE_COMBI)
3275 {
3276 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);
3277 }
3278 else if (data.attack_mode == ATTACK_MODE_BF)
3279 {
3280 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);
3281 }
3282 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3283 {
3284 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);
3285 }
3286 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3287 {
3288 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);
3289 }
3290
3291 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3292
3293 if (data.benchmark == 1)
3294 {
3295 double exec_ms_avg_prev = get_avg_exec_time (device_param, EXEC_CACHE);
3296
3297 // a few caching rounds
3298
3299 for (u32 i = 0; i < 2; i++)
3300 {
3301 hc_timer_set (&device_param->timer_speed);
3302
3303 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3304
3305 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
3306
3307 exec_ms_avg_prev = exec_ms_avg;
3308 }
3309
3310 // benchmark_repeats became a maximum possible repeats
3311
3312 for (u32 i = 2; i < data.benchmark_repeats; i++)
3313 {
3314 hc_timer_set (&device_param->timer_speed);
3315
3316 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3317
3318 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
3319
3320 if ((exec_ms_avg_prev / exec_ms_avg) < 1.001) break;
3321
3322 exec_ms_avg_prev = exec_ms_avg;
3323 }
3324 }
3325
3326 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3327
3328 if (data.devices_status == STATUS_CRACKED) break;
3329 if (data.devices_status == STATUS_ABORTED) break;
3330 if (data.devices_status == STATUS_QUIT) break;
3331
3332 /**
3333 * result
3334 */
3335
3336 hc_thread_mutex_lock (mux_display);
3337
3338 check_cracked (device_param, salt_pos);
3339
3340 hc_thread_mutex_unlock (mux_display);
3341
3342 /**
3343 * progress
3344 */
3345
3346 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3347
3348 hc_thread_mutex_lock (mux_counter);
3349
3350 data.words_progress_done[salt_pos] += perf_sum_all;
3351
3352 hc_thread_mutex_unlock (mux_counter);
3353
3354 /**
3355 * speed
3356 */
3357
3358 double speed_ms;
3359
3360 hc_timer_get (device_param->timer_speed, speed_ms);
3361
3362 hc_timer_set (&device_param->timer_speed);
3363
3364 hc_thread_mutex_lock (mux_display);
3365
3366 // current speed
3367
3368 device_param->speed_cnt[speed_pos] = perf_sum_all;
3369
3370 device_param->speed_ms[speed_pos] = speed_ms;
3371
3372 hc_thread_mutex_unlock (mux_display);
3373
3374 speed_pos++;
3375
3376 if (speed_pos == SPEED_CACHE)
3377 {
3378 speed_pos = 0;
3379 }
3380
3381 /**
3382 * benchmark
3383 */
3384
3385 if (data.benchmark == 1) break;
3386 }
3387 }
3388
3389 device_param->speed_pos = speed_pos;
3390
3391 myfree (line_buf);
3392 }
3393
3394 static void load_segment (wl_data_t *wl_data, FILE *fd)
3395 {
3396 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3397
3398 wl_data->pos = 0;
3399
3400 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3401
3402 wl_data->buf[wl_data->cnt] = 0;
3403
3404 if (wl_data->cnt == 0) return;
3405
3406 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3407
3408 while (!feof (fd))
3409 {
3410 if (wl_data->cnt == wl_data->avail)
3411 {
3412 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3413
3414 wl_data->avail += wl_data->incr;
3415 }
3416
3417 const int c = fgetc (fd);
3418
3419 if (c == EOF) break;
3420
3421 wl_data->buf[wl_data->cnt] = (char) c;
3422
3423 wl_data->cnt++;
3424
3425 if (c == '\n') break;
3426 }
3427
3428 // ensure stream ends with a newline
3429
3430 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3431 {
3432 wl_data->cnt++;
3433
3434 wl_data->buf[wl_data->cnt - 1] = '\n';
3435 }
3436
3437 return;
3438 }
3439
3440 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3441 {
3442 char *ptr = buf;
3443
3444 for (u32 i = 0; i < sz; i++, ptr++)
3445 {
3446 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3447
3448 if (i == 7)
3449 {
3450 *off = i;
3451 *len = i;
3452
3453 return;
3454 }
3455
3456 if (*ptr != '\n') continue;
3457
3458 *off = i + 1;
3459
3460 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3461
3462 *len = i;
3463
3464 return;
3465 }
3466
3467 *off = sz;
3468 *len = sz;
3469 }
3470
3471 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3472 {
3473 char *ptr = buf;
3474
3475 for (u32 i = 0; i < sz; i++, ptr++)
3476 {
3477 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3478
3479 if (*ptr != '\n') continue;
3480
3481 *off = i + 1;
3482
3483 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3484
3485 *len = i;
3486
3487 return;
3488 }
3489
3490 *off = sz;
3491 *len = sz;
3492 }
3493
3494 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3495 {
3496 char *ptr = buf;
3497
3498 for (u32 i = 0; i < sz; i++, ptr++)
3499 {
3500 if (*ptr != '\n') continue;
3501
3502 *off = i + 1;
3503
3504 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3505
3506 *len = i;
3507
3508 return;
3509 }
3510
3511 *off = sz;
3512 *len = sz;
3513 }
3514
3515 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3516 {
3517 while (wl_data->pos < wl_data->cnt)
3518 {
3519 uint off;
3520 uint len;
3521
3522 char *ptr = wl_data->buf + wl_data->pos;
3523
3524 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3525
3526 wl_data->pos += off;
3527
3528 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3529 {
3530 char rule_buf_out[BLOCK_SIZE] = { 0 };
3531
3532 int rule_len_out = -1;
3533
3534 if (len < BLOCK_SIZE)
3535 {
3536 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3537 }
3538
3539 if (rule_len_out < 0)
3540 {
3541 continue;
3542 }
3543
3544 if (rule_len_out > PW_MAX)
3545 {
3546 continue;
3547 }
3548 }
3549 else
3550 {
3551 if (len > PW_MAX)
3552 {
3553 continue;
3554 }
3555 }
3556
3557 *out_buf = ptr;
3558 *out_len = len;
3559
3560 return;
3561 }
3562
3563 if (feof (fd))
3564 {
3565 fprintf (stderr, "BUG feof()!!\n");
3566
3567 return;
3568 }
3569
3570 load_segment (wl_data, fd);
3571
3572 get_next_word (wl_data, fd, out_buf, out_len);
3573 }
3574
3575 #ifdef _POSIX
3576 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3577 #endif
3578
3579 #ifdef _WIN
3580 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3581 #endif
3582 {
3583 hc_signal (NULL);
3584
3585 dictstat_t d;
3586
3587 d.cnt = 0;
3588
3589 #ifdef _POSIX
3590 fstat (fileno (fd), &d.stat);
3591 #endif
3592
3593 #ifdef _WIN
3594 _fstat64 (fileno (fd), &d.stat);
3595 #endif
3596
3597 d.stat.st_mode = 0;
3598 d.stat.st_nlink = 0;
3599 d.stat.st_uid = 0;
3600 d.stat.st_gid = 0;
3601 d.stat.st_rdev = 0;
3602 d.stat.st_atime = 0;
3603
3604 #ifdef _POSIX
3605 d.stat.st_blksize = 0;
3606 d.stat.st_blocks = 0;
3607 #endif
3608
3609 if (d.stat.st_size == 0) return 0;
3610
3611 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3612
3613 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3614 {
3615 if (d_cache)
3616 {
3617 u64 cnt = d_cache->cnt;
3618
3619 u64 keyspace = cnt;
3620
3621 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3622 {
3623 keyspace *= data.kernel_rules_cnt;
3624 }
3625 else if (data.attack_kern == ATTACK_KERN_COMBI)
3626 {
3627 keyspace *= data.combs_cnt;
3628 }
3629
3630 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);
3631 if (data.quiet == 0) log_info ("");
3632
3633 hc_signal (sigHandler_default);
3634
3635 return (keyspace);
3636 }
3637 }
3638
3639 time_t now = 0;
3640 time_t prev = 0;
3641
3642 u64 comp = 0;
3643 u64 cnt = 0;
3644 u64 cnt2 = 0;
3645
3646 while (!feof (fd))
3647 {
3648 load_segment (wl_data, fd);
3649
3650 comp += wl_data->cnt;
3651
3652 u32 i = 0;
3653
3654 while (i < wl_data->cnt)
3655 {
3656 u32 len;
3657 u32 off;
3658
3659 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3660
3661 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3662 {
3663 char rule_buf_out[BLOCK_SIZE] = { 0 };
3664
3665 int rule_len_out = -1;
3666
3667 if (len < BLOCK_SIZE)
3668 {
3669 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3670 }
3671
3672 if (rule_len_out < 0)
3673 {
3674 len = PW_MAX1;
3675 }
3676 else
3677 {
3678 len = rule_len_out;
3679 }
3680 }
3681
3682 if (len < PW_MAX1)
3683 {
3684 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3685 {
3686 cnt += data.kernel_rules_cnt;
3687 }
3688 else if (data.attack_kern == ATTACK_KERN_COMBI)
3689 {
3690 cnt += data.combs_cnt;
3691 }
3692
3693 d.cnt++;
3694 }
3695
3696 i += off;
3697
3698 cnt2++;
3699 }
3700
3701 time (&now);
3702
3703 if ((now - prev) == 0) continue;
3704
3705 float percent = (float) comp / (float) d.stat.st_size;
3706
3707 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);
3708
3709 time (&prev);
3710 }
3711
3712 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);
3713 if (data.quiet == 0) log_info ("");
3714
3715 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3716
3717 hc_signal (sigHandler_default);
3718
3719 return (cnt);
3720 }
3721
3722 static void *thread_monitor (void *p)
3723 {
3724 uint runtime_check = 0;
3725 uint remove_check = 0;
3726 uint status_check = 0;
3727 uint restore_check = 0;
3728
3729 uint restore_left = data.restore_timer;
3730 uint remove_left = data.remove_timer;
3731 uint status_left = data.status_timer;
3732
3733 #ifdef HAVE_HWMON
3734 uint hwmon_check = 0;
3735
3736 // these variables are mainly used for fan control (AMD only)
3737
3738 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3739
3740 // temperature controller "loopback" values
3741
3742 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3743 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3744
3745 #ifdef HAVE_ADL
3746 int temp_threshold = 1; // degrees celcius
3747
3748 int fan_speed_min = 15; // in percentage
3749 int fan_speed_max = 100;
3750 #endif // HAVE_ADL
3751
3752 time_t last_temp_check_time;
3753 #endif // HAVE_HWMON
3754
3755 uint sleep_time = 1;
3756
3757 if (data.runtime)
3758 {
3759 runtime_check = 1;
3760 }
3761
3762 if (data.restore_timer)
3763 {
3764 restore_check = 1;
3765 }
3766
3767 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3768 {
3769 remove_check = 1;
3770 }
3771
3772 if (data.status == 1)
3773 {
3774 status_check = 1;
3775 }
3776
3777 #ifdef HAVE_HWMON
3778 if (data.gpu_temp_disable == 0)
3779 {
3780 time (&last_temp_check_time);
3781
3782 hwmon_check = 1;
3783 }
3784 #endif
3785
3786 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3787 {
3788 #ifdef HAVE_HWMON
3789 if (hwmon_check == 0)
3790 #endif
3791 return (p);
3792 }
3793
3794 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3795 {
3796 hc_sleep (sleep_time);
3797
3798 if (data.devices_status != STATUS_RUNNING) continue;
3799
3800 #ifdef HAVE_HWMON
3801 if (hwmon_check == 1)
3802 {
3803 hc_thread_mutex_lock (mux_adl);
3804
3805 time_t temp_check_time;
3806
3807 time (&temp_check_time);
3808
3809 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3810
3811 if (Ta == 0) Ta = 1;
3812
3813 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3814 {
3815 hc_device_param_t *device_param = &data.devices_param[device_id];
3816
3817 if (device_param->skipped) continue;
3818
3819 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3820
3821 const int temperature = hm_get_temperature_with_device_id (device_id);
3822
3823 if (temperature > (int) data.gpu_temp_abort)
3824 {
3825 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3826
3827 if (data.devices_status != STATUS_QUIT) myabort ();
3828
3829 break;
3830 }
3831
3832 #ifdef HAVE_ADL
3833 const int gpu_temp_retain = data.gpu_temp_retain;
3834
3835 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3836 {
3837 if (data.hm_device[device_id].fan_supported == 1)
3838 {
3839 int temp_cur = temperature;
3840
3841 int temp_diff_new = gpu_temp_retain - temp_cur;
3842
3843 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3844
3845 // calculate Ta value (time difference in seconds between the last check and this check)
3846
3847 last_temp_check_time = temp_check_time;
3848
3849 float Kp = 1.8;
3850 float Ki = 0.005;
3851 float Kd = 6;
3852
3853 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3854
3855 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);
3856
3857 if (abs (fan_diff_required) >= temp_threshold)
3858 {
3859 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3860
3861 int fan_speed_level = fan_speed_cur;
3862
3863 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3864
3865 int fan_speed_new = fan_speed_level - fan_diff_required;
3866
3867 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3868 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3869
3870 if (fan_speed_new != fan_speed_cur)
3871 {
3872 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3873 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3874
3875 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3876 {
3877 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3878
3879 fan_speed_chgd[device_id] = 1;
3880 }
3881
3882 temp_diff_old[device_id] = temp_diff_new;
3883 }
3884 }
3885 }
3886 }
3887 #endif // HAVE_ADL
3888 }
3889
3890 hc_thread_mutex_unlock (mux_adl);
3891 }
3892 #endif // HAVE_HWMON
3893
3894 if (restore_check == 1)
3895 {
3896 restore_left--;
3897
3898 if (restore_left == 0)
3899 {
3900 if (data.restore_disable == 0) cycle_restore ();
3901
3902 restore_left = data.restore_timer;
3903 }
3904 }
3905
3906 if ((runtime_check == 1) && (data.runtime_start > 0))
3907 {
3908 time_t runtime_cur;
3909
3910 time (&runtime_cur);
3911
3912 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3913
3914 if (runtime_left <= 0)
3915 {
3916 if (data.benchmark == 0)
3917 {
3918 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3919 }
3920
3921 if (data.devices_status != STATUS_QUIT) myabort ();
3922 }
3923 }
3924
3925 if (remove_check == 1)
3926 {
3927 remove_left--;
3928
3929 if (remove_left == 0)
3930 {
3931 if (data.digests_saved != data.digests_done)
3932 {
3933 data.digests_saved = data.digests_done;
3934
3935 save_hash ();
3936 }
3937
3938 remove_left = data.remove_timer;
3939 }
3940 }
3941
3942 if (status_check == 1)
3943 {
3944 status_left--;
3945
3946 if (status_left == 0)
3947 {
3948 hc_thread_mutex_lock (mux_display);
3949
3950 if (data.quiet == 0) clear_prompt ();
3951
3952 if (data.quiet == 0) log_info ("");
3953
3954 status_display ();
3955
3956 if (data.quiet == 0) log_info ("");
3957
3958 hc_thread_mutex_unlock (mux_display);
3959
3960 status_left = data.status_timer;
3961 }
3962 }
3963 }
3964
3965 #ifdef HAVE_HWMON
3966 myfree (fan_speed_chgd);
3967
3968 myfree (temp_diff_old);
3969 myfree (temp_diff_sum);
3970 #endif
3971
3972 p = NULL;
3973
3974 return (p);
3975 }
3976
3977 static void *thread_outfile_remove (void *p)
3978 {
3979 // some hash-dependent constants
3980 char *outfile_dir = data.outfile_check_directory;
3981 uint dgst_size = data.dgst_size;
3982 uint isSalted = data.isSalted;
3983 uint esalt_size = data.esalt_size;
3984 uint hash_mode = data.hash_mode;
3985
3986 uint outfile_check_timer = data.outfile_check_timer;
3987
3988 char separator = data.separator;
3989
3990 // some hash-dependent functions
3991 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3992 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3993
3994 // buffers
3995 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3996
3997 hash_buf.digest = mymalloc (dgst_size);
3998
3999 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4000
4001 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4002
4003 uint digest_buf[64] = { 0 };
4004
4005 outfile_data_t *out_info = NULL;
4006
4007 char **out_files = NULL;
4008
4009 time_t folder_mtime = 0;
4010
4011 int out_cnt = 0;
4012
4013 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4014
4015 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4016 {
4017 hc_sleep (1);
4018
4019 if (data.devices_status != STATUS_RUNNING) continue;
4020
4021 check_left--;
4022
4023 if (check_left == 0)
4024 {
4025 struct stat outfile_check_stat;
4026
4027 if (stat (outfile_dir, &outfile_check_stat) == 0)
4028 {
4029 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4030
4031 if (is_dir == 1)
4032 {
4033 if (outfile_check_stat.st_mtime > folder_mtime)
4034 {
4035 char **out_files_new = scan_directory (outfile_dir);
4036
4037 int out_cnt_new = count_dictionaries (out_files_new);
4038
4039 outfile_data_t *out_info_new = NULL;
4040
4041 if (out_cnt_new > 0)
4042 {
4043 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4044
4045 for (int i = 0; i < out_cnt_new; i++)
4046 {
4047 out_info_new[i].file_name = out_files_new[i];
4048
4049 // check if there are files that we have seen/checked before (and not changed)
4050
4051 for (int j = 0; j < out_cnt; j++)
4052 {
4053 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4054 {
4055 struct stat outfile_stat;
4056
4057 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4058 {
4059 if (outfile_stat.st_ctime == out_info[j].ctime)
4060 {
4061 out_info_new[i].ctime = out_info[j].ctime;
4062 out_info_new[i].seek = out_info[j].seek;
4063 }
4064 }
4065 }
4066 }
4067 }
4068 }
4069
4070 local_free (out_info);
4071 local_free (out_files);
4072
4073 out_files = out_files_new;
4074 out_cnt = out_cnt_new;
4075 out_info = out_info_new;
4076
4077 folder_mtime = outfile_check_stat.st_mtime;
4078 }
4079
4080 for (int j = 0; j < out_cnt; j++)
4081 {
4082 FILE *fp = fopen (out_info[j].file_name, "rb");
4083
4084 if (fp != NULL)
4085 {
4086 //hc_thread_mutex_lock (mux_display);
4087
4088 #ifdef _POSIX
4089 struct stat outfile_stat;
4090
4091 fstat (fileno (fp), &outfile_stat);
4092 #endif
4093
4094 #ifdef _WIN
4095 struct stat64 outfile_stat;
4096
4097 _fstat64 (fileno (fp), &outfile_stat);
4098 #endif
4099
4100 if (outfile_stat.st_ctime > out_info[j].ctime)
4101 {
4102 out_info[j].ctime = outfile_stat.st_ctime;
4103 out_info[j].seek = 0;
4104 }
4105
4106 fseek (fp, out_info[j].seek, SEEK_SET);
4107
4108 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4109
4110 while (!feof (fp))
4111 {
4112 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4113
4114 if (ptr == NULL) break;
4115
4116 int line_len = strlen (line_buf);
4117
4118 if (line_len <= 0) continue;
4119
4120 int iter = MAX_CUT_TRIES;
4121
4122 for (uint i = line_len - 1; i && iter; i--, line_len--)
4123 {
4124 if (line_buf[i] != separator) continue;
4125
4126 int parser_status = PARSER_OK;
4127
4128 if ((hash_mode != 2500) && (hash_mode != 6800))
4129 {
4130 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4131 }
4132
4133 uint found = 0;
4134
4135 if (parser_status == PARSER_OK)
4136 {
4137 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4138 {
4139 if (data.salts_shown[salt_pos] == 1) continue;
4140
4141 salt_t *salt_buf = &data.salts_buf[salt_pos];
4142
4143 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4144 {
4145 uint idx = salt_buf->digests_offset + digest_pos;
4146
4147 if (data.digests_shown[idx] == 1) continue;
4148
4149 uint cracked = 0;
4150
4151 if (hash_mode == 6800)
4152 {
4153 if (i == salt_buf->salt_len)
4154 {
4155 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4156 }
4157 }
4158 else if (hash_mode == 2500)
4159 {
4160 // BSSID : MAC1 : MAC2 (:plain)
4161 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4162 {
4163 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4164
4165 if (!cracked) continue;
4166
4167 // now compare MAC1 and MAC2 too, since we have this additional info
4168 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4169 char *mac2_pos = mac1_pos + 12 + 1;
4170
4171 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4172 wpa_t *wpa = &wpas[salt_pos];
4173
4174 // compare hex string(s) vs binary MAC address(es)
4175
4176 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4177 {
4178 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4179 {
4180 cracked = 0;
4181
4182 break;
4183 }
4184 }
4185
4186 // early skip ;)
4187 if (!cracked) continue;
4188
4189 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4190 {
4191 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4192 {
4193 cracked = 0;
4194
4195 break;
4196 }
4197 }
4198 }
4199 }
4200 else
4201 {
4202 char *digests_buf_ptr = (char *) data.digests_buf;
4203
4204 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4205
4206 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4207 }
4208
4209 if (cracked == 1)
4210 {
4211 found = 1;
4212
4213 data.digests_shown[idx] = 1;
4214
4215 data.digests_done++;
4216
4217 salt_buf->digests_done++;
4218
4219 if (salt_buf->digests_done == salt_buf->digests_cnt)
4220 {
4221 data.salts_shown[salt_pos] = 1;
4222
4223 data.salts_done++;
4224
4225 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4226 }
4227 }
4228 }
4229
4230 if (data.devices_status == STATUS_CRACKED) break;
4231 }
4232 }
4233
4234 if (found) break;
4235
4236 if (data.devices_status == STATUS_CRACKED) break;
4237
4238 iter--;
4239 }
4240
4241 if (data.devices_status == STATUS_CRACKED) break;
4242 }
4243
4244 myfree (line_buf);
4245
4246 out_info[j].seek = ftell (fp);
4247
4248 //hc_thread_mutex_unlock (mux_display);
4249
4250 fclose (fp);
4251 }
4252 }
4253 }
4254 }
4255
4256 check_left = outfile_check_timer;
4257 }
4258 }
4259
4260 if (esalt_size) local_free (hash_buf.esalt);
4261
4262 if (isSalted) local_free (hash_buf.salt);
4263
4264 local_free (hash_buf.digest);
4265
4266 local_free (out_info);
4267
4268 local_free (out_files);
4269
4270 p = NULL;
4271
4272 return (p);
4273 }
4274
4275 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4276 {
4277 if (device_param->pws_cnt < device_param->kernel_power)
4278 {
4279 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4280
4281 u8 *ptr = (u8 *) pw->i;
4282
4283 memcpy (ptr, pw_buf, pw_len);
4284
4285 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4286
4287 pw->pw_len = pw_len;
4288
4289 device_param->pws_cnt++;
4290 }
4291 else
4292 {
4293 fprintf (stderr, "BUG pw_add()!!\n");
4294
4295 return;
4296 }
4297 }
4298
4299 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4300 {
4301 hc_thread_mutex_lock (mux_dispatcher);
4302
4303 const u64 words_cur = data.words_cur;
4304 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4305
4306 device_param->words_off = words_cur;
4307
4308 const u64 words_left = words_base - words_cur;
4309
4310 if (allow_div)
4311 {
4312 if (data.kernel_power_all > words_left)
4313 {
4314 if (data.kernel_power_div == 0)
4315 {
4316 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4317 }
4318 }
4319
4320 if (data.kernel_power_div)
4321 {
4322 if (device_param->kernel_power == device_param->kernel_power_user)
4323 {
4324 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4325
4326 if (kernel_power_new < device_param->kernel_power)
4327 {
4328 device_param->kernel_power = kernel_power_new;
4329 }
4330 }
4331 }
4332 }
4333
4334 const uint kernel_power = device_param->kernel_power;
4335
4336 uint work = MIN (words_left, kernel_power);
4337
4338 work = MIN (work, max);
4339
4340 data.words_cur += work;
4341
4342 hc_thread_mutex_unlock (mux_dispatcher);
4343
4344 return work;
4345 }
4346
4347 static void *thread_calc_stdin (void *p)
4348 {
4349 hc_device_param_t *device_param = (hc_device_param_t *) p;
4350
4351 if (device_param->skipped) return NULL;
4352
4353 autotune (device_param);
4354
4355 char *buf = (char *) mymalloc (HCBUFSIZ);
4356
4357 const uint attack_kern = data.attack_kern;
4358
4359 const uint kernel_power = device_param->kernel_power;
4360
4361 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4362 {
4363 hc_thread_mutex_lock (mux_dispatcher);
4364
4365 if (feof (stdin) != 0)
4366 {
4367 hc_thread_mutex_unlock (mux_dispatcher);
4368
4369 break;
4370 }
4371
4372 uint words_cur = 0;
4373
4374 while (words_cur < kernel_power)
4375 {
4376 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4377
4378 if (line_buf == NULL) break;
4379
4380 uint line_len = in_superchop (line_buf);
4381
4382 line_len = convert_from_hex (line_buf, line_len);
4383
4384 // post-process rule engine
4385
4386 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4387 {
4388 char rule_buf_out[BLOCK_SIZE] = { 0 };
4389
4390 int rule_len_out = -1;
4391
4392 if (line_len < BLOCK_SIZE)
4393 {
4394 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4395 }
4396
4397 if (rule_len_out < 0) continue;
4398
4399 line_buf = rule_buf_out;
4400 line_len = rule_len_out;
4401 }
4402
4403 if (line_len > PW_MAX)
4404 {
4405 continue;
4406 }
4407
4408 if (attack_kern == ATTACK_KERN_STRAIGHT)
4409 {
4410 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4411 {
4412 hc_thread_mutex_lock (mux_counter);
4413
4414 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4415 {
4416 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4417 }
4418
4419 hc_thread_mutex_unlock (mux_counter);
4420
4421 continue;
4422 }
4423 }
4424 else if (attack_kern == ATTACK_KERN_COMBI)
4425 {
4426 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4427 // since we still need to combine the plains
4428
4429 if (line_len > data.pw_max)
4430 {
4431 hc_thread_mutex_lock (mux_counter);
4432
4433 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4434 {
4435 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4436 }
4437
4438 hc_thread_mutex_unlock (mux_counter);
4439
4440 continue;
4441 }
4442 }
4443
4444 pw_add (device_param, (u8 *) line_buf, line_len);
4445
4446 words_cur++;
4447
4448 if (data.devices_status == STATUS_CRACKED) break;
4449 if (data.devices_status == STATUS_ABORTED) break;
4450 if (data.devices_status == STATUS_QUIT) break;
4451 if (data.devices_status == STATUS_BYPASS) break;
4452 }
4453
4454 hc_thread_mutex_unlock (mux_dispatcher);
4455
4456 if (data.devices_status == STATUS_CRACKED) break;
4457 if (data.devices_status == STATUS_ABORTED) break;
4458 if (data.devices_status == STATUS_QUIT) break;
4459 if (data.devices_status == STATUS_BYPASS) break;
4460
4461 // flush
4462
4463 const uint pws_cnt = device_param->pws_cnt;
4464
4465 if (pws_cnt)
4466 {
4467 run_copy (device_param, pws_cnt);
4468
4469 run_cracker (device_param, pws_cnt);
4470
4471 device_param->pws_cnt = 0;
4472
4473 if (attack_kern == ATTACK_KERN_STRAIGHT)
4474 {
4475 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4476 }
4477 else if (attack_kern == ATTACK_KERN_COMBI)
4478 {
4479 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4480 }
4481 }
4482 }
4483
4484 device_param->kernel_accel = 0;
4485 device_param->kernel_loops = 0;
4486
4487 myfree (buf);
4488
4489 return NULL;
4490 }
4491
4492 static void *thread_calc (void *p)
4493 {
4494 hc_device_param_t *device_param = (hc_device_param_t *) p;
4495
4496 if (device_param->skipped) return NULL;
4497
4498 autotune (device_param);
4499
4500 const uint attack_mode = data.attack_mode;
4501 const uint attack_kern = data.attack_kern;
4502
4503 if (attack_mode == ATTACK_MODE_BF)
4504 {
4505 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4506 {
4507 const uint work = get_work (device_param, -1, true);
4508
4509 if (work == 0) break;
4510
4511 const u64 words_off = device_param->words_off;
4512 const u64 words_fin = words_off + work;
4513
4514 const uint pws_cnt = work;
4515
4516 device_param->pws_cnt = pws_cnt;
4517
4518 if (pws_cnt)
4519 {
4520 run_copy (device_param, pws_cnt);
4521
4522 run_cracker (device_param, pws_cnt);
4523
4524 device_param->pws_cnt = 0;
4525
4526 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4527 }
4528
4529 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4530
4531 if (data.devices_status == STATUS_CRACKED) break;
4532 if (data.devices_status == STATUS_ABORTED) break;
4533 if (data.devices_status == STATUS_QUIT) break;
4534 if (data.devices_status == STATUS_BYPASS) break;
4535
4536 if (data.benchmark == 1) break;
4537
4538 device_param->words_done = words_fin;
4539 }
4540 }
4541 else
4542 {
4543 const uint segment_size = data.segment_size;
4544
4545 char *dictfile = data.dictfile;
4546
4547 if (attack_mode == ATTACK_MODE_COMBI)
4548 {
4549 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4550 {
4551 dictfile = data.dictfile2;
4552 }
4553 }
4554
4555 FILE *fd = fopen (dictfile, "rb");
4556
4557 if (fd == NULL)
4558 {
4559 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4560
4561 return NULL;
4562 }
4563
4564 if (attack_mode == ATTACK_MODE_COMBI)
4565 {
4566 const uint combs_mode = data.combs_mode;
4567
4568 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4569 {
4570 const char *dictfilec = data.dictfile2;
4571
4572 FILE *combs_fp = fopen (dictfilec, "rb");
4573
4574 if (combs_fp == NULL)
4575 {
4576 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4577
4578 fclose (fd);
4579
4580 return NULL;
4581 }
4582
4583 device_param->combs_fp = combs_fp;
4584 }
4585 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4586 {
4587 const char *dictfilec = data.dictfile;
4588
4589 FILE *combs_fp = fopen (dictfilec, "rb");
4590
4591 if (combs_fp == NULL)
4592 {
4593 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4594
4595 fclose (fd);
4596
4597 return NULL;
4598 }
4599
4600 device_param->combs_fp = combs_fp;
4601 }
4602 }
4603
4604 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4605
4606 wl_data->buf = (char *) mymalloc (segment_size);
4607 wl_data->avail = segment_size;
4608 wl_data->incr = segment_size;
4609 wl_data->cnt = 0;
4610 wl_data->pos = 0;
4611
4612 u64 words_cur = 0;
4613
4614 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4615 {
4616 u64 words_off = 0;
4617 u64 words_fin = 0;
4618
4619 bool allow_div = true;
4620
4621 u64 max = -1;
4622
4623 while (max)
4624 {
4625 const uint work = get_work (device_param, max, allow_div);
4626
4627 allow_div = false;
4628
4629 if (work == 0) break;
4630
4631 words_off = device_param->words_off;
4632 words_fin = words_off + work;
4633
4634 char *line_buf;
4635 uint line_len;
4636
4637 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4638
4639 max = 0;
4640
4641 for ( ; words_cur < words_fin; words_cur++)
4642 {
4643 get_next_word (wl_data, fd, &line_buf, &line_len);
4644
4645 line_len = convert_from_hex (line_buf, line_len);
4646
4647 // post-process rule engine
4648
4649 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4650 {
4651 char rule_buf_out[BLOCK_SIZE] = { 0 };
4652
4653 int rule_len_out = -1;
4654
4655 if (line_len < BLOCK_SIZE)
4656 {
4657 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4658 }
4659
4660 if (rule_len_out < 0) continue;
4661
4662 line_buf = rule_buf_out;
4663 line_len = rule_len_out;
4664 }
4665
4666 if (attack_kern == ATTACK_KERN_STRAIGHT)
4667 {
4668 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4669 {
4670 max++;
4671
4672 hc_thread_mutex_lock (mux_counter);
4673
4674 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4675 {
4676 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4677 }
4678
4679 hc_thread_mutex_unlock (mux_counter);
4680
4681 continue;
4682 }
4683 }
4684 else if (attack_kern == ATTACK_KERN_COMBI)
4685 {
4686 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4687 // since we still need to combine the plains
4688
4689 if (line_len > data.pw_max)
4690 {
4691 max++;
4692
4693 hc_thread_mutex_lock (mux_counter);
4694
4695 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4696 {
4697 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4698 }
4699
4700 hc_thread_mutex_unlock (mux_counter);
4701
4702 continue;
4703 }
4704 }
4705
4706 pw_add (device_param, (u8 *) line_buf, line_len);
4707
4708 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4709
4710 if (data.devices_status == STATUS_CRACKED) break;
4711 if (data.devices_status == STATUS_ABORTED) break;
4712 if (data.devices_status == STATUS_QUIT) break;
4713 if (data.devices_status == STATUS_BYPASS) break;
4714 }
4715
4716 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4717
4718 if (data.devices_status == STATUS_CRACKED) break;
4719 if (data.devices_status == STATUS_ABORTED) break;
4720 if (data.devices_status == STATUS_QUIT) break;
4721 if (data.devices_status == STATUS_BYPASS) break;
4722 }
4723
4724 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4725
4726 if (data.devices_status == STATUS_CRACKED) break;
4727 if (data.devices_status == STATUS_ABORTED) break;
4728 if (data.devices_status == STATUS_QUIT) break;
4729 if (data.devices_status == STATUS_BYPASS) break;
4730
4731 //
4732 // flush
4733 //
4734
4735 const uint pws_cnt = device_param->pws_cnt;
4736
4737 if (pws_cnt)
4738 {
4739 run_copy (device_param, pws_cnt);
4740
4741 run_cracker (device_param, pws_cnt);
4742
4743 device_param->pws_cnt = 0;
4744
4745 if (attack_kern == ATTACK_KERN_STRAIGHT)
4746 {
4747 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4748 }
4749 else if (attack_kern == ATTACK_KERN_COMBI)
4750 {
4751 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4752 }
4753 }
4754
4755 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4756
4757 if (data.devices_status == STATUS_CRACKED) break;
4758 if (data.devices_status == STATUS_ABORTED) break;
4759 if (data.devices_status == STATUS_QUIT) break;
4760 if (data.devices_status == STATUS_BYPASS) break;
4761
4762 if (words_fin == 0) break;
4763
4764 device_param->words_done = words_fin;
4765 }
4766
4767 if (attack_mode == ATTACK_MODE_COMBI)
4768 {
4769 fclose (device_param->combs_fp);
4770 }
4771
4772 free (wl_data->buf);
4773 free (wl_data);
4774
4775 fclose (fd);
4776 }
4777
4778 device_param->kernel_accel = 0;
4779 device_param->kernel_loops = 0;
4780
4781 return NULL;
4782 }
4783
4784 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4785 {
4786 if (!device_param)
4787 {
4788 log_error ("ERROR: %s : Invalid argument", __func__);
4789
4790 exit (-1);
4791 }
4792
4793 salt_t *salt_buf = &data.salts_buf[salt_pos];
4794
4795 device_param->kernel_params_buf32[24] = salt_pos;
4796 device_param->kernel_params_buf32[27] = 1;
4797 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4798 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4799 device_param->kernel_params_buf32[30] = 0;
4800 device_param->kernel_params_buf32[31] = 1;
4801
4802 char *dictfile_old = data.dictfile;
4803
4804 const char *weak_hash_check = "weak-hash-check";
4805
4806 data.dictfile = (char *) weak_hash_check;
4807
4808 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4809
4810 data.kernel_rules_buf[0].cmds[0] = 0;
4811
4812 /**
4813 * run the kernel
4814 */
4815
4816 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4817 {
4818 run_kernel (KERN_RUN_1, device_param, 1, false);
4819 }
4820 else
4821 {
4822 run_kernel (KERN_RUN_1, device_param, 1, false);
4823
4824 uint loop_step = 16;
4825
4826 const uint iter = salt_buf->salt_iter;
4827
4828 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4829 {
4830 uint loop_left = iter - loop_pos;
4831
4832 loop_left = MIN (loop_left, loop_step);
4833
4834 device_param->kernel_params_buf32[25] = loop_pos;
4835 device_param->kernel_params_buf32[26] = loop_left;
4836
4837 run_kernel (KERN_RUN_2, device_param, 1, false);
4838 }
4839
4840 run_kernel (KERN_RUN_3, device_param, 1, false);
4841 }
4842
4843 /**
4844 * result
4845 */
4846
4847 check_cracked (device_param, salt_pos);
4848
4849 /**
4850 * cleanup
4851 */
4852
4853 device_param->kernel_params_buf32[24] = 0;
4854 device_param->kernel_params_buf32[25] = 0;
4855 device_param->kernel_params_buf32[26] = 0;
4856 device_param->kernel_params_buf32[27] = 0;
4857 device_param->kernel_params_buf32[28] = 0;
4858 device_param->kernel_params_buf32[29] = 0;
4859 device_param->kernel_params_buf32[30] = 0;
4860 device_param->kernel_params_buf32[31] = 0;
4861
4862 data.dictfile = dictfile_old;
4863
4864 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4865 }
4866
4867 // hlfmt hashcat
4868
4869 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4870 {
4871 if (data.username == 0)
4872 {
4873 *hashbuf_pos = line_buf;
4874 *hashbuf_len = line_len;
4875 }
4876 else
4877 {
4878 char *pos = line_buf;
4879 int len = line_len;
4880
4881 for (int i = 0; i < line_len; i++, pos++, len--)
4882 {
4883 if (line_buf[i] == data.separator)
4884 {
4885 pos++;
4886
4887 len--;
4888
4889 break;
4890 }
4891 }
4892
4893 *hashbuf_pos = pos;
4894 *hashbuf_len = len;
4895 }
4896 }
4897
4898 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4899 {
4900 char *pos = NULL;
4901 int len = 0;
4902
4903 int sep_cnt = 0;
4904
4905 for (int i = 0; i < line_len; i++)
4906 {
4907 if (line_buf[i] == data.separator)
4908 {
4909 sep_cnt++;
4910
4911 continue;
4912 }
4913
4914 if (sep_cnt == 0)
4915 {
4916 if (pos == NULL) pos = line_buf + i;
4917
4918 len++;
4919 }
4920 }
4921
4922 *userbuf_pos = pos;
4923 *userbuf_len = len;
4924 }
4925
4926 // hlfmt pwdump
4927
4928 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4929 {
4930 int sep_cnt = 0;
4931
4932 int sep2_len = 0;
4933 int sep3_len = 0;
4934
4935 for (int i = 0; i < line_len; i++)
4936 {
4937 if (line_buf[i] == ':')
4938 {
4939 sep_cnt++;
4940
4941 continue;
4942 }
4943
4944 if (sep_cnt == 2) sep2_len++;
4945 if (sep_cnt == 3) sep3_len++;
4946 }
4947
4948 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4949
4950 return 0;
4951 }
4952
4953 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4954 {
4955 char *pos = NULL;
4956 int len = 0;
4957
4958 int sep_cnt = 0;
4959
4960 for (int i = 0; i < line_len; i++)
4961 {
4962 if (line_buf[i] == ':')
4963 {
4964 sep_cnt++;
4965
4966 continue;
4967 }
4968
4969 if (data.hash_mode == 1000)
4970 {
4971 if (sep_cnt == 3)
4972 {
4973 if (pos == NULL) pos = line_buf + i;
4974
4975 len++;
4976 }
4977 }
4978 else if (data.hash_mode == 3000)
4979 {
4980 if (sep_cnt == 2)
4981 {
4982 if (pos == NULL) pos = line_buf + i;
4983
4984 len++;
4985 }
4986 }
4987 }
4988
4989 *hashbuf_pos = pos;
4990 *hashbuf_len = len;
4991 }
4992
4993 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4994 {
4995 char *pos = NULL;
4996 int len = 0;
4997
4998 int sep_cnt = 0;
4999
5000 for (int i = 0; i < line_len; i++)
5001 {
5002 if (line_buf[i] == ':')
5003 {
5004 sep_cnt++;
5005
5006 continue;
5007 }
5008
5009 if (sep_cnt == 0)
5010 {
5011 if (pos == NULL) pos = line_buf + i;
5012
5013 len++;
5014 }
5015 }
5016
5017 *userbuf_pos = pos;
5018 *userbuf_len = len;
5019 }
5020
5021 // hlfmt passwd
5022
5023 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5024 {
5025 int sep_cnt = 0;
5026
5027 char sep5_first = 0;
5028 char sep6_first = 0;
5029
5030 for (int i = 0; i < line_len; i++)
5031 {
5032 if (line_buf[i] == ':')
5033 {
5034 sep_cnt++;
5035
5036 continue;
5037 }
5038
5039 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5040 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5041 }
5042
5043 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5044
5045 return 0;
5046 }
5047
5048 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5049 {
5050 char *pos = NULL;
5051 int len = 0;
5052
5053 int sep_cnt = 0;
5054
5055 for (int i = 0; i < line_len; i++)
5056 {
5057 if (line_buf[i] == ':')
5058 {
5059 sep_cnt++;
5060
5061 continue;
5062 }
5063
5064 if (sep_cnt == 1)
5065 {
5066 if (pos == NULL) pos = line_buf + i;
5067
5068 len++;
5069 }
5070 }
5071
5072 *hashbuf_pos = pos;
5073 *hashbuf_len = len;
5074 }
5075
5076 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5077 {
5078 char *pos = NULL;
5079 int len = 0;
5080
5081 int sep_cnt = 0;
5082
5083 for (int i = 0; i < line_len; i++)
5084 {
5085 if (line_buf[i] == ':')
5086 {
5087 sep_cnt++;
5088
5089 continue;
5090 }
5091
5092 if (sep_cnt == 0)
5093 {
5094 if (pos == NULL) pos = line_buf + i;
5095
5096 len++;
5097 }
5098 }
5099
5100 *userbuf_pos = pos;
5101 *userbuf_len = len;
5102 }
5103
5104 // hlfmt shadow
5105
5106 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5107 {
5108 int sep_cnt = 0;
5109
5110 for (int i = 0; i < line_len; i++)
5111 {
5112 if (line_buf[i] == ':') sep_cnt++;
5113 }
5114
5115 if (sep_cnt == 8) return 1;
5116
5117 return 0;
5118 }
5119
5120 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5121 {
5122 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5123 }
5124
5125 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5126 {
5127 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5128 }
5129
5130 // hlfmt main
5131
5132 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5133 {
5134 switch (hashfile_format)
5135 {
5136 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5137 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5138 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5139 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5140 }
5141 }
5142
5143 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5144 {
5145 switch (hashfile_format)
5146 {
5147 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5148 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5149 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5150 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5151 }
5152 }
5153
5154 char *strhlfmt (const uint hashfile_format)
5155 {
5156 switch (hashfile_format)
5157 {
5158 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5159 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5160 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5161 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5162 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5163 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5164 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5165 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5166 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5167 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5168 }
5169
5170 return ((char *) "Unknown");
5171 }
5172
5173 static uint hlfmt_detect (FILE *fp, uint max_check)
5174 {
5175 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5176
5177 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5178 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5179
5180 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5181
5182 uint num_check = 0;
5183
5184 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5185
5186 while (!feof (fp))
5187 {
5188 int line_len = fgetl (fp, line_buf);
5189
5190 if (line_len == 0) continue;
5191
5192 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5193 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5194 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5195
5196 if (num_check == max_check) break;
5197
5198 num_check++;
5199 }
5200
5201 myfree (line_buf);
5202
5203 uint hashlist_format = HLFMT_HASHCAT;
5204
5205 for (int i = 1; i < HLFMTS_CNT; i++)
5206 {
5207 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5208
5209 hashlist_format = i;
5210 }
5211
5212 free (formats_cnt);
5213
5214 return hashlist_format;
5215 }
5216
5217 /**
5218 * some further helper function
5219 */
5220
5221 // wrapper around mymalloc for ADL
5222
5223 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5224 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5225 {
5226 return mymalloc (iSize);
5227 }
5228 #endif
5229
5230 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)
5231 {
5232 u64 collisions = 0;
5233
5234 const uint dgst_pos0 = data.dgst_pos0;
5235 const uint dgst_pos1 = data.dgst_pos1;
5236 const uint dgst_pos2 = data.dgst_pos2;
5237 const uint dgst_pos3 = data.dgst_pos3;
5238
5239 memset (bitmap_a, 0, bitmap_size);
5240 memset (bitmap_b, 0, bitmap_size);
5241 memset (bitmap_c, 0, bitmap_size);
5242 memset (bitmap_d, 0, bitmap_size);
5243
5244 for (uint i = 0; i < digests_cnt; i++)
5245 {
5246 uint *digest_ptr = (uint *) digests_buf_ptr;
5247
5248 digests_buf_ptr += dgst_size;
5249
5250 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5251 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5252 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5253 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5254
5255 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5256 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5257 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5258 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5259
5260 if (bitmap_a[idx0] & val0) collisions++;
5261 if (bitmap_b[idx1] & val1) collisions++;
5262 if (bitmap_c[idx2] & val2) collisions++;
5263 if (bitmap_d[idx3] & val3) collisions++;
5264
5265 bitmap_a[idx0] |= val0;
5266 bitmap_b[idx1] |= val1;
5267 bitmap_c[idx2] |= val2;
5268 bitmap_d[idx3] |= val3;
5269
5270 if (collisions >= collisions_max) return 0x7fffffff;
5271 }
5272
5273 return collisions;
5274 }
5275
5276 /**
5277 * main
5278 */
5279
5280 int main (int argc, char **argv)
5281 {
5282 /**
5283 * To help users a bit
5284 */
5285
5286 char *compute = getenv ("COMPUTE");
5287
5288 if (compute)
5289 {
5290 static char display[100];
5291
5292 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5293
5294 putenv (display);
5295 }
5296 else
5297 {
5298 if (getenv ("DISPLAY") == NULL)
5299 putenv ((char *) "DISPLAY=:0");
5300 }
5301
5302 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5303 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5304
5305 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5306 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5307
5308 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5309 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5310
5311 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5312 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5313
5314 /**
5315 * Real init
5316 */
5317
5318 memset (&data, 0, sizeof (hc_global_data_t));
5319
5320 time_t proc_start;
5321
5322 time (&proc_start);
5323
5324 data.proc_start = proc_start;
5325
5326 int myargc = argc;
5327 char **myargv = argv;
5328
5329 hc_thread_mutex_init (mux_dispatcher);
5330 hc_thread_mutex_init (mux_counter);
5331 hc_thread_mutex_init (mux_display);
5332 hc_thread_mutex_init (mux_adl);
5333
5334 /**
5335 * commandline parameters
5336 */
5337
5338 uint usage = USAGE;
5339 uint version = VERSION;
5340 uint quiet = QUIET;
5341 uint benchmark = BENCHMARK;
5342 uint benchmark_repeats = BENCHMARK_REPEATS;
5343 uint show = SHOW;
5344 uint left = LEFT;
5345 uint username = USERNAME;
5346 uint remove = REMOVE;
5347 uint remove_timer = REMOVE_TIMER;
5348 u64 skip = SKIP;
5349 u64 limit = LIMIT;
5350 uint keyspace = KEYSPACE;
5351 uint potfile_disable = POTFILE_DISABLE;
5352 char *potfile_path = NULL;
5353 uint debug_mode = DEBUG_MODE;
5354 char *debug_file = NULL;
5355 char *induction_dir = NULL;
5356 char *outfile_check_dir = NULL;
5357 uint force = FORCE;
5358 uint runtime = RUNTIME;
5359 uint hash_mode = HASH_MODE;
5360 uint attack_mode = ATTACK_MODE;
5361 uint markov_disable = MARKOV_DISABLE;
5362 uint markov_classic = MARKOV_CLASSIC;
5363 uint markov_threshold = MARKOV_THRESHOLD;
5364 char *markov_hcstat = NULL;
5365 char *outfile = NULL;
5366 uint outfile_format = OUTFILE_FORMAT;
5367 uint outfile_autohex = OUTFILE_AUTOHEX;
5368 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5369 uint restore = RESTORE;
5370 uint restore_timer = RESTORE_TIMER;
5371 uint restore_disable = RESTORE_DISABLE;
5372 uint status = STATUS;
5373 uint status_timer = STATUS_TIMER;
5374 uint status_automat = STATUS_AUTOMAT;
5375 uint loopback = LOOPBACK;
5376 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5377 char *session = NULL;
5378 uint hex_charset = HEX_CHARSET;
5379 uint hex_salt = HEX_SALT;
5380 uint hex_wordlist = HEX_WORDLIST;
5381 uint rp_gen = RP_GEN;
5382 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5383 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5384 uint rp_gen_seed = RP_GEN_SEED;
5385 char *rule_buf_l = (char *) RULE_BUF_L;
5386 char *rule_buf_r = (char *) RULE_BUF_R;
5387 uint increment = INCREMENT;
5388 uint increment_min = INCREMENT_MIN;
5389 uint increment_max = INCREMENT_MAX;
5390 char *cpu_affinity = NULL;
5391 OCL_PTR *ocl = NULL;
5392 char *opencl_devices = NULL;
5393 char *opencl_platforms = NULL;
5394 char *opencl_device_types = NULL;
5395 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5396 char *truecrypt_keyfiles = NULL;
5397 uint workload_profile = WORKLOAD_PROFILE;
5398 uint kernel_accel = KERNEL_ACCEL;
5399 uint kernel_loops = KERNEL_LOOPS;
5400 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5401 #ifdef HAVE_HWMON
5402 uint gpu_temp_abort = GPU_TEMP_ABORT;
5403 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5404 #ifdef HAVE_ADL
5405 uint powertune_enable = POWERTUNE_ENABLE;
5406 #endif
5407 #endif
5408 uint logfile_disable = LOGFILE_DISABLE;
5409 uint segment_size = SEGMENT_SIZE;
5410 uint scrypt_tmto = SCRYPT_TMTO;
5411 char separator = SEPARATOR;
5412 uint bitmap_min = BITMAP_MIN;
5413 uint bitmap_max = BITMAP_MAX;
5414 char *custom_charset_1 = NULL;
5415 char *custom_charset_2 = NULL;
5416 char *custom_charset_3 = NULL;
5417 char *custom_charset_4 = NULL;
5418
5419 #define IDX_HELP 'h'
5420 #define IDX_VERSION 'V'
5421 #define IDX_VERSION_LOWER 'v'
5422 #define IDX_QUIET 0xff02
5423 #define IDX_SHOW 0xff03
5424 #define IDX_LEFT 0xff04
5425 #define IDX_REMOVE 0xff05
5426 #define IDX_REMOVE_TIMER 0xff37
5427 #define IDX_SKIP 's'
5428 #define IDX_LIMIT 'l'
5429 #define IDX_KEYSPACE 0xff35
5430 #define IDX_POTFILE_DISABLE 0xff06
5431 #define IDX_POTFILE_PATH 0xffe0
5432 #define IDX_DEBUG_MODE 0xff43
5433 #define IDX_DEBUG_FILE 0xff44
5434 #define IDX_INDUCTION_DIR 0xff46
5435 #define IDX_OUTFILE_CHECK_DIR 0xff47
5436 #define IDX_USERNAME 0xff07
5437 #define IDX_FORCE 0xff08
5438 #define IDX_RUNTIME 0xff09
5439 #define IDX_BENCHMARK 'b'
5440 #define IDX_BENCHMARK_REPEATS 0xff78
5441 #define IDX_HASH_MODE 'm'
5442 #define IDX_ATTACK_MODE 'a'
5443 #define IDX_RP_FILE 'r'
5444 #define IDX_RP_GEN 'g'
5445 #define IDX_RP_GEN_FUNC_MIN 0xff10
5446 #define IDX_RP_GEN_FUNC_MAX 0xff11
5447 #define IDX_RP_GEN_SEED 0xff34
5448 #define IDX_RULE_BUF_L 'j'
5449 #define IDX_RULE_BUF_R 'k'
5450 #define IDX_INCREMENT 'i'
5451 #define IDX_INCREMENT_MIN 0xff12
5452 #define IDX_INCREMENT_MAX 0xff13
5453 #define IDX_OUTFILE 'o'
5454 #define IDX_OUTFILE_FORMAT 0xff14
5455 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5456 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5457 #define IDX_RESTORE 0xff15
5458 #define IDX_RESTORE_DISABLE 0xff27
5459 #define IDX_STATUS 0xff17
5460 #define IDX_STATUS_TIMER 0xff18
5461 #define IDX_STATUS_AUTOMAT 0xff50
5462 #define IDX_LOOPBACK 0xff38
5463 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5464 #define IDX_SESSION 0xff19
5465 #define IDX_HEX_CHARSET 0xff20
5466 #define IDX_HEX_SALT 0xff21
5467 #define IDX_HEX_WORDLIST 0xff40
5468 #define IDX_MARKOV_DISABLE 0xff22
5469 #define IDX_MARKOV_CLASSIC 0xff23
5470 #define IDX_MARKOV_THRESHOLD 't'
5471 #define IDX_MARKOV_HCSTAT 0xff24
5472 #define IDX_CPU_AFFINITY 0xff25
5473 #define IDX_OPENCL_DEVICES 'd'
5474 #define IDX_OPENCL_PLATFORMS 0xff72
5475 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5476 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5477 #define IDX_WORKLOAD_PROFILE 'w'
5478 #define IDX_KERNEL_ACCEL 'n'
5479 #define IDX_KERNEL_LOOPS 'u'
5480 #define IDX_GPU_TEMP_DISABLE 0xff29
5481 #define IDX_GPU_TEMP_ABORT 0xff30
5482 #define IDX_GPU_TEMP_RETAIN 0xff31
5483 #define IDX_POWERTUNE_ENABLE 0xff41
5484 #define IDX_LOGFILE_DISABLE 0xff51
5485 #define IDX_TRUECRYPT_KEYFILES 0xff52
5486 #define IDX_SCRYPT_TMTO 0xff61
5487 #define IDX_SEGMENT_SIZE 'c'
5488 #define IDX_SEPARATOR 'p'
5489 #define IDX_BITMAP_MIN 0xff70
5490 #define IDX_BITMAP_MAX 0xff71
5491 #define IDX_CUSTOM_CHARSET_1 '1'
5492 #define IDX_CUSTOM_CHARSET_2 '2'
5493 #define IDX_CUSTOM_CHARSET_3 '3'
5494 #define IDX_CUSTOM_CHARSET_4 '4'
5495
5496 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5497
5498 struct option long_options[] =
5499 {
5500 {"help", no_argument, 0, IDX_HELP},
5501 {"version", no_argument, 0, IDX_VERSION},
5502 {"quiet", no_argument, 0, IDX_QUIET},
5503 {"show", no_argument, 0, IDX_SHOW},
5504 {"left", no_argument, 0, IDX_LEFT},
5505 {"username", no_argument, 0, IDX_USERNAME},
5506 {"remove", no_argument, 0, IDX_REMOVE},
5507 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5508 {"skip", required_argument, 0, IDX_SKIP},
5509 {"limit", required_argument, 0, IDX_LIMIT},
5510 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5511 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5512 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5513 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5514 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5515 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5516 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5517 {"force", no_argument, 0, IDX_FORCE},
5518 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5519 {"benchmark-repeats", required_argument, 0, IDX_BENCHMARK_REPEATS},
5520 {"restore", no_argument, 0, IDX_RESTORE},
5521 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5522 {"status", no_argument, 0, IDX_STATUS},
5523 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5524 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5525 {"loopback", no_argument, 0, IDX_LOOPBACK},
5526 {"weak-hash-threshold",
5527 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5528 {"session", required_argument, 0, IDX_SESSION},
5529 {"runtime", required_argument, 0, IDX_RUNTIME},
5530 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5531 {"generate-rules-func-min",
5532 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5533 {"generate-rules-func-max",
5534 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5535 {"generate-rules-seed",
5536 required_argument, 0, IDX_RP_GEN_SEED},
5537 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5538 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5539 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5540 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5541 {"rules-file", required_argument, 0, IDX_RP_FILE},
5542 {"outfile", required_argument, 0, IDX_OUTFILE},
5543 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5544 {"outfile-autohex-disable",
5545 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5546 {"outfile-check-timer",
5547 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5548 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5549 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5550 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5551 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5552 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5553 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5554 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5555 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5556 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5557 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5558 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5559 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5560 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5561 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5562 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5563 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5564 #ifdef HAVE_HWMON
5565 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5566 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5567 #ifdef HAVE_ADL
5568 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5569 #endif
5570 #endif // HAVE_HWMON
5571 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5572 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5573 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5574 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5575 // deprecated
5576 {"seperator", required_argument, 0, IDX_SEPARATOR},
5577 {"separator", required_argument, 0, IDX_SEPARATOR},
5578 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5579 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5580 {"increment", no_argument, 0, IDX_INCREMENT},
5581 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5582 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5583 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5584 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5585 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5586 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5587
5588 {0, 0, 0, 0}
5589 };
5590
5591 uint rp_files_cnt = 0;
5592
5593 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5594
5595 int option_index = 0;
5596 int c = -1;
5597
5598 optind = 1;
5599 optopt = 0;
5600
5601 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5602 {
5603 switch (c)
5604 {
5605 case IDX_HELP: usage = 1; break;
5606 case IDX_VERSION:
5607 case IDX_VERSION_LOWER: version = 1; break;
5608 case IDX_RESTORE: restore = 1; break;
5609 case IDX_SESSION: session = optarg; break;
5610 case IDX_SHOW: show = 1; break;
5611 case IDX_LEFT: left = 1; break;
5612 case '?': return (-1);
5613 }
5614 }
5615
5616 if (optopt != 0)
5617 {
5618 log_error ("ERROR: Invalid argument specified");
5619
5620 return (-1);
5621 }
5622
5623 /**
5624 * exit functions
5625 */
5626
5627 if (version)
5628 {
5629 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5630
5631 return (0);
5632 }
5633
5634 if (usage)
5635 {
5636 usage_big_print (PROGNAME);
5637
5638 return (0);
5639 }
5640
5641 /**
5642 * session needs to be set, always!
5643 */
5644
5645 if (session == NULL) session = (char *) PROGNAME;
5646
5647 /**
5648 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5649 */
5650
5651 char *exec_path = get_exec_path ();
5652
5653 #ifdef LINUX
5654
5655 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5656 char *resolved_exec_path = realpath (exec_path, NULL);
5657
5658 char *install_dir = get_install_dir (resolved_exec_path);
5659 char *profile_dir = NULL;
5660 char *session_dir = NULL;
5661 char *shared_dir = NULL;
5662
5663 if (strcmp (install_dir, resolved_install_folder) == 0)
5664 {
5665 struct passwd *pw = getpwuid (getuid ());
5666
5667 const char *homedir = pw->pw_dir;
5668
5669 profile_dir = get_profile_dir (homedir);
5670 session_dir = get_session_dir (profile_dir);
5671 shared_dir = strdup (SHARED_FOLDER);
5672
5673 mkdir (profile_dir, 0700);
5674 mkdir (session_dir, 0700);
5675 }
5676 else
5677 {
5678 profile_dir = install_dir;
5679 session_dir = install_dir;
5680 shared_dir = install_dir;
5681 }
5682
5683 myfree (resolved_install_folder);
5684 myfree (resolved_exec_path);
5685
5686 #else
5687
5688 char *install_dir = get_install_dir (exec_path);
5689 char *profile_dir = install_dir;
5690 char *session_dir = install_dir;
5691 char *shared_dir = install_dir;
5692
5693 #endif
5694
5695 data.install_dir = install_dir;
5696 data.profile_dir = profile_dir;
5697 data.session_dir = session_dir;
5698 data.shared_dir = shared_dir;
5699
5700 myfree (exec_path);
5701
5702 /**
5703 * kernel cache, we need to make sure folder exist
5704 */
5705
5706 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5707
5708 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5709
5710 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5711
5712 mkdir (kernels_folder, 0700);
5713
5714 myfree (kernels_folder);
5715
5716 /**
5717 * session
5718 */
5719
5720 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5721
5722 data.session = session;
5723
5724 char *eff_restore_file = (char *) mymalloc (session_size);
5725 char *new_restore_file = (char *) mymalloc (session_size);
5726
5727 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5728 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5729
5730 data.eff_restore_file = eff_restore_file;
5731 data.new_restore_file = new_restore_file;
5732
5733 if (((show == 1) || (left == 1)) && (restore == 1))
5734 {
5735 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5736 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5737
5738 return (-1);
5739 }
5740
5741 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5742 if ((show == 1) || (left == 1))
5743 {
5744 restore_disable = 1;
5745
5746 restore = 0;
5747 }
5748
5749 data.restore_disable = restore_disable;
5750
5751 restore_data_t *rd = init_restore (argc, argv);
5752
5753 data.rd = rd;
5754
5755 /**
5756 * restore file
5757 */
5758
5759 if (restore == 1)
5760 {
5761 read_restore (eff_restore_file, rd);
5762
5763 if (rd->version_bin < RESTORE_MIN)
5764 {
5765 log_error ("ERROR: Incompatible restore-file version");
5766
5767 return (-1);
5768 }
5769
5770 myargc = rd->argc;
5771 myargv = rd->argv;
5772
5773 #ifdef _POSIX
5774 rd->pid = getpid ();
5775 #elif _WIN
5776 rd->pid = GetCurrentProcessId ();
5777 #endif
5778 }
5779
5780 uint hash_mode_chgd = 0;
5781 uint runtime_chgd = 0;
5782 uint kernel_loops_chgd = 0;
5783 uint kernel_accel_chgd = 0;
5784 uint attack_mode_chgd = 0;
5785 uint outfile_format_chgd = 0;
5786 uint rp_gen_seed_chgd = 0;
5787 uint remove_timer_chgd = 0;
5788 uint increment_min_chgd = 0;
5789 uint increment_max_chgd = 0;
5790 uint workload_profile_chgd = 0;
5791 uint opencl_vector_width_chgd = 0;
5792
5793 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5794 uint gpu_temp_retain_chgd = 0;
5795 uint gpu_temp_abort_chgd = 0;
5796 #endif
5797
5798 optind = 1;
5799 optopt = 0;
5800 option_index = 0;
5801
5802 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5803 {
5804 switch (c)
5805 {
5806 //case IDX_HELP: usage = 1; break;
5807 //case IDX_VERSION: version = 1; break;
5808 //case IDX_RESTORE: restore = 1; break;
5809 case IDX_QUIET: quiet = 1; break;
5810 //case IDX_SHOW: show = 1; break;
5811 case IDX_SHOW: break;
5812 //case IDX_LEFT: left = 1; break;
5813 case IDX_LEFT: break;
5814 case IDX_USERNAME: username = 1; break;
5815 case IDX_REMOVE: remove = 1; break;
5816 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5817 remove_timer_chgd = 1; break;
5818 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5819 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5820 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5821 case IDX_DEBUG_FILE: debug_file = optarg; break;
5822 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5823 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5824 case IDX_FORCE: force = 1; break;
5825 case IDX_SKIP: skip = atoll (optarg); break;
5826 case IDX_LIMIT: limit = atoll (optarg); break;
5827 case IDX_KEYSPACE: keyspace = 1; break;
5828 case IDX_BENCHMARK: benchmark = 1; break;
5829 case IDX_BENCHMARK_REPEATS: benchmark_repeats = atoi (optarg); break;
5830 case IDX_RESTORE: break;
5831 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5832 case IDX_STATUS: status = 1; break;
5833 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5834 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5835 case IDX_LOOPBACK: loopback = 1; break;
5836 case IDX_WEAK_HASH_THRESHOLD:
5837 weak_hash_threshold = atoi (optarg); break;
5838 //case IDX_SESSION: session = optarg; break;
5839 case IDX_SESSION: break;
5840 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5841 hash_mode_chgd = 1; break;
5842 case IDX_RUNTIME: runtime = atoi (optarg);
5843 runtime_chgd = 1; break;
5844 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5845 attack_mode_chgd = 1; break;
5846 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5847 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5848 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5849 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5850 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5851 rp_gen_seed_chgd = 1; break;
5852 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5853 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5854 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5855 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5856 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5857 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5858 case IDX_OUTFILE: outfile = optarg; break;
5859 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5860 outfile_format_chgd = 1; break;
5861 case IDX_OUTFILE_AUTOHEX_DISABLE:
5862 outfile_autohex = 0; break;
5863 case IDX_OUTFILE_CHECK_TIMER:
5864 outfile_check_timer = atoi (optarg); break;
5865 case IDX_HEX_CHARSET: hex_charset = 1; break;
5866 case IDX_HEX_SALT: hex_salt = 1; break;
5867 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5868 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5869 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5870 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5871 case IDX_OPENCL_DEVICE_TYPES:
5872 opencl_device_types = optarg; break;
5873 case IDX_OPENCL_VECTOR_WIDTH:
5874 opencl_vector_width = atoi (optarg);
5875 opencl_vector_width_chgd = 1; break;
5876 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5877 workload_profile_chgd = 1; break;
5878 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5879 kernel_accel_chgd = 1; break;
5880 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5881 kernel_loops_chgd = 1; break;
5882 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5883 #ifdef HAVE_HWMON
5884 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5885 #ifdef HAVE_ADL
5886 gpu_temp_abort_chgd = 1;
5887 #endif
5888 break;
5889 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5890 #ifdef HAVE_ADL
5891 gpu_temp_retain_chgd = 1;
5892 #endif
5893 break;
5894 #ifdef HAVE_ADL
5895 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5896 #endif
5897 #endif // HAVE_HWMON
5898 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5899 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5900 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5901 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5902 case IDX_SEPARATOR: separator = optarg[0]; break;
5903 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5904 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5905 case IDX_INCREMENT: increment = 1; break;
5906 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5907 increment_min_chgd = 1; break;
5908 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5909 increment_max_chgd = 1; break;
5910 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5911 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5912 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5913 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5914
5915 default:
5916 log_error ("ERROR: Invalid argument specified");
5917 return (-1);
5918 }
5919 }
5920
5921 if (optopt != 0)
5922 {
5923 log_error ("ERROR: Invalid argument specified");
5924
5925 return (-1);
5926 }
5927
5928 /**
5929 * Inform user things getting started,
5930 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5931 * - we do not need to check algorithm_pos
5932 */
5933
5934 if (quiet == 0)
5935 {
5936 if (benchmark == 1)
5937 {
5938 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5939
5940 log_info ("");
5941 }
5942 else if (restore == 1)
5943 {
5944 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5945
5946 log_info ("");
5947 }
5948 else
5949 {
5950 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5951
5952 log_info ("");
5953 }
5954 }
5955
5956 /**
5957 * sanity check
5958 */
5959
5960 if (attack_mode > 7)
5961 {
5962 log_error ("ERROR: Invalid attack-mode specified");
5963
5964 return (-1);
5965 }
5966
5967 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5968 {
5969 log_error ("ERROR: Invalid runtime specified");
5970
5971 return (-1);
5972 }
5973
5974 if (hash_mode_chgd && hash_mode > 13400) // just added to remove compiler warnings for hash_mode_chgd
5975 {
5976 log_error ("ERROR: Invalid hash-type specified");
5977
5978 return (-1);
5979 }
5980
5981 // renamed hash modes
5982
5983 if (hash_mode_chgd)
5984 {
5985 int n = -1;
5986
5987 switch (hash_mode)
5988 {
5989 case 123: n = 124;
5990 break;
5991 }
5992
5993 if (n >= 0)
5994 {
5995 log_error ("Old -m specified, use -m %d instead", n);
5996
5997 return (-1);
5998 }
5999 }
6000
6001 if (username == 1)
6002 {
6003 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
6004 {
6005 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6006
6007 return (-1);
6008 }
6009 }
6010
6011 if (outfile_format > 16)
6012 {
6013 log_error ("ERROR: Invalid outfile-format specified");
6014
6015 return (-1);
6016 }
6017
6018 if (left == 1)
6019 {
6020 if (outfile_format_chgd == 1)
6021 {
6022 if (outfile_format > 1)
6023 {
6024 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6025
6026 return (-1);
6027 }
6028 }
6029 else
6030 {
6031 outfile_format = OUTFILE_FMT_HASH;
6032 }
6033 }
6034
6035 if (show == 1)
6036 {
6037 if (outfile_format_chgd == 1)
6038 {
6039 if ((outfile_format > 7) && (outfile_format < 16))
6040 {
6041 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6042
6043 return (-1);
6044 }
6045 }
6046 }
6047
6048 if (increment_min < INCREMENT_MIN)
6049 {
6050 log_error ("ERROR: Invalid increment-min specified");
6051
6052 return (-1);
6053 }
6054
6055 if (increment_max > INCREMENT_MAX)
6056 {
6057 log_error ("ERROR: Invalid increment-max specified");
6058
6059 return (-1);
6060 }
6061
6062 if (increment_min > increment_max)
6063 {
6064 log_error ("ERROR: Invalid increment-min specified");
6065
6066 return (-1);
6067 }
6068
6069 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6070 {
6071 log_error ("ERROR: increment is not allowed in attack-mode 0");
6072
6073 return (-1);
6074 }
6075
6076 if ((increment == 0) && (increment_min_chgd == 1))
6077 {
6078 log_error ("ERROR: increment-min is only supported together with increment switch");
6079
6080 return (-1);
6081 }
6082
6083 if ((increment == 0) && (increment_max_chgd == 1))
6084 {
6085 log_error ("ERROR: increment-max is only supported together with increment switch");
6086
6087 return (-1);
6088 }
6089
6090 if (rp_files_cnt && rp_gen)
6091 {
6092 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6093
6094 return (-1);
6095 }
6096
6097 if (rp_files_cnt || rp_gen)
6098 {
6099 if (attack_mode != ATTACK_MODE_STRAIGHT)
6100 {
6101 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6102
6103 return (-1);
6104 }
6105 }
6106
6107 if (rp_gen_func_min > rp_gen_func_max)
6108 {
6109 log_error ("ERROR: Invalid rp-gen-func-min specified");
6110
6111 return (-1);
6112 }
6113
6114 if (kernel_accel_chgd == 1)
6115 {
6116 if (kernel_accel < 1)
6117 {
6118 log_error ("ERROR: Invalid kernel-accel specified");
6119
6120 return (-1);
6121 }
6122
6123 if (kernel_accel > 1024)
6124 {
6125 log_error ("ERROR: Invalid kernel-accel specified");
6126
6127 return (-1);
6128 }
6129 }
6130
6131 if (kernel_loops_chgd == 1)
6132 {
6133 if (kernel_loops < 1)
6134 {
6135 log_error ("ERROR: Invalid kernel-loops specified");
6136
6137 return (-1);
6138 }
6139
6140 if (kernel_loops > 1024)
6141 {
6142 log_error ("ERROR: Invalid kernel-loops specified");
6143
6144 return (-1);
6145 }
6146 }
6147
6148 if ((workload_profile < 1) || (workload_profile > 3))
6149 {
6150 log_error ("ERROR: workload-profile %i not available", workload_profile);
6151
6152 return (-1);
6153 }
6154
6155 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6156 {
6157 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6158
6159 return (-1);
6160 }
6161
6162 if (show == 1 || left == 1)
6163 {
6164 attack_mode = ATTACK_MODE_NONE;
6165
6166 if (remove == 1)
6167 {
6168 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6169
6170 return (-1);
6171 }
6172
6173 if (potfile_disable == 1)
6174 {
6175 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6176
6177 return (-1);
6178 }
6179 }
6180
6181 uint attack_kern = ATTACK_KERN_NONE;
6182
6183 switch (attack_mode)
6184 {
6185 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6186 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6187 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6188 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6189 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6190 }
6191
6192 if (benchmark == 0)
6193 {
6194 if (keyspace == 1)
6195 {
6196 int num_additional_params = 1;
6197
6198 if (attack_kern == ATTACK_KERN_COMBI)
6199 {
6200 num_additional_params = 2;
6201 }
6202
6203 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6204
6205 if (keyspace_wordlist_specified == 0) optind--;
6206 }
6207
6208 if (attack_kern == ATTACK_KERN_NONE)
6209 {
6210 if ((optind + 1) != myargc)
6211 {
6212 usage_mini_print (myargv[0]);
6213
6214 return (-1);
6215 }
6216 }
6217 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6218 {
6219 if ((optind + 1) > myargc)
6220 {
6221 usage_mini_print (myargv[0]);
6222
6223 return (-1);
6224 }
6225 }
6226 else if (attack_kern == ATTACK_KERN_COMBI)
6227 {
6228 if ((optind + 3) != myargc)
6229 {
6230 usage_mini_print (myargv[0]);
6231
6232 return (-1);
6233 }
6234 }
6235 else if (attack_kern == ATTACK_KERN_BF)
6236 {
6237 if ((optind + 1) > myargc)
6238 {
6239 usage_mini_print (myargv[0]);
6240
6241 return (-1);
6242 }
6243 }
6244 else
6245 {
6246 usage_mini_print (myargv[0]);
6247
6248 return (-1);
6249 }
6250 }
6251 else
6252 {
6253 if (myargv[optind] != 0)
6254 {
6255 log_error ("ERROR: Invalid argument for benchmark mode specified");
6256
6257 return (-1);
6258 }
6259
6260 if (attack_mode_chgd == 1)
6261 {
6262 if (attack_mode != ATTACK_MODE_BF)
6263 {
6264 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6265
6266 return (-1);
6267 }
6268 }
6269 }
6270
6271 if (skip != 0 && limit != 0)
6272 {
6273 limit += skip;
6274 }
6275
6276 if (keyspace == 1)
6277 {
6278 if (show == 1)
6279 {
6280 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6281
6282 return (-1);
6283 }
6284 else if (left == 1)
6285 {
6286 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6287
6288 return (-1);
6289 }
6290
6291 potfile_disable = 1;
6292
6293 restore_disable = 1;
6294
6295 restore = 0;
6296
6297 weak_hash_threshold = 0;
6298
6299 quiet = 1;
6300 }
6301
6302 if (remove_timer_chgd == 1)
6303 {
6304 if (remove == 0)
6305 {
6306 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6307
6308 return (-1);
6309 }
6310
6311 if (remove_timer < 1)
6312 {
6313 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6314
6315 return (-1);
6316 }
6317 }
6318
6319 if (loopback == 1)
6320 {
6321 if (attack_mode == ATTACK_MODE_BF)
6322 {
6323 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6324
6325 return (-1);
6326 }
6327 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6328 {
6329 if ((rp_files_cnt == 0) && (rp_gen == 0))
6330 {
6331 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6332
6333 return (-1);
6334 }
6335 }
6336 }
6337
6338 if (debug_mode > 0)
6339 {
6340 if (attack_mode != ATTACK_MODE_STRAIGHT)
6341 {
6342 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6343
6344 return (-1);
6345 }
6346
6347 if ((rp_files_cnt == 0) && (rp_gen == 0))
6348 {
6349 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6350
6351 return (-1);
6352 }
6353 }
6354
6355 if (debug_mode > 4)
6356 {
6357 log_error ("ERROR: Invalid debug-mode specified");
6358
6359 return (-1);
6360 }
6361
6362 if (debug_file != NULL)
6363 {
6364 if (debug_mode < 1)
6365 {
6366 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6367
6368 return (-1);
6369 }
6370 }
6371
6372 if (induction_dir != NULL)
6373 {
6374 if (attack_mode == ATTACK_MODE_BF)
6375 {
6376 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6377
6378 return (-1);
6379 }
6380 }
6381
6382 if (attack_mode != ATTACK_MODE_STRAIGHT)
6383 {
6384 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6385 {
6386 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6387
6388 return (-1);
6389 }
6390
6391 weak_hash_threshold = 0;
6392 }
6393
6394 /**
6395 * induction directory
6396 */
6397
6398 char *induction_directory = NULL;
6399
6400 if (attack_mode != ATTACK_MODE_BF)
6401 {
6402 if (induction_dir == NULL)
6403 {
6404 induction_directory = (char *) mymalloc (session_size);
6405
6406 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6407
6408 // create induction folder if it does not already exist
6409
6410 if (keyspace == 0)
6411 {
6412 if (rmdir (induction_directory) == -1)
6413 {
6414 if (errno == ENOENT)
6415 {
6416 // good, we can ignore
6417 }
6418 else if (errno == ENOTEMPTY)
6419 {
6420 char *induction_directory_mv = (char *) mymalloc (session_size);
6421
6422 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6423
6424 if (rename (induction_directory, induction_directory_mv) != 0)
6425 {
6426 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6427
6428 return (-1);
6429 }
6430 }
6431 else
6432 {
6433 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6434
6435 return (-1);
6436 }
6437 }
6438
6439 if (mkdir (induction_directory, 0700) == -1)
6440 {
6441 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6442
6443 return (-1);
6444 }
6445 }
6446 }
6447 else
6448 {
6449 induction_directory = induction_dir;
6450 }
6451 }
6452
6453 data.induction_directory = induction_directory;
6454
6455 /**
6456 * loopback
6457 */
6458
6459 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6460
6461 char *loopback_file = (char *) mymalloc (loopback_size);
6462
6463 /**
6464 * tuning db
6465 */
6466
6467 char tuning_db_file[256] = { 0 };
6468
6469 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6470
6471 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6472
6473 /**
6474 * outfile-check directory
6475 */
6476
6477 char *outfile_check_directory = NULL;
6478
6479 if (outfile_check_dir == NULL)
6480 {
6481 outfile_check_directory = (char *) mymalloc (session_size);
6482
6483 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6484 }
6485 else
6486 {
6487 outfile_check_directory = outfile_check_dir;
6488 }
6489
6490 data.outfile_check_directory = outfile_check_directory;
6491
6492 if (keyspace == 0)
6493 {
6494 struct stat outfile_check_stat;
6495
6496 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6497 {
6498 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6499
6500 if (is_dir == 0)
6501 {
6502 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6503
6504 return (-1);
6505 }
6506 }
6507 else if (outfile_check_dir == NULL)
6508 {
6509 if (mkdir (outfile_check_directory, 0700) == -1)
6510 {
6511 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6512
6513 return (-1);
6514 }
6515 }
6516 }
6517
6518 /**
6519 * special other stuff
6520 */
6521
6522 if (hash_mode == 9710)
6523 {
6524 outfile_format = 5;
6525 outfile_format_chgd = 1;
6526 }
6527
6528 if (hash_mode == 9810)
6529 {
6530 outfile_format = 5;
6531 outfile_format_chgd = 1;
6532 }
6533
6534 if (hash_mode == 10410)
6535 {
6536 outfile_format = 5;
6537 outfile_format_chgd = 1;
6538 }
6539
6540 /**
6541 * store stuff
6542 */
6543
6544 data.hash_mode = hash_mode;
6545 data.restore = restore;
6546 data.restore_timer = restore_timer;
6547 data.restore_disable = restore_disable;
6548 data.status = status;
6549 data.status_timer = status_timer;
6550 data.status_automat = status_automat;
6551 data.loopback = loopback;
6552 data.runtime = runtime;
6553 data.remove = remove;
6554 data.remove_timer = remove_timer;
6555 data.debug_mode = debug_mode;
6556 data.debug_file = debug_file;
6557 data.username = username;
6558 data.quiet = quiet;
6559 data.outfile = outfile;
6560 data.outfile_format = outfile_format;
6561 data.outfile_autohex = outfile_autohex;
6562 data.hex_charset = hex_charset;
6563 data.hex_salt = hex_salt;
6564 data.hex_wordlist = hex_wordlist;
6565 data.separator = separator;
6566 data.rp_files = rp_files;
6567 data.rp_files_cnt = rp_files_cnt;
6568 data.rp_gen = rp_gen;
6569 data.rp_gen_seed = rp_gen_seed;
6570 data.force = force;
6571 data.benchmark = benchmark;
6572 data.benchmark_repeats = benchmark_repeats;
6573 data.skip = skip;
6574 data.limit = limit;
6575 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6576 data.powertune_enable = powertune_enable;
6577 #endif
6578 data.logfile_disable = logfile_disable;
6579 data.truecrypt_keyfiles = truecrypt_keyfiles;
6580 data.scrypt_tmto = scrypt_tmto;
6581 data.workload_profile = workload_profile;
6582
6583 /**
6584 * cpu affinity
6585 */
6586
6587 if (cpu_affinity)
6588 {
6589 set_cpu_affinity (cpu_affinity);
6590 }
6591
6592 if (rp_gen_seed_chgd == 0)
6593 {
6594 srand (proc_start);
6595 }
6596 else
6597 {
6598 srand (rp_gen_seed);
6599 }
6600
6601 /**
6602 * logfile init
6603 */
6604
6605 if (logfile_disable == 0)
6606 {
6607 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6608
6609 char *logfile = (char *) mymalloc (logfile_size);
6610
6611 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6612
6613 data.logfile = logfile;
6614
6615 char *topid = logfile_generate_topid ();
6616
6617 data.topid = topid;
6618 }
6619
6620 // logfile_append() checks for logfile_disable internally to make it easier from here
6621
6622 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6623 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6624 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6625 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6626 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6627 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6628 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6629 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6630 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6631 #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));
6632
6633 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6634 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6635 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6636 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6637 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6638 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6639 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6640 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6641
6642 logfile_top_msg ("START");
6643
6644 logfile_top_uint (attack_mode);
6645 logfile_top_uint (attack_kern);
6646 logfile_top_uint (benchmark);
6647 logfile_top_uint (benchmark_repeats);
6648 logfile_top_uint (bitmap_min);
6649 logfile_top_uint (bitmap_max);
6650 logfile_top_uint (debug_mode);
6651 logfile_top_uint (force);
6652 logfile_top_uint (kernel_accel);
6653 logfile_top_uint (kernel_loops);
6654 logfile_top_uint (gpu_temp_disable);
6655 #ifdef HAVE_HWMON
6656 logfile_top_uint (gpu_temp_abort);
6657 logfile_top_uint (gpu_temp_retain);
6658 #endif
6659 logfile_top_uint (hash_mode);
6660 logfile_top_uint (hex_charset);
6661 logfile_top_uint (hex_salt);
6662 logfile_top_uint (hex_wordlist);
6663 logfile_top_uint (increment);
6664 logfile_top_uint (increment_max);
6665 logfile_top_uint (increment_min);
6666 logfile_top_uint (keyspace);
6667 logfile_top_uint (left);
6668 logfile_top_uint (logfile_disable);
6669 logfile_top_uint (loopback);
6670 logfile_top_uint (markov_classic);
6671 logfile_top_uint (markov_disable);
6672 logfile_top_uint (markov_threshold);
6673 logfile_top_uint (outfile_autohex);
6674 logfile_top_uint (outfile_check_timer);
6675 logfile_top_uint (outfile_format);
6676 logfile_top_uint (potfile_disable);
6677 logfile_top_string (potfile_path);
6678 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6679 logfile_top_uint (powertune_enable);
6680 #endif
6681 logfile_top_uint (scrypt_tmto);
6682 logfile_top_uint (quiet);
6683 logfile_top_uint (remove);
6684 logfile_top_uint (remove_timer);
6685 logfile_top_uint (restore);
6686 logfile_top_uint (restore_disable);
6687 logfile_top_uint (restore_timer);
6688 logfile_top_uint (rp_gen);
6689 logfile_top_uint (rp_gen_func_max);
6690 logfile_top_uint (rp_gen_func_min);
6691 logfile_top_uint (rp_gen_seed);
6692 logfile_top_uint (runtime);
6693 logfile_top_uint (segment_size);
6694 logfile_top_uint (show);
6695 logfile_top_uint (status);
6696 logfile_top_uint (status_automat);
6697 logfile_top_uint (status_timer);
6698 logfile_top_uint (usage);
6699 logfile_top_uint (username);
6700 logfile_top_uint (version);
6701 logfile_top_uint (weak_hash_threshold);
6702 logfile_top_uint (workload_profile);
6703 logfile_top_uint64 (limit);
6704 logfile_top_uint64 (skip);
6705 logfile_top_char (separator);
6706 logfile_top_string (cpu_affinity);
6707 logfile_top_string (custom_charset_1);
6708 logfile_top_string (custom_charset_2);
6709 logfile_top_string (custom_charset_3);
6710 logfile_top_string (custom_charset_4);
6711 logfile_top_string (debug_file);
6712 logfile_top_string (opencl_devices);
6713 logfile_top_string (opencl_platforms);
6714 logfile_top_string (opencl_device_types);
6715 logfile_top_uint (opencl_vector_width);
6716 logfile_top_string (induction_dir);
6717 logfile_top_string (markov_hcstat);
6718 logfile_top_string (outfile);
6719 logfile_top_string (outfile_check_dir);
6720 logfile_top_string (rule_buf_l);
6721 logfile_top_string (rule_buf_r);
6722 logfile_top_string (session);
6723 logfile_top_string (truecrypt_keyfiles);
6724
6725 /**
6726 * Init OpenCL library loader
6727 */
6728
6729 if (keyspace == 0)
6730 {
6731 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6732
6733 ocl_init (ocl);
6734
6735 data.ocl = ocl;
6736 }
6737
6738 /**
6739 * OpenCL platform selection
6740 */
6741
6742 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6743
6744 /**
6745 * OpenCL device selection
6746 */
6747
6748 u32 devices_filter = setup_devices_filter (opencl_devices);
6749
6750 /**
6751 * OpenCL device type selection
6752 */
6753
6754 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6755
6756 /**
6757 * benchmark
6758 */
6759
6760 if (benchmark == 1)
6761 {
6762 /**
6763 * disable useless stuff for benchmark
6764 */
6765
6766 status_timer = 0;
6767 restore_timer = 0;
6768 restore_disable = 1;
6769 potfile_disable = 1;
6770 weak_hash_threshold = 0;
6771 gpu_temp_disable = 1;
6772
6773 data.status_timer = status_timer;
6774 data.restore_timer = restore_timer;
6775 data.restore_disable = restore_disable;
6776
6777 /**
6778 * force attack mode to be bruteforce
6779 */
6780
6781 attack_mode = ATTACK_MODE_BF;
6782 attack_kern = ATTACK_KERN_BF;
6783
6784 if (workload_profile_chgd == 0)
6785 {
6786 workload_profile = 3;
6787
6788 data.workload_profile = workload_profile;
6789 }
6790 }
6791
6792 /**
6793 * config
6794 */
6795
6796 uint hash_type = 0;
6797 uint salt_type = 0;
6798 uint attack_exec = 0;
6799 uint opts_type = 0;
6800 uint kern_type = 0;
6801 uint dgst_size = 0;
6802 uint esalt_size = 0;
6803 uint opti_type = 0;
6804 uint dgst_pos0 = -1;
6805 uint dgst_pos1 = -1;
6806 uint dgst_pos2 = -1;
6807 uint dgst_pos3 = -1;
6808
6809 int (*parse_func) (char *, uint, hash_t *);
6810 int (*sort_by_digest) (const void *, const void *);
6811
6812 uint algorithm_pos = 0;
6813 uint algorithm_max = 1;
6814
6815 uint *algorithms = default_benchmark_algorithms;
6816
6817 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6818
6819 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6820 {
6821 /*
6822 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6823 * the following algos are skipped entirely
6824 */
6825
6826 if (algorithm_pos > 0)
6827 {
6828 local_free (rd);
6829
6830 rd = init_restore (argc, argv);
6831
6832 data.rd = rd;
6833 }
6834
6835 /**
6836 * update hash_mode in case of multihash benchmark
6837 */
6838
6839 if (benchmark == 1)
6840 {
6841 if (hash_mode_chgd == 0)
6842 {
6843 hash_mode = algorithms[algorithm_pos];
6844
6845 data.hash_mode = hash_mode;
6846 }
6847
6848 quiet = 1;
6849
6850 data.quiet = quiet;
6851 }
6852
6853 switch (hash_mode)
6854 {
6855 case 0: hash_type = HASH_TYPE_MD5;
6856 salt_type = SALT_TYPE_NONE;
6857 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6858 opts_type = OPTS_TYPE_PT_GENERATE_LE
6859 | OPTS_TYPE_PT_ADD80
6860 | OPTS_TYPE_PT_ADDBITS14;
6861 kern_type = KERN_TYPE_MD5;
6862 dgst_size = DGST_SIZE_4_4;
6863 parse_func = md5_parse_hash;
6864 sort_by_digest = sort_by_digest_4_4;
6865 opti_type = OPTI_TYPE_ZERO_BYTE
6866 | OPTI_TYPE_PRECOMPUTE_INIT
6867 | OPTI_TYPE_PRECOMPUTE_MERKLE
6868 | OPTI_TYPE_MEET_IN_MIDDLE
6869 | OPTI_TYPE_EARLY_SKIP
6870 | OPTI_TYPE_NOT_ITERATED
6871 | OPTI_TYPE_NOT_SALTED
6872 | OPTI_TYPE_RAW_HASH;
6873 dgst_pos0 = 0;
6874 dgst_pos1 = 3;
6875 dgst_pos2 = 2;
6876 dgst_pos3 = 1;
6877 break;
6878
6879 case 10: hash_type = HASH_TYPE_MD5;
6880 salt_type = SALT_TYPE_INTERN;
6881 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6882 opts_type = OPTS_TYPE_PT_GENERATE_LE
6883 | OPTS_TYPE_ST_ADD80
6884 | OPTS_TYPE_ST_ADDBITS14;
6885 kern_type = KERN_TYPE_MD5_PWSLT;
6886 dgst_size = DGST_SIZE_4_4;
6887 parse_func = md5s_parse_hash;
6888 sort_by_digest = sort_by_digest_4_4;
6889 opti_type = OPTI_TYPE_ZERO_BYTE
6890 | OPTI_TYPE_PRECOMPUTE_INIT
6891 | OPTI_TYPE_PRECOMPUTE_MERKLE
6892 | OPTI_TYPE_MEET_IN_MIDDLE
6893 | OPTI_TYPE_EARLY_SKIP
6894 | OPTI_TYPE_NOT_ITERATED
6895 | OPTI_TYPE_APPENDED_SALT
6896 | OPTI_TYPE_RAW_HASH;
6897 dgst_pos0 = 0;
6898 dgst_pos1 = 3;
6899 dgst_pos2 = 2;
6900 dgst_pos3 = 1;
6901 break;
6902
6903 case 11: hash_type = HASH_TYPE_MD5;
6904 salt_type = SALT_TYPE_INTERN;
6905 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6906 opts_type = OPTS_TYPE_PT_GENERATE_LE
6907 | OPTS_TYPE_ST_ADD80
6908 | OPTS_TYPE_ST_ADDBITS14;
6909 kern_type = KERN_TYPE_MD5_PWSLT;
6910 dgst_size = DGST_SIZE_4_4;
6911 parse_func = joomla_parse_hash;
6912 sort_by_digest = sort_by_digest_4_4;
6913 opti_type = OPTI_TYPE_ZERO_BYTE
6914 | OPTI_TYPE_PRECOMPUTE_INIT
6915 | OPTI_TYPE_PRECOMPUTE_MERKLE
6916 | OPTI_TYPE_MEET_IN_MIDDLE
6917 | OPTI_TYPE_EARLY_SKIP
6918 | OPTI_TYPE_NOT_ITERATED
6919 | OPTI_TYPE_APPENDED_SALT
6920 | OPTI_TYPE_RAW_HASH;
6921 dgst_pos0 = 0;
6922 dgst_pos1 = 3;
6923 dgst_pos2 = 2;
6924 dgst_pos3 = 1;
6925 break;
6926
6927 case 12: hash_type = HASH_TYPE_MD5;
6928 salt_type = SALT_TYPE_INTERN;
6929 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6930 opts_type = OPTS_TYPE_PT_GENERATE_LE
6931 | OPTS_TYPE_ST_ADD80
6932 | OPTS_TYPE_ST_ADDBITS14;
6933 kern_type = KERN_TYPE_MD5_PWSLT;
6934 dgst_size = DGST_SIZE_4_4;
6935 parse_func = postgresql_parse_hash;
6936 sort_by_digest = sort_by_digest_4_4;
6937 opti_type = OPTI_TYPE_ZERO_BYTE
6938 | OPTI_TYPE_PRECOMPUTE_INIT
6939 | OPTI_TYPE_PRECOMPUTE_MERKLE
6940 | OPTI_TYPE_MEET_IN_MIDDLE
6941 | OPTI_TYPE_EARLY_SKIP
6942 | OPTI_TYPE_NOT_ITERATED
6943 | OPTI_TYPE_APPENDED_SALT
6944 | OPTI_TYPE_RAW_HASH;
6945 dgst_pos0 = 0;
6946 dgst_pos1 = 3;
6947 dgst_pos2 = 2;
6948 dgst_pos3 = 1;
6949 break;
6950
6951 case 20: hash_type = HASH_TYPE_MD5;
6952 salt_type = SALT_TYPE_INTERN;
6953 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6954 opts_type = OPTS_TYPE_PT_GENERATE_LE
6955 | OPTS_TYPE_PT_ADD80
6956 | OPTS_TYPE_PT_ADDBITS14;
6957 kern_type = KERN_TYPE_MD5_SLTPW;
6958 dgst_size = DGST_SIZE_4_4;
6959 parse_func = md5s_parse_hash;
6960 sort_by_digest = sort_by_digest_4_4;
6961 opti_type = OPTI_TYPE_ZERO_BYTE
6962 | OPTI_TYPE_PRECOMPUTE_INIT
6963 | OPTI_TYPE_PRECOMPUTE_MERKLE
6964 | OPTI_TYPE_EARLY_SKIP
6965 | OPTI_TYPE_NOT_ITERATED
6966 | OPTI_TYPE_PREPENDED_SALT
6967 | OPTI_TYPE_RAW_HASH;
6968 dgst_pos0 = 0;
6969 dgst_pos1 = 3;
6970 dgst_pos2 = 2;
6971 dgst_pos3 = 1;
6972 break;
6973
6974 case 21: hash_type = HASH_TYPE_MD5;
6975 salt_type = SALT_TYPE_INTERN;
6976 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6977 opts_type = OPTS_TYPE_PT_GENERATE_LE
6978 | OPTS_TYPE_PT_ADD80
6979 | OPTS_TYPE_PT_ADDBITS14;
6980 kern_type = KERN_TYPE_MD5_SLTPW;
6981 dgst_size = DGST_SIZE_4_4;
6982 parse_func = osc_parse_hash;
6983 sort_by_digest = sort_by_digest_4_4;
6984 opti_type = OPTI_TYPE_ZERO_BYTE
6985 | OPTI_TYPE_PRECOMPUTE_INIT
6986 | OPTI_TYPE_PRECOMPUTE_MERKLE
6987 | OPTI_TYPE_EARLY_SKIP
6988 | OPTI_TYPE_NOT_ITERATED
6989 | OPTI_TYPE_PREPENDED_SALT
6990 | OPTI_TYPE_RAW_HASH;
6991 dgst_pos0 = 0;
6992 dgst_pos1 = 3;
6993 dgst_pos2 = 2;
6994 dgst_pos3 = 1;
6995 break;
6996
6997 case 22: hash_type = HASH_TYPE_MD5;
6998 salt_type = SALT_TYPE_EMBEDDED;
6999 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7000 opts_type = OPTS_TYPE_PT_GENERATE_LE
7001 | OPTS_TYPE_PT_ADD80
7002 | OPTS_TYPE_PT_ADDBITS14;
7003 kern_type = KERN_TYPE_MD5_SLTPW;
7004 dgst_size = DGST_SIZE_4_4;
7005 parse_func = netscreen_parse_hash;
7006 sort_by_digest = sort_by_digest_4_4;
7007 opti_type = OPTI_TYPE_ZERO_BYTE
7008 | OPTI_TYPE_PRECOMPUTE_INIT
7009 | OPTI_TYPE_PRECOMPUTE_MERKLE
7010 | OPTI_TYPE_EARLY_SKIP
7011 | OPTI_TYPE_NOT_ITERATED
7012 | OPTI_TYPE_PREPENDED_SALT
7013 | OPTI_TYPE_RAW_HASH;
7014 dgst_pos0 = 0;
7015 dgst_pos1 = 3;
7016 dgst_pos2 = 2;
7017 dgst_pos3 = 1;
7018 break;
7019
7020 case 23: hash_type = HASH_TYPE_MD5;
7021 salt_type = SALT_TYPE_EMBEDDED;
7022 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7023 opts_type = OPTS_TYPE_PT_GENERATE_LE
7024 | OPTS_TYPE_PT_ADD80
7025 | OPTS_TYPE_PT_ADDBITS14;
7026 kern_type = KERN_TYPE_MD5_SLTPW;
7027 dgst_size = DGST_SIZE_4_4;
7028 parse_func = skype_parse_hash;
7029 sort_by_digest = sort_by_digest_4_4;
7030 opti_type = OPTI_TYPE_ZERO_BYTE
7031 | OPTI_TYPE_PRECOMPUTE_INIT
7032 | OPTI_TYPE_PRECOMPUTE_MERKLE
7033 | OPTI_TYPE_EARLY_SKIP
7034 | OPTI_TYPE_NOT_ITERATED
7035 | OPTI_TYPE_PREPENDED_SALT
7036 | OPTI_TYPE_RAW_HASH;
7037 dgst_pos0 = 0;
7038 dgst_pos1 = 3;
7039 dgst_pos2 = 2;
7040 dgst_pos3 = 1;
7041 break;
7042
7043 case 30: hash_type = HASH_TYPE_MD5;
7044 salt_type = SALT_TYPE_INTERN;
7045 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7046 opts_type = OPTS_TYPE_PT_GENERATE_LE
7047 | OPTS_TYPE_PT_UNICODE
7048 | OPTS_TYPE_ST_ADD80
7049 | OPTS_TYPE_ST_ADDBITS14;
7050 kern_type = KERN_TYPE_MD5_PWUSLT;
7051 dgst_size = DGST_SIZE_4_4;
7052 parse_func = md5s_parse_hash;
7053 sort_by_digest = sort_by_digest_4_4;
7054 opti_type = OPTI_TYPE_ZERO_BYTE
7055 | OPTI_TYPE_PRECOMPUTE_INIT
7056 | OPTI_TYPE_PRECOMPUTE_MERKLE
7057 | OPTI_TYPE_MEET_IN_MIDDLE
7058 | OPTI_TYPE_EARLY_SKIP
7059 | OPTI_TYPE_NOT_ITERATED
7060 | OPTI_TYPE_APPENDED_SALT
7061 | OPTI_TYPE_RAW_HASH;
7062 dgst_pos0 = 0;
7063 dgst_pos1 = 3;
7064 dgst_pos2 = 2;
7065 dgst_pos3 = 1;
7066 break;
7067
7068 case 40: hash_type = HASH_TYPE_MD5;
7069 salt_type = SALT_TYPE_INTERN;
7070 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7071 opts_type = OPTS_TYPE_PT_GENERATE_LE
7072 | OPTS_TYPE_PT_ADD80
7073 | OPTS_TYPE_PT_ADDBITS14
7074 | OPTS_TYPE_PT_UNICODE;
7075 kern_type = KERN_TYPE_MD5_SLTPWU;
7076 dgst_size = DGST_SIZE_4_4;
7077 parse_func = md5s_parse_hash;
7078 sort_by_digest = sort_by_digest_4_4;
7079 opti_type = OPTI_TYPE_ZERO_BYTE
7080 | OPTI_TYPE_PRECOMPUTE_INIT
7081 | OPTI_TYPE_PRECOMPUTE_MERKLE
7082 | OPTI_TYPE_EARLY_SKIP
7083 | OPTI_TYPE_NOT_ITERATED
7084 | OPTI_TYPE_PREPENDED_SALT
7085 | OPTI_TYPE_RAW_HASH;
7086 dgst_pos0 = 0;
7087 dgst_pos1 = 3;
7088 dgst_pos2 = 2;
7089 dgst_pos3 = 1;
7090 break;
7091
7092 case 50: hash_type = HASH_TYPE_MD5;
7093 salt_type = SALT_TYPE_INTERN;
7094 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7095 opts_type = OPTS_TYPE_PT_GENERATE_LE
7096 | OPTS_TYPE_ST_ADD80
7097 | OPTS_TYPE_ST_ADDBITS14;
7098 kern_type = KERN_TYPE_HMACMD5_PW;
7099 dgst_size = DGST_SIZE_4_4;
7100 parse_func = hmacmd5_parse_hash;
7101 sort_by_digest = sort_by_digest_4_4;
7102 opti_type = OPTI_TYPE_ZERO_BYTE
7103 | OPTI_TYPE_NOT_ITERATED;
7104 dgst_pos0 = 0;
7105 dgst_pos1 = 3;
7106 dgst_pos2 = 2;
7107 dgst_pos3 = 1;
7108 break;
7109
7110 case 60: hash_type = HASH_TYPE_MD5;
7111 salt_type = SALT_TYPE_INTERN;
7112 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7113 opts_type = OPTS_TYPE_PT_GENERATE_LE
7114 | OPTS_TYPE_PT_ADD80
7115 | OPTS_TYPE_PT_ADDBITS14;
7116 kern_type = KERN_TYPE_HMACMD5_SLT;
7117 dgst_size = DGST_SIZE_4_4;
7118 parse_func = hmacmd5_parse_hash;
7119 sort_by_digest = sort_by_digest_4_4;
7120 opti_type = OPTI_TYPE_ZERO_BYTE
7121 | OPTI_TYPE_NOT_ITERATED;
7122 dgst_pos0 = 0;
7123 dgst_pos1 = 3;
7124 dgst_pos2 = 2;
7125 dgst_pos3 = 1;
7126 break;
7127
7128 case 100: hash_type = HASH_TYPE_SHA1;
7129 salt_type = SALT_TYPE_NONE;
7130 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7131 opts_type = OPTS_TYPE_PT_GENERATE_BE
7132 | OPTS_TYPE_PT_ADD80
7133 | OPTS_TYPE_PT_ADDBITS15;
7134 kern_type = KERN_TYPE_SHA1;
7135 dgst_size = DGST_SIZE_4_5;
7136 parse_func = sha1_parse_hash;
7137 sort_by_digest = sort_by_digest_4_5;
7138 opti_type = OPTI_TYPE_ZERO_BYTE
7139 | OPTI_TYPE_PRECOMPUTE_INIT
7140 | OPTI_TYPE_PRECOMPUTE_MERKLE
7141 | OPTI_TYPE_EARLY_SKIP
7142 | OPTI_TYPE_NOT_ITERATED
7143 | OPTI_TYPE_NOT_SALTED
7144 | OPTI_TYPE_RAW_HASH;
7145 dgst_pos0 = 3;
7146 dgst_pos1 = 4;
7147 dgst_pos2 = 2;
7148 dgst_pos3 = 1;
7149 break;
7150
7151 case 101: hash_type = HASH_TYPE_SHA1;
7152 salt_type = SALT_TYPE_NONE;
7153 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7154 opts_type = OPTS_TYPE_PT_GENERATE_BE
7155 | OPTS_TYPE_PT_ADD80
7156 | OPTS_TYPE_PT_ADDBITS15;
7157 kern_type = KERN_TYPE_SHA1;
7158 dgst_size = DGST_SIZE_4_5;
7159 parse_func = sha1b64_parse_hash;
7160 sort_by_digest = sort_by_digest_4_5;
7161 opti_type = OPTI_TYPE_ZERO_BYTE
7162 | OPTI_TYPE_PRECOMPUTE_INIT
7163 | OPTI_TYPE_PRECOMPUTE_MERKLE
7164 | OPTI_TYPE_EARLY_SKIP
7165 | OPTI_TYPE_NOT_ITERATED
7166 | OPTI_TYPE_NOT_SALTED
7167 | OPTI_TYPE_RAW_HASH;
7168 dgst_pos0 = 3;
7169 dgst_pos1 = 4;
7170 dgst_pos2 = 2;
7171 dgst_pos3 = 1;
7172 break;
7173
7174 case 110: hash_type = HASH_TYPE_SHA1;
7175 salt_type = SALT_TYPE_INTERN;
7176 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7177 opts_type = OPTS_TYPE_PT_GENERATE_BE
7178 | OPTS_TYPE_ST_ADD80
7179 | OPTS_TYPE_ST_ADDBITS15;
7180 kern_type = KERN_TYPE_SHA1_PWSLT;
7181 dgst_size = DGST_SIZE_4_5;
7182 parse_func = sha1s_parse_hash;
7183 sort_by_digest = sort_by_digest_4_5;
7184 opti_type = OPTI_TYPE_ZERO_BYTE
7185 | OPTI_TYPE_PRECOMPUTE_INIT
7186 | OPTI_TYPE_PRECOMPUTE_MERKLE
7187 | OPTI_TYPE_EARLY_SKIP
7188 | OPTI_TYPE_NOT_ITERATED
7189 | OPTI_TYPE_APPENDED_SALT
7190 | OPTI_TYPE_RAW_HASH;
7191 dgst_pos0 = 3;
7192 dgst_pos1 = 4;
7193 dgst_pos2 = 2;
7194 dgst_pos3 = 1;
7195 break;
7196
7197 case 111: hash_type = HASH_TYPE_SHA1;
7198 salt_type = SALT_TYPE_EMBEDDED;
7199 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7200 opts_type = OPTS_TYPE_PT_GENERATE_BE
7201 | OPTS_TYPE_ST_ADD80
7202 | OPTS_TYPE_ST_ADDBITS15;
7203 kern_type = KERN_TYPE_SHA1_PWSLT;
7204 dgst_size = DGST_SIZE_4_5;
7205 parse_func = sha1b64s_parse_hash;
7206 sort_by_digest = sort_by_digest_4_5;
7207 opti_type = OPTI_TYPE_ZERO_BYTE
7208 | OPTI_TYPE_PRECOMPUTE_INIT
7209 | OPTI_TYPE_PRECOMPUTE_MERKLE
7210 | OPTI_TYPE_EARLY_SKIP
7211 | OPTI_TYPE_NOT_ITERATED
7212 | OPTI_TYPE_APPENDED_SALT
7213 | OPTI_TYPE_RAW_HASH;
7214 dgst_pos0 = 3;
7215 dgst_pos1 = 4;
7216 dgst_pos2 = 2;
7217 dgst_pos3 = 1;
7218 break;
7219
7220 case 112: hash_type = HASH_TYPE_SHA1;
7221 salt_type = SALT_TYPE_INTERN;
7222 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7223 opts_type = OPTS_TYPE_PT_GENERATE_BE
7224 | OPTS_TYPE_ST_ADD80
7225 | OPTS_TYPE_ST_ADDBITS15
7226 | OPTS_TYPE_ST_HEX;
7227 kern_type = KERN_TYPE_SHA1_PWSLT;
7228 dgst_size = DGST_SIZE_4_5;
7229 parse_func = oracles_parse_hash;
7230 sort_by_digest = sort_by_digest_4_5;
7231 opti_type = OPTI_TYPE_ZERO_BYTE
7232 | OPTI_TYPE_PRECOMPUTE_INIT
7233 | OPTI_TYPE_PRECOMPUTE_MERKLE
7234 | OPTI_TYPE_EARLY_SKIP
7235 | OPTI_TYPE_NOT_ITERATED
7236 | OPTI_TYPE_APPENDED_SALT
7237 | OPTI_TYPE_RAW_HASH;
7238 dgst_pos0 = 3;
7239 dgst_pos1 = 4;
7240 dgst_pos2 = 2;
7241 dgst_pos3 = 1;
7242 break;
7243
7244 case 120: hash_type = HASH_TYPE_SHA1;
7245 salt_type = SALT_TYPE_INTERN;
7246 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7247 opts_type = OPTS_TYPE_PT_GENERATE_BE
7248 | OPTS_TYPE_PT_ADD80
7249 | OPTS_TYPE_PT_ADDBITS15;
7250 kern_type = KERN_TYPE_SHA1_SLTPW;
7251 dgst_size = DGST_SIZE_4_5;
7252 parse_func = sha1s_parse_hash;
7253 sort_by_digest = sort_by_digest_4_5;
7254 opti_type = OPTI_TYPE_ZERO_BYTE
7255 | OPTI_TYPE_PRECOMPUTE_INIT
7256 | OPTI_TYPE_PRECOMPUTE_MERKLE
7257 | OPTI_TYPE_EARLY_SKIP
7258 | OPTI_TYPE_NOT_ITERATED
7259 | OPTI_TYPE_PREPENDED_SALT
7260 | OPTI_TYPE_RAW_HASH;
7261 dgst_pos0 = 3;
7262 dgst_pos1 = 4;
7263 dgst_pos2 = 2;
7264 dgst_pos3 = 1;
7265 break;
7266
7267 case 121: hash_type = HASH_TYPE_SHA1;
7268 salt_type = SALT_TYPE_INTERN;
7269 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7270 opts_type = OPTS_TYPE_PT_GENERATE_BE
7271 | OPTS_TYPE_PT_ADD80
7272 | OPTS_TYPE_PT_ADDBITS15
7273 | OPTS_TYPE_ST_LOWER;
7274 kern_type = KERN_TYPE_SHA1_SLTPW;
7275 dgst_size = DGST_SIZE_4_5;
7276 parse_func = smf_parse_hash;
7277 sort_by_digest = sort_by_digest_4_5;
7278 opti_type = OPTI_TYPE_ZERO_BYTE
7279 | OPTI_TYPE_PRECOMPUTE_INIT
7280 | OPTI_TYPE_PRECOMPUTE_MERKLE
7281 | OPTI_TYPE_EARLY_SKIP
7282 | OPTI_TYPE_NOT_ITERATED
7283 | OPTI_TYPE_PREPENDED_SALT
7284 | OPTI_TYPE_RAW_HASH;
7285 dgst_pos0 = 3;
7286 dgst_pos1 = 4;
7287 dgst_pos2 = 2;
7288 dgst_pos3 = 1;
7289 break;
7290
7291 case 122: hash_type = HASH_TYPE_SHA1;
7292 salt_type = SALT_TYPE_EMBEDDED;
7293 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7294 opts_type = OPTS_TYPE_PT_GENERATE_BE
7295 | OPTS_TYPE_PT_ADD80
7296 | OPTS_TYPE_PT_ADDBITS15
7297 | OPTS_TYPE_ST_HEX;
7298 kern_type = KERN_TYPE_SHA1_SLTPW;
7299 dgst_size = DGST_SIZE_4_5;
7300 parse_func = osx1_parse_hash;
7301 sort_by_digest = sort_by_digest_4_5;
7302 opti_type = OPTI_TYPE_ZERO_BYTE
7303 | OPTI_TYPE_PRECOMPUTE_INIT
7304 | OPTI_TYPE_PRECOMPUTE_MERKLE
7305 | OPTI_TYPE_EARLY_SKIP
7306 | OPTI_TYPE_NOT_ITERATED
7307 | OPTI_TYPE_PREPENDED_SALT
7308 | OPTI_TYPE_RAW_HASH;
7309 dgst_pos0 = 3;
7310 dgst_pos1 = 4;
7311 dgst_pos2 = 2;
7312 dgst_pos3 = 1;
7313 break;
7314
7315 case 124: hash_type = HASH_TYPE_SHA1;
7316 salt_type = SALT_TYPE_EMBEDDED;
7317 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7318 opts_type = OPTS_TYPE_PT_GENERATE_BE
7319 | OPTS_TYPE_PT_ADD80
7320 | OPTS_TYPE_PT_ADDBITS15;
7321 kern_type = KERN_TYPE_SHA1_SLTPW;
7322 dgst_size = DGST_SIZE_4_5;
7323 parse_func = djangosha1_parse_hash;
7324 sort_by_digest = sort_by_digest_4_5;
7325 opti_type = OPTI_TYPE_ZERO_BYTE
7326 | OPTI_TYPE_PRECOMPUTE_INIT
7327 | OPTI_TYPE_PRECOMPUTE_MERKLE
7328 | OPTI_TYPE_EARLY_SKIP
7329 | OPTI_TYPE_NOT_ITERATED
7330 | OPTI_TYPE_PREPENDED_SALT
7331 | OPTI_TYPE_RAW_HASH;
7332 dgst_pos0 = 3;
7333 dgst_pos1 = 4;
7334 dgst_pos2 = 2;
7335 dgst_pos3 = 1;
7336 break;
7337
7338 case 125: hash_type = HASH_TYPE_SHA1;
7339 salt_type = SALT_TYPE_EMBEDDED;
7340 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7341 opts_type = OPTS_TYPE_PT_GENERATE_BE
7342 | OPTS_TYPE_PT_ADD80
7343 | OPTS_TYPE_PT_ADDBITS15
7344 | OPTS_TYPE_ST_HEX;
7345 kern_type = KERN_TYPE_SHA1_SLTPW;
7346 dgst_size = DGST_SIZE_4_5;
7347 parse_func = arubaos_parse_hash;
7348 sort_by_digest = sort_by_digest_4_5;
7349 opti_type = OPTI_TYPE_ZERO_BYTE
7350 | OPTI_TYPE_PRECOMPUTE_INIT
7351 | OPTI_TYPE_PRECOMPUTE_MERKLE
7352 | OPTI_TYPE_EARLY_SKIP
7353 | OPTI_TYPE_NOT_ITERATED
7354 | OPTI_TYPE_PREPENDED_SALT
7355 | OPTI_TYPE_RAW_HASH;
7356 dgst_pos0 = 3;
7357 dgst_pos1 = 4;
7358 dgst_pos2 = 2;
7359 dgst_pos3 = 1;
7360 break;
7361
7362 case 130: hash_type = HASH_TYPE_SHA1;
7363 salt_type = SALT_TYPE_INTERN;
7364 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7365 opts_type = OPTS_TYPE_PT_GENERATE_BE
7366 | OPTS_TYPE_PT_UNICODE
7367 | OPTS_TYPE_ST_ADD80
7368 | OPTS_TYPE_ST_ADDBITS15;
7369 kern_type = KERN_TYPE_SHA1_PWUSLT;
7370 dgst_size = DGST_SIZE_4_5;
7371 parse_func = sha1s_parse_hash;
7372 sort_by_digest = sort_by_digest_4_5;
7373 opti_type = OPTI_TYPE_ZERO_BYTE
7374 | OPTI_TYPE_PRECOMPUTE_INIT
7375 | OPTI_TYPE_PRECOMPUTE_MERKLE
7376 | OPTI_TYPE_EARLY_SKIP
7377 | OPTI_TYPE_NOT_ITERATED
7378 | OPTI_TYPE_APPENDED_SALT
7379 | OPTI_TYPE_RAW_HASH;
7380 dgst_pos0 = 3;
7381 dgst_pos1 = 4;
7382 dgst_pos2 = 2;
7383 dgst_pos3 = 1;
7384 break;
7385
7386 case 131: hash_type = HASH_TYPE_SHA1;
7387 salt_type = SALT_TYPE_EMBEDDED;
7388 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7389 opts_type = OPTS_TYPE_PT_GENERATE_BE
7390 | OPTS_TYPE_PT_UNICODE
7391 | OPTS_TYPE_PT_UPPER
7392 | OPTS_TYPE_ST_ADD80
7393 | OPTS_TYPE_ST_ADDBITS15
7394 | OPTS_TYPE_ST_HEX;
7395 kern_type = KERN_TYPE_SHA1_PWUSLT;
7396 dgst_size = DGST_SIZE_4_5;
7397 parse_func = mssql2000_parse_hash;
7398 sort_by_digest = sort_by_digest_4_5;
7399 opti_type = OPTI_TYPE_ZERO_BYTE
7400 | OPTI_TYPE_PRECOMPUTE_INIT
7401 | OPTI_TYPE_PRECOMPUTE_MERKLE
7402 | OPTI_TYPE_EARLY_SKIP
7403 | OPTI_TYPE_NOT_ITERATED
7404 | OPTI_TYPE_APPENDED_SALT
7405 | OPTI_TYPE_RAW_HASH;
7406 dgst_pos0 = 3;
7407 dgst_pos1 = 4;
7408 dgst_pos2 = 2;
7409 dgst_pos3 = 1;
7410 break;
7411
7412 case 132: hash_type = HASH_TYPE_SHA1;
7413 salt_type = SALT_TYPE_EMBEDDED;
7414 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7415 opts_type = OPTS_TYPE_PT_GENERATE_BE
7416 | OPTS_TYPE_PT_UNICODE
7417 | OPTS_TYPE_ST_ADD80
7418 | OPTS_TYPE_ST_ADDBITS15
7419 | OPTS_TYPE_ST_HEX;
7420 kern_type = KERN_TYPE_SHA1_PWUSLT;
7421 dgst_size = DGST_SIZE_4_5;
7422 parse_func = mssql2005_parse_hash;
7423 sort_by_digest = sort_by_digest_4_5;
7424 opti_type = OPTI_TYPE_ZERO_BYTE
7425 | OPTI_TYPE_PRECOMPUTE_INIT
7426 | OPTI_TYPE_PRECOMPUTE_MERKLE
7427 | OPTI_TYPE_EARLY_SKIP
7428 | OPTI_TYPE_NOT_ITERATED
7429 | OPTI_TYPE_APPENDED_SALT
7430 | OPTI_TYPE_RAW_HASH;
7431 dgst_pos0 = 3;
7432 dgst_pos1 = 4;
7433 dgst_pos2 = 2;
7434 dgst_pos3 = 1;
7435 break;
7436
7437 case 133: hash_type = HASH_TYPE_SHA1;
7438 salt_type = SALT_TYPE_EMBEDDED;
7439 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7440 opts_type = OPTS_TYPE_PT_GENERATE_BE
7441 | OPTS_TYPE_PT_UNICODE
7442 | OPTS_TYPE_ST_ADD80
7443 | OPTS_TYPE_ST_ADDBITS15;
7444 kern_type = KERN_TYPE_SHA1_PWUSLT;
7445 dgst_size = DGST_SIZE_4_5;
7446 parse_func = peoplesoft_parse_hash;
7447 sort_by_digest = sort_by_digest_4_5;
7448 opti_type = OPTI_TYPE_ZERO_BYTE
7449 | OPTI_TYPE_PRECOMPUTE_INIT
7450 | OPTI_TYPE_PRECOMPUTE_MERKLE
7451 | OPTI_TYPE_EARLY_SKIP
7452 | OPTI_TYPE_NOT_ITERATED
7453 | OPTI_TYPE_APPENDED_SALT
7454 | OPTI_TYPE_RAW_HASH;
7455 dgst_pos0 = 3;
7456 dgst_pos1 = 4;
7457 dgst_pos2 = 2;
7458 dgst_pos3 = 1;
7459 break;
7460
7461 case 140: hash_type = HASH_TYPE_SHA1;
7462 salt_type = SALT_TYPE_INTERN;
7463 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7464 opts_type = OPTS_TYPE_PT_GENERATE_BE
7465 | OPTS_TYPE_PT_ADD80
7466 | OPTS_TYPE_PT_ADDBITS15
7467 | OPTS_TYPE_PT_UNICODE;
7468 kern_type = KERN_TYPE_SHA1_SLTPWU;
7469 dgst_size = DGST_SIZE_4_5;
7470 parse_func = sha1s_parse_hash;
7471 sort_by_digest = sort_by_digest_4_5;
7472 opti_type = OPTI_TYPE_ZERO_BYTE
7473 | OPTI_TYPE_PRECOMPUTE_INIT
7474 | OPTI_TYPE_PRECOMPUTE_MERKLE
7475 | OPTI_TYPE_EARLY_SKIP
7476 | OPTI_TYPE_NOT_ITERATED
7477 | OPTI_TYPE_PREPENDED_SALT
7478 | OPTI_TYPE_RAW_HASH;
7479 dgst_pos0 = 3;
7480 dgst_pos1 = 4;
7481 dgst_pos2 = 2;
7482 dgst_pos3 = 1;
7483 break;
7484
7485 case 141: hash_type = HASH_TYPE_SHA1;
7486 salt_type = SALT_TYPE_EMBEDDED;
7487 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7488 opts_type = OPTS_TYPE_PT_GENERATE_BE
7489 | OPTS_TYPE_PT_ADD80
7490 | OPTS_TYPE_PT_ADDBITS15
7491 | OPTS_TYPE_PT_UNICODE
7492 | OPTS_TYPE_ST_BASE64;
7493 kern_type = KERN_TYPE_SHA1_SLTPWU;
7494 dgst_size = DGST_SIZE_4_5;
7495 parse_func = episerver_parse_hash;
7496 sort_by_digest = sort_by_digest_4_5;
7497 opti_type = OPTI_TYPE_ZERO_BYTE
7498 | OPTI_TYPE_PRECOMPUTE_INIT
7499 | OPTI_TYPE_PRECOMPUTE_MERKLE
7500 | OPTI_TYPE_EARLY_SKIP
7501 | OPTI_TYPE_NOT_ITERATED
7502 | OPTI_TYPE_PREPENDED_SALT
7503 | OPTI_TYPE_RAW_HASH;
7504 dgst_pos0 = 3;
7505 dgst_pos1 = 4;
7506 dgst_pos2 = 2;
7507 dgst_pos3 = 1;
7508 break;
7509
7510 case 150: hash_type = HASH_TYPE_SHA1;
7511 salt_type = SALT_TYPE_INTERN;
7512 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7513 opts_type = OPTS_TYPE_PT_GENERATE_BE
7514 | OPTS_TYPE_ST_ADD80
7515 | OPTS_TYPE_ST_ADDBITS15;
7516 kern_type = KERN_TYPE_HMACSHA1_PW;
7517 dgst_size = DGST_SIZE_4_5;
7518 parse_func = hmacsha1_parse_hash;
7519 sort_by_digest = sort_by_digest_4_5;
7520 opti_type = OPTI_TYPE_ZERO_BYTE
7521 | OPTI_TYPE_NOT_ITERATED;
7522 dgst_pos0 = 3;
7523 dgst_pos1 = 4;
7524 dgst_pos2 = 2;
7525 dgst_pos3 = 1;
7526 break;
7527
7528 case 160: hash_type = HASH_TYPE_SHA1;
7529 salt_type = SALT_TYPE_INTERN;
7530 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7531 opts_type = OPTS_TYPE_PT_GENERATE_BE
7532 | OPTS_TYPE_PT_ADD80
7533 | OPTS_TYPE_PT_ADDBITS15;
7534 kern_type = KERN_TYPE_HMACSHA1_SLT;
7535 dgst_size = DGST_SIZE_4_5;
7536 parse_func = hmacsha1_parse_hash;
7537 sort_by_digest = sort_by_digest_4_5;
7538 opti_type = OPTI_TYPE_ZERO_BYTE
7539 | OPTI_TYPE_NOT_ITERATED;
7540 dgst_pos0 = 3;
7541 dgst_pos1 = 4;
7542 dgst_pos2 = 2;
7543 dgst_pos3 = 1;
7544 break;
7545
7546 case 190: hash_type = HASH_TYPE_SHA1;
7547 salt_type = SALT_TYPE_NONE;
7548 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7549 opts_type = OPTS_TYPE_PT_GENERATE_BE
7550 | OPTS_TYPE_PT_ADD80
7551 | OPTS_TYPE_PT_ADDBITS15;
7552 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7553 dgst_size = DGST_SIZE_4_5;
7554 parse_func = sha1linkedin_parse_hash;
7555 sort_by_digest = sort_by_digest_4_5;
7556 opti_type = OPTI_TYPE_ZERO_BYTE
7557 | OPTI_TYPE_PRECOMPUTE_INIT
7558 | OPTI_TYPE_EARLY_SKIP
7559 | OPTI_TYPE_NOT_ITERATED
7560 | OPTI_TYPE_NOT_SALTED;
7561 dgst_pos0 = 0;
7562 dgst_pos1 = 4;
7563 dgst_pos2 = 3;
7564 dgst_pos3 = 2;
7565 break;
7566
7567 case 200: hash_type = HASH_TYPE_MYSQL;
7568 salt_type = SALT_TYPE_NONE;
7569 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7570 opts_type = 0;
7571 kern_type = KERN_TYPE_MYSQL;
7572 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7573 parse_func = mysql323_parse_hash;
7574 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7575 opti_type = OPTI_TYPE_ZERO_BYTE;
7576 dgst_pos0 = 0;
7577 dgst_pos1 = 1;
7578 dgst_pos2 = 2;
7579 dgst_pos3 = 3;
7580 break;
7581
7582 case 300: hash_type = HASH_TYPE_SHA1;
7583 salt_type = SALT_TYPE_NONE;
7584 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7585 opts_type = OPTS_TYPE_PT_GENERATE_BE
7586 | OPTS_TYPE_PT_ADD80
7587 | OPTS_TYPE_PT_ADDBITS15;
7588 kern_type = KERN_TYPE_MYSQL41;
7589 dgst_size = DGST_SIZE_4_5;
7590 parse_func = sha1_parse_hash;
7591 sort_by_digest = sort_by_digest_4_5;
7592 opti_type = OPTI_TYPE_ZERO_BYTE
7593 | OPTI_TYPE_PRECOMPUTE_INIT
7594 | OPTI_TYPE_PRECOMPUTE_MERKLE
7595 | OPTI_TYPE_EARLY_SKIP
7596 | OPTI_TYPE_NOT_ITERATED
7597 | OPTI_TYPE_NOT_SALTED;
7598 dgst_pos0 = 3;
7599 dgst_pos1 = 4;
7600 dgst_pos2 = 2;
7601 dgst_pos3 = 1;
7602 break;
7603
7604 case 400: hash_type = HASH_TYPE_MD5;
7605 salt_type = SALT_TYPE_EMBEDDED;
7606 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7607 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7608 kern_type = KERN_TYPE_PHPASS;
7609 dgst_size = DGST_SIZE_4_4;
7610 parse_func = phpass_parse_hash;
7611 sort_by_digest = sort_by_digest_4_4;
7612 opti_type = OPTI_TYPE_ZERO_BYTE;
7613 dgst_pos0 = 0;
7614 dgst_pos1 = 1;
7615 dgst_pos2 = 2;
7616 dgst_pos3 = 3;
7617 break;
7618
7619 case 500: hash_type = HASH_TYPE_MD5;
7620 salt_type = SALT_TYPE_EMBEDDED;
7621 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7622 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7623 kern_type = KERN_TYPE_MD5CRYPT;
7624 dgst_size = DGST_SIZE_4_4;
7625 parse_func = md5crypt_parse_hash;
7626 sort_by_digest = sort_by_digest_4_4;
7627 opti_type = OPTI_TYPE_ZERO_BYTE;
7628 dgst_pos0 = 0;
7629 dgst_pos1 = 1;
7630 dgst_pos2 = 2;
7631 dgst_pos3 = 3;
7632 break;
7633
7634 case 501: hash_type = HASH_TYPE_MD5;
7635 salt_type = SALT_TYPE_EMBEDDED;
7636 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7637 opts_type = OPTS_TYPE_PT_GENERATE_LE
7638 | OPTS_TYPE_HASH_COPY;
7639 kern_type = KERN_TYPE_MD5CRYPT;
7640 dgst_size = DGST_SIZE_4_4;
7641 parse_func = juniper_parse_hash;
7642 sort_by_digest = sort_by_digest_4_4;
7643 opti_type = OPTI_TYPE_ZERO_BYTE;
7644 dgst_pos0 = 0;
7645 dgst_pos1 = 1;
7646 dgst_pos2 = 2;
7647 dgst_pos3 = 3;
7648 break;
7649
7650 case 900: hash_type = HASH_TYPE_MD4;
7651 salt_type = SALT_TYPE_NONE;
7652 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7653 opts_type = OPTS_TYPE_PT_GENERATE_LE
7654 | OPTS_TYPE_PT_ADD80
7655 | OPTS_TYPE_PT_ADDBITS14;
7656 kern_type = KERN_TYPE_MD4;
7657 dgst_size = DGST_SIZE_4_4;
7658 parse_func = md4_parse_hash;
7659 sort_by_digest = sort_by_digest_4_4;
7660 opti_type = OPTI_TYPE_ZERO_BYTE
7661 | OPTI_TYPE_PRECOMPUTE_INIT
7662 | OPTI_TYPE_PRECOMPUTE_MERKLE
7663 | OPTI_TYPE_MEET_IN_MIDDLE
7664 | OPTI_TYPE_EARLY_SKIP
7665 | OPTI_TYPE_NOT_ITERATED
7666 | OPTI_TYPE_NOT_SALTED
7667 | OPTI_TYPE_RAW_HASH;
7668 dgst_pos0 = 0;
7669 dgst_pos1 = 3;
7670 dgst_pos2 = 2;
7671 dgst_pos3 = 1;
7672 break;
7673
7674 case 1000: hash_type = HASH_TYPE_MD4;
7675 salt_type = SALT_TYPE_NONE;
7676 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7677 opts_type = OPTS_TYPE_PT_GENERATE_LE
7678 | OPTS_TYPE_PT_ADD80
7679 | OPTS_TYPE_PT_ADDBITS14
7680 | OPTS_TYPE_PT_UNICODE;
7681 kern_type = KERN_TYPE_MD4_PWU;
7682 dgst_size = DGST_SIZE_4_4;
7683 parse_func = md4_parse_hash;
7684 sort_by_digest = sort_by_digest_4_4;
7685 opti_type = OPTI_TYPE_ZERO_BYTE
7686 | OPTI_TYPE_PRECOMPUTE_INIT
7687 | OPTI_TYPE_PRECOMPUTE_MERKLE
7688 | OPTI_TYPE_MEET_IN_MIDDLE
7689 | OPTI_TYPE_EARLY_SKIP
7690 | OPTI_TYPE_NOT_ITERATED
7691 | OPTI_TYPE_NOT_SALTED
7692 | OPTI_TYPE_RAW_HASH;
7693 dgst_pos0 = 0;
7694 dgst_pos1 = 3;
7695 dgst_pos2 = 2;
7696 dgst_pos3 = 1;
7697 break;
7698
7699 case 1100: hash_type = HASH_TYPE_MD4;
7700 salt_type = SALT_TYPE_INTERN;
7701 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7702 opts_type = OPTS_TYPE_PT_GENERATE_LE
7703 | OPTS_TYPE_PT_ADD80
7704 | OPTS_TYPE_PT_ADDBITS14
7705 | OPTS_TYPE_PT_UNICODE
7706 | OPTS_TYPE_ST_ADD80
7707 | OPTS_TYPE_ST_UNICODE
7708 | OPTS_TYPE_ST_LOWER;
7709 kern_type = KERN_TYPE_MD44_PWUSLT;
7710 dgst_size = DGST_SIZE_4_4;
7711 parse_func = dcc_parse_hash;
7712 sort_by_digest = sort_by_digest_4_4;
7713 opti_type = OPTI_TYPE_ZERO_BYTE
7714 | OPTI_TYPE_PRECOMPUTE_INIT
7715 | OPTI_TYPE_PRECOMPUTE_MERKLE
7716 | OPTI_TYPE_EARLY_SKIP
7717 | OPTI_TYPE_NOT_ITERATED;
7718 dgst_pos0 = 0;
7719 dgst_pos1 = 3;
7720 dgst_pos2 = 2;
7721 dgst_pos3 = 1;
7722 break;
7723
7724 case 1400: hash_type = HASH_TYPE_SHA256;
7725 salt_type = SALT_TYPE_NONE;
7726 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7727 opts_type = OPTS_TYPE_PT_GENERATE_BE
7728 | OPTS_TYPE_PT_ADD80
7729 | OPTS_TYPE_PT_ADDBITS15;
7730 kern_type = KERN_TYPE_SHA256;
7731 dgst_size = DGST_SIZE_4_8;
7732 parse_func = sha256_parse_hash;
7733 sort_by_digest = sort_by_digest_4_8;
7734 opti_type = OPTI_TYPE_ZERO_BYTE
7735 | OPTI_TYPE_PRECOMPUTE_INIT
7736 | OPTI_TYPE_PRECOMPUTE_MERKLE
7737 | OPTI_TYPE_EARLY_SKIP
7738 | OPTI_TYPE_NOT_ITERATED
7739 | OPTI_TYPE_NOT_SALTED
7740 | OPTI_TYPE_RAW_HASH;
7741 dgst_pos0 = 3;
7742 dgst_pos1 = 7;
7743 dgst_pos2 = 2;
7744 dgst_pos3 = 6;
7745 break;
7746
7747 case 1410: hash_type = HASH_TYPE_SHA256;
7748 salt_type = SALT_TYPE_INTERN;
7749 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7750 opts_type = OPTS_TYPE_PT_GENERATE_BE
7751 | OPTS_TYPE_ST_ADD80
7752 | OPTS_TYPE_ST_ADDBITS15;
7753 kern_type = KERN_TYPE_SHA256_PWSLT;
7754 dgst_size = DGST_SIZE_4_8;
7755 parse_func = sha256s_parse_hash;
7756 sort_by_digest = sort_by_digest_4_8;
7757 opti_type = OPTI_TYPE_ZERO_BYTE
7758 | OPTI_TYPE_PRECOMPUTE_INIT
7759 | OPTI_TYPE_PRECOMPUTE_MERKLE
7760 | OPTI_TYPE_EARLY_SKIP
7761 | OPTI_TYPE_NOT_ITERATED
7762 | OPTI_TYPE_APPENDED_SALT
7763 | OPTI_TYPE_RAW_HASH;
7764 dgst_pos0 = 3;
7765 dgst_pos1 = 7;
7766 dgst_pos2 = 2;
7767 dgst_pos3 = 6;
7768 break;
7769
7770 case 1420: hash_type = HASH_TYPE_SHA256;
7771 salt_type = SALT_TYPE_INTERN;
7772 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7773 opts_type = OPTS_TYPE_PT_GENERATE_BE
7774 | OPTS_TYPE_PT_ADD80
7775 | OPTS_TYPE_PT_ADDBITS15;
7776 kern_type = KERN_TYPE_SHA256_SLTPW;
7777 dgst_size = DGST_SIZE_4_8;
7778 parse_func = sha256s_parse_hash;
7779 sort_by_digest = sort_by_digest_4_8;
7780 opti_type = OPTI_TYPE_ZERO_BYTE
7781 | OPTI_TYPE_PRECOMPUTE_INIT
7782 | OPTI_TYPE_PRECOMPUTE_MERKLE
7783 | OPTI_TYPE_EARLY_SKIP
7784 | OPTI_TYPE_NOT_ITERATED
7785 | OPTI_TYPE_PREPENDED_SALT
7786 | OPTI_TYPE_RAW_HASH;
7787 dgst_pos0 = 3;
7788 dgst_pos1 = 7;
7789 dgst_pos2 = 2;
7790 dgst_pos3 = 6;
7791 break;
7792
7793 case 1421: hash_type = HASH_TYPE_SHA256;
7794 salt_type = SALT_TYPE_EMBEDDED;
7795 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7796 opts_type = OPTS_TYPE_PT_GENERATE_BE
7797 | OPTS_TYPE_PT_ADD80
7798 | OPTS_TYPE_PT_ADDBITS15;
7799 kern_type = KERN_TYPE_SHA256_SLTPW;
7800 dgst_size = DGST_SIZE_4_8;
7801 parse_func = hmailserver_parse_hash;
7802 sort_by_digest = sort_by_digest_4_8;
7803 opti_type = OPTI_TYPE_ZERO_BYTE
7804 | OPTI_TYPE_PRECOMPUTE_INIT
7805 | OPTI_TYPE_PRECOMPUTE_MERKLE
7806 | OPTI_TYPE_EARLY_SKIP
7807 | OPTI_TYPE_NOT_ITERATED
7808 | OPTI_TYPE_PREPENDED_SALT
7809 | OPTI_TYPE_RAW_HASH;
7810 dgst_pos0 = 3;
7811 dgst_pos1 = 7;
7812 dgst_pos2 = 2;
7813 dgst_pos3 = 6;
7814 break;
7815
7816 case 1430: hash_type = HASH_TYPE_SHA256;
7817 salt_type = SALT_TYPE_INTERN;
7818 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7819 opts_type = OPTS_TYPE_PT_GENERATE_BE
7820 | OPTS_TYPE_PT_UNICODE
7821 | OPTS_TYPE_ST_ADD80
7822 | OPTS_TYPE_ST_ADDBITS15;
7823 kern_type = KERN_TYPE_SHA256_PWUSLT;
7824 dgst_size = DGST_SIZE_4_8;
7825 parse_func = sha256s_parse_hash;
7826 sort_by_digest = sort_by_digest_4_8;
7827 opti_type = OPTI_TYPE_ZERO_BYTE
7828 | OPTI_TYPE_PRECOMPUTE_INIT
7829 | OPTI_TYPE_PRECOMPUTE_MERKLE
7830 | OPTI_TYPE_EARLY_SKIP
7831 | OPTI_TYPE_NOT_ITERATED
7832 | OPTI_TYPE_APPENDED_SALT
7833 | OPTI_TYPE_RAW_HASH;
7834 dgst_pos0 = 3;
7835 dgst_pos1 = 7;
7836 dgst_pos2 = 2;
7837 dgst_pos3 = 6;
7838 break;
7839
7840 case 1440: hash_type = HASH_TYPE_SHA256;
7841 salt_type = SALT_TYPE_INTERN;
7842 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7843 opts_type = OPTS_TYPE_PT_GENERATE_BE
7844 | OPTS_TYPE_PT_ADD80
7845 | OPTS_TYPE_PT_ADDBITS15
7846 | OPTS_TYPE_PT_UNICODE;
7847 kern_type = KERN_TYPE_SHA256_SLTPWU;
7848 dgst_size = DGST_SIZE_4_8;
7849 parse_func = sha256s_parse_hash;
7850 sort_by_digest = sort_by_digest_4_8;
7851 opti_type = OPTI_TYPE_ZERO_BYTE
7852 | OPTI_TYPE_PRECOMPUTE_INIT
7853 | OPTI_TYPE_PRECOMPUTE_MERKLE
7854 | OPTI_TYPE_EARLY_SKIP
7855 | OPTI_TYPE_NOT_ITERATED
7856 | OPTI_TYPE_PREPENDED_SALT
7857 | OPTI_TYPE_RAW_HASH;
7858 dgst_pos0 = 3;
7859 dgst_pos1 = 7;
7860 dgst_pos2 = 2;
7861 dgst_pos3 = 6;
7862 break;
7863
7864 case 1441: hash_type = HASH_TYPE_SHA256;
7865 salt_type = SALT_TYPE_EMBEDDED;
7866 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7867 opts_type = OPTS_TYPE_PT_GENERATE_BE
7868 | OPTS_TYPE_PT_ADD80
7869 | OPTS_TYPE_PT_ADDBITS15
7870 | OPTS_TYPE_PT_UNICODE
7871 | OPTS_TYPE_ST_BASE64;
7872 kern_type = KERN_TYPE_SHA256_SLTPWU;
7873 dgst_size = DGST_SIZE_4_8;
7874 parse_func = episerver4_parse_hash;
7875 sort_by_digest = sort_by_digest_4_8;
7876 opti_type = OPTI_TYPE_ZERO_BYTE
7877 | OPTI_TYPE_PRECOMPUTE_INIT
7878 | OPTI_TYPE_PRECOMPUTE_MERKLE
7879 | OPTI_TYPE_EARLY_SKIP
7880 | OPTI_TYPE_NOT_ITERATED
7881 | OPTI_TYPE_PREPENDED_SALT
7882 | OPTI_TYPE_RAW_HASH;
7883 dgst_pos0 = 3;
7884 dgst_pos1 = 7;
7885 dgst_pos2 = 2;
7886 dgst_pos3 = 6;
7887 break;
7888
7889 case 1450: hash_type = HASH_TYPE_SHA256;
7890 salt_type = SALT_TYPE_INTERN;
7891 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7892 opts_type = OPTS_TYPE_PT_GENERATE_BE
7893 | OPTS_TYPE_ST_ADD80;
7894 kern_type = KERN_TYPE_HMACSHA256_PW;
7895 dgst_size = DGST_SIZE_4_8;
7896 parse_func = hmacsha256_parse_hash;
7897 sort_by_digest = sort_by_digest_4_8;
7898 opti_type = OPTI_TYPE_ZERO_BYTE
7899 | OPTI_TYPE_NOT_ITERATED;
7900 dgst_pos0 = 3;
7901 dgst_pos1 = 7;
7902 dgst_pos2 = 2;
7903 dgst_pos3 = 6;
7904 break;
7905
7906 case 1460: hash_type = HASH_TYPE_SHA256;
7907 salt_type = SALT_TYPE_INTERN;
7908 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7909 opts_type = OPTS_TYPE_PT_GENERATE_BE
7910 | OPTS_TYPE_PT_ADD80
7911 | OPTS_TYPE_PT_ADDBITS15;
7912 kern_type = KERN_TYPE_HMACSHA256_SLT;
7913 dgst_size = DGST_SIZE_4_8;
7914 parse_func = hmacsha256_parse_hash;
7915 sort_by_digest = sort_by_digest_4_8;
7916 opti_type = OPTI_TYPE_ZERO_BYTE
7917 | OPTI_TYPE_NOT_ITERATED;
7918 dgst_pos0 = 3;
7919 dgst_pos1 = 7;
7920 dgst_pos2 = 2;
7921 dgst_pos3 = 6;
7922 break;
7923
7924 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7925 salt_type = SALT_TYPE_EMBEDDED;
7926 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7927 opts_type = OPTS_TYPE_PT_GENERATE_LE
7928 | OPTS_TYPE_PT_BITSLICE;
7929 kern_type = KERN_TYPE_DESCRYPT;
7930 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7931 parse_func = descrypt_parse_hash;
7932 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7933 opti_type = OPTI_TYPE_ZERO_BYTE
7934 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7935 dgst_pos0 = 0;
7936 dgst_pos1 = 1;
7937 dgst_pos2 = 2;
7938 dgst_pos3 = 3;
7939 break;
7940
7941 case 1600: hash_type = HASH_TYPE_MD5;
7942 salt_type = SALT_TYPE_EMBEDDED;
7943 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7944 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7945 kern_type = KERN_TYPE_APR1CRYPT;
7946 dgst_size = DGST_SIZE_4_4;
7947 parse_func = md5apr1_parse_hash;
7948 sort_by_digest = sort_by_digest_4_4;
7949 opti_type = OPTI_TYPE_ZERO_BYTE;
7950 dgst_pos0 = 0;
7951 dgst_pos1 = 1;
7952 dgst_pos2 = 2;
7953 dgst_pos3 = 3;
7954 break;
7955
7956 case 1700: hash_type = HASH_TYPE_SHA512;
7957 salt_type = SALT_TYPE_NONE;
7958 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7959 opts_type = OPTS_TYPE_PT_GENERATE_BE
7960 | OPTS_TYPE_PT_ADD80
7961 | OPTS_TYPE_PT_ADDBITS15;
7962 kern_type = KERN_TYPE_SHA512;
7963 dgst_size = DGST_SIZE_8_8;
7964 parse_func = sha512_parse_hash;
7965 sort_by_digest = sort_by_digest_8_8;
7966 opti_type = OPTI_TYPE_ZERO_BYTE
7967 | OPTI_TYPE_PRECOMPUTE_INIT
7968 | OPTI_TYPE_PRECOMPUTE_MERKLE
7969 | OPTI_TYPE_EARLY_SKIP
7970 | OPTI_TYPE_NOT_ITERATED
7971 | OPTI_TYPE_NOT_SALTED
7972 | OPTI_TYPE_USES_BITS_64
7973 | OPTI_TYPE_RAW_HASH;
7974 dgst_pos0 = 14;
7975 dgst_pos1 = 15;
7976 dgst_pos2 = 6;
7977 dgst_pos3 = 7;
7978 break;
7979
7980 case 1710: hash_type = HASH_TYPE_SHA512;
7981 salt_type = SALT_TYPE_INTERN;
7982 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7983 opts_type = OPTS_TYPE_PT_GENERATE_BE
7984 | OPTS_TYPE_ST_ADD80
7985 | OPTS_TYPE_ST_ADDBITS15;
7986 kern_type = KERN_TYPE_SHA512_PWSLT;
7987 dgst_size = DGST_SIZE_8_8;
7988 parse_func = sha512s_parse_hash;
7989 sort_by_digest = sort_by_digest_8_8;
7990 opti_type = OPTI_TYPE_ZERO_BYTE
7991 | OPTI_TYPE_PRECOMPUTE_INIT
7992 | OPTI_TYPE_PRECOMPUTE_MERKLE
7993 | OPTI_TYPE_EARLY_SKIP
7994 | OPTI_TYPE_NOT_ITERATED
7995 | OPTI_TYPE_APPENDED_SALT
7996 | OPTI_TYPE_USES_BITS_64
7997 | OPTI_TYPE_RAW_HASH;
7998 dgst_pos0 = 14;
7999 dgst_pos1 = 15;
8000 dgst_pos2 = 6;
8001 dgst_pos3 = 7;
8002 break;
8003
8004 case 1711: hash_type = HASH_TYPE_SHA512;
8005 salt_type = SALT_TYPE_EMBEDDED;
8006 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8007 opts_type = OPTS_TYPE_PT_GENERATE_BE
8008 | OPTS_TYPE_ST_ADD80
8009 | OPTS_TYPE_ST_ADDBITS15;
8010 kern_type = KERN_TYPE_SHA512_PWSLT;
8011 dgst_size = DGST_SIZE_8_8;
8012 parse_func = sha512b64s_parse_hash;
8013 sort_by_digest = sort_by_digest_8_8;
8014 opti_type = OPTI_TYPE_ZERO_BYTE
8015 | OPTI_TYPE_PRECOMPUTE_INIT
8016 | OPTI_TYPE_PRECOMPUTE_MERKLE
8017 | OPTI_TYPE_EARLY_SKIP
8018 | OPTI_TYPE_NOT_ITERATED
8019 | OPTI_TYPE_APPENDED_SALT
8020 | OPTI_TYPE_USES_BITS_64
8021 | OPTI_TYPE_RAW_HASH;
8022 dgst_pos0 = 14;
8023 dgst_pos1 = 15;
8024 dgst_pos2 = 6;
8025 dgst_pos3 = 7;
8026 break;
8027
8028 case 1720: hash_type = HASH_TYPE_SHA512;
8029 salt_type = SALT_TYPE_INTERN;
8030 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8031 opts_type = OPTS_TYPE_PT_GENERATE_BE
8032 | OPTS_TYPE_PT_ADD80
8033 | OPTS_TYPE_PT_ADDBITS15;
8034 kern_type = KERN_TYPE_SHA512_SLTPW;
8035 dgst_size = DGST_SIZE_8_8;
8036 parse_func = sha512s_parse_hash;
8037 sort_by_digest = sort_by_digest_8_8;
8038 opti_type = OPTI_TYPE_ZERO_BYTE
8039 | OPTI_TYPE_PRECOMPUTE_INIT
8040 | OPTI_TYPE_PRECOMPUTE_MERKLE
8041 | OPTI_TYPE_EARLY_SKIP
8042 | OPTI_TYPE_NOT_ITERATED
8043 | OPTI_TYPE_PREPENDED_SALT
8044 | OPTI_TYPE_USES_BITS_64
8045 | OPTI_TYPE_RAW_HASH;
8046 dgst_pos0 = 14;
8047 dgst_pos1 = 15;
8048 dgst_pos2 = 6;
8049 dgst_pos3 = 7;
8050 break;
8051
8052 case 1722: hash_type = HASH_TYPE_SHA512;
8053 salt_type = SALT_TYPE_EMBEDDED;
8054 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8055 opts_type = OPTS_TYPE_PT_GENERATE_BE
8056 | OPTS_TYPE_PT_ADD80
8057 | OPTS_TYPE_PT_ADDBITS15
8058 | OPTS_TYPE_ST_HEX;
8059 kern_type = KERN_TYPE_SHA512_SLTPW;
8060 dgst_size = DGST_SIZE_8_8;
8061 parse_func = osx512_parse_hash;
8062 sort_by_digest = sort_by_digest_8_8;
8063 opti_type = OPTI_TYPE_ZERO_BYTE
8064 | OPTI_TYPE_PRECOMPUTE_INIT
8065 | OPTI_TYPE_PRECOMPUTE_MERKLE
8066 | OPTI_TYPE_EARLY_SKIP
8067 | OPTI_TYPE_NOT_ITERATED
8068 | OPTI_TYPE_PREPENDED_SALT
8069 | OPTI_TYPE_USES_BITS_64
8070 | OPTI_TYPE_RAW_HASH;
8071 dgst_pos0 = 14;
8072 dgst_pos1 = 15;
8073 dgst_pos2 = 6;
8074 dgst_pos3 = 7;
8075 break;
8076
8077 case 1730: hash_type = HASH_TYPE_SHA512;
8078 salt_type = SALT_TYPE_INTERN;
8079 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8080 opts_type = OPTS_TYPE_PT_GENERATE_BE
8081 | OPTS_TYPE_PT_UNICODE
8082 | OPTS_TYPE_ST_ADD80
8083 | OPTS_TYPE_ST_ADDBITS15;
8084 kern_type = KERN_TYPE_SHA512_PWSLTU;
8085 dgst_size = DGST_SIZE_8_8;
8086 parse_func = sha512s_parse_hash;
8087 sort_by_digest = sort_by_digest_8_8;
8088 opti_type = OPTI_TYPE_ZERO_BYTE
8089 | OPTI_TYPE_PRECOMPUTE_INIT
8090 | OPTI_TYPE_PRECOMPUTE_MERKLE
8091 | OPTI_TYPE_EARLY_SKIP
8092 | OPTI_TYPE_NOT_ITERATED
8093 | OPTI_TYPE_APPENDED_SALT
8094 | OPTI_TYPE_USES_BITS_64
8095 | OPTI_TYPE_RAW_HASH;
8096 dgst_pos0 = 14;
8097 dgst_pos1 = 15;
8098 dgst_pos2 = 6;
8099 dgst_pos3 = 7;
8100 break;
8101
8102 case 1731: hash_type = HASH_TYPE_SHA512;
8103 salt_type = SALT_TYPE_EMBEDDED;
8104 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8105 opts_type = OPTS_TYPE_PT_GENERATE_BE
8106 | OPTS_TYPE_PT_UNICODE
8107 | OPTS_TYPE_ST_ADD80
8108 | OPTS_TYPE_ST_ADDBITS15
8109 | OPTS_TYPE_ST_HEX;
8110 kern_type = KERN_TYPE_SHA512_PWSLTU;
8111 dgst_size = DGST_SIZE_8_8;
8112 parse_func = mssql2012_parse_hash;
8113 sort_by_digest = sort_by_digest_8_8;
8114 opti_type = OPTI_TYPE_ZERO_BYTE
8115 | OPTI_TYPE_PRECOMPUTE_INIT
8116 | OPTI_TYPE_PRECOMPUTE_MERKLE
8117 | OPTI_TYPE_EARLY_SKIP
8118 | OPTI_TYPE_NOT_ITERATED
8119 | OPTI_TYPE_APPENDED_SALT
8120 | OPTI_TYPE_USES_BITS_64
8121 | OPTI_TYPE_RAW_HASH;
8122 dgst_pos0 = 14;
8123 dgst_pos1 = 15;
8124 dgst_pos2 = 6;
8125 dgst_pos3 = 7;
8126 break;
8127
8128 case 1740: hash_type = HASH_TYPE_SHA512;
8129 salt_type = SALT_TYPE_INTERN;
8130 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8131 opts_type = OPTS_TYPE_PT_GENERATE_BE
8132 | OPTS_TYPE_PT_ADD80
8133 | OPTS_TYPE_PT_ADDBITS15
8134 | OPTS_TYPE_PT_UNICODE;
8135 kern_type = KERN_TYPE_SHA512_SLTPWU;
8136 dgst_size = DGST_SIZE_8_8;
8137 parse_func = sha512s_parse_hash;
8138 sort_by_digest = sort_by_digest_8_8;
8139 opti_type = OPTI_TYPE_ZERO_BYTE
8140 | OPTI_TYPE_PRECOMPUTE_INIT
8141 | OPTI_TYPE_PRECOMPUTE_MERKLE
8142 | OPTI_TYPE_EARLY_SKIP
8143 | OPTI_TYPE_NOT_ITERATED
8144 | OPTI_TYPE_PREPENDED_SALT
8145 | OPTI_TYPE_USES_BITS_64
8146 | OPTI_TYPE_RAW_HASH;
8147 dgst_pos0 = 14;
8148 dgst_pos1 = 15;
8149 dgst_pos2 = 6;
8150 dgst_pos3 = 7;
8151 break;
8152
8153 case 1750: hash_type = HASH_TYPE_SHA512;
8154 salt_type = SALT_TYPE_INTERN;
8155 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8156 opts_type = OPTS_TYPE_PT_GENERATE_BE
8157 | OPTS_TYPE_ST_ADD80;
8158 kern_type = KERN_TYPE_HMACSHA512_PW;
8159 dgst_size = DGST_SIZE_8_8;
8160 parse_func = hmacsha512_parse_hash;
8161 sort_by_digest = sort_by_digest_8_8;
8162 opti_type = OPTI_TYPE_ZERO_BYTE
8163 | OPTI_TYPE_USES_BITS_64
8164 | OPTI_TYPE_NOT_ITERATED;
8165 dgst_pos0 = 14;
8166 dgst_pos1 = 15;
8167 dgst_pos2 = 6;
8168 dgst_pos3 = 7;
8169 break;
8170
8171 case 1760: hash_type = HASH_TYPE_SHA512;
8172 salt_type = SALT_TYPE_INTERN;
8173 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8174 opts_type = OPTS_TYPE_PT_GENERATE_BE
8175 | OPTS_TYPE_PT_ADD80
8176 | OPTS_TYPE_PT_ADDBITS15;
8177 kern_type = KERN_TYPE_HMACSHA512_SLT;
8178 dgst_size = DGST_SIZE_8_8;
8179 parse_func = hmacsha512_parse_hash;
8180 sort_by_digest = sort_by_digest_8_8;
8181 opti_type = OPTI_TYPE_ZERO_BYTE
8182 | OPTI_TYPE_USES_BITS_64
8183 | OPTI_TYPE_NOT_ITERATED;
8184 dgst_pos0 = 14;
8185 dgst_pos1 = 15;
8186 dgst_pos2 = 6;
8187 dgst_pos3 = 7;
8188 break;
8189
8190 case 1800: hash_type = HASH_TYPE_SHA512;
8191 salt_type = SALT_TYPE_EMBEDDED;
8192 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8193 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8194 kern_type = KERN_TYPE_SHA512CRYPT;
8195 dgst_size = DGST_SIZE_8_8;
8196 parse_func = sha512crypt_parse_hash;
8197 sort_by_digest = sort_by_digest_8_8;
8198 opti_type = OPTI_TYPE_ZERO_BYTE
8199 | OPTI_TYPE_USES_BITS_64;
8200 dgst_pos0 = 0;
8201 dgst_pos1 = 1;
8202 dgst_pos2 = 2;
8203 dgst_pos3 = 3;
8204 break;
8205
8206 case 2100: hash_type = HASH_TYPE_DCC2;
8207 salt_type = SALT_TYPE_EMBEDDED;
8208 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8209 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8210 | OPTS_TYPE_ST_LOWER
8211 | OPTS_TYPE_ST_UNICODE;
8212 kern_type = KERN_TYPE_DCC2;
8213 dgst_size = DGST_SIZE_4_4;
8214 parse_func = dcc2_parse_hash;
8215 sort_by_digest = sort_by_digest_4_4;
8216 opti_type = OPTI_TYPE_ZERO_BYTE;
8217 dgst_pos0 = 0;
8218 dgst_pos1 = 1;
8219 dgst_pos2 = 2;
8220 dgst_pos3 = 3;
8221 break;
8222
8223 case 2400: hash_type = HASH_TYPE_MD5;
8224 salt_type = SALT_TYPE_NONE;
8225 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8226 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8227 kern_type = KERN_TYPE_MD5PIX;
8228 dgst_size = DGST_SIZE_4_4;
8229 parse_func = md5pix_parse_hash;
8230 sort_by_digest = sort_by_digest_4_4;
8231 opti_type = OPTI_TYPE_ZERO_BYTE
8232 | OPTI_TYPE_PRECOMPUTE_INIT
8233 | OPTI_TYPE_PRECOMPUTE_MERKLE
8234 | OPTI_TYPE_EARLY_SKIP
8235 | OPTI_TYPE_NOT_ITERATED
8236 | OPTI_TYPE_NOT_SALTED;
8237 dgst_pos0 = 0;
8238 dgst_pos1 = 3;
8239 dgst_pos2 = 2;
8240 dgst_pos3 = 1;
8241 break;
8242
8243 case 2410: hash_type = HASH_TYPE_MD5;
8244 salt_type = SALT_TYPE_INTERN;
8245 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8246 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8247 kern_type = KERN_TYPE_MD5ASA;
8248 dgst_size = DGST_SIZE_4_4;
8249 parse_func = md5asa_parse_hash;
8250 sort_by_digest = sort_by_digest_4_4;
8251 opti_type = OPTI_TYPE_ZERO_BYTE
8252 | OPTI_TYPE_PRECOMPUTE_INIT
8253 | OPTI_TYPE_PRECOMPUTE_MERKLE
8254 | OPTI_TYPE_EARLY_SKIP
8255 | OPTI_TYPE_NOT_ITERATED;
8256 dgst_pos0 = 0;
8257 dgst_pos1 = 3;
8258 dgst_pos2 = 2;
8259 dgst_pos3 = 1;
8260 break;
8261
8262 case 2500: hash_type = HASH_TYPE_WPA;
8263 salt_type = SALT_TYPE_EMBEDDED;
8264 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8265 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8266 kern_type = KERN_TYPE_WPA;
8267 dgst_size = DGST_SIZE_4_4;
8268 parse_func = wpa_parse_hash;
8269 sort_by_digest = sort_by_digest_4_4;
8270 opti_type = OPTI_TYPE_ZERO_BYTE;
8271 dgst_pos0 = 0;
8272 dgst_pos1 = 1;
8273 dgst_pos2 = 2;
8274 dgst_pos3 = 3;
8275 break;
8276
8277 case 2600: hash_type = HASH_TYPE_MD5;
8278 salt_type = SALT_TYPE_VIRTUAL;
8279 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8280 opts_type = OPTS_TYPE_PT_GENERATE_LE
8281 | OPTS_TYPE_PT_ADD80
8282 | OPTS_TYPE_PT_ADDBITS14
8283 | OPTS_TYPE_ST_ADD80;
8284 kern_type = KERN_TYPE_MD55_PWSLT1;
8285 dgst_size = DGST_SIZE_4_4;
8286 parse_func = md5md5_parse_hash;
8287 sort_by_digest = sort_by_digest_4_4;
8288 opti_type = OPTI_TYPE_ZERO_BYTE
8289 | OPTI_TYPE_PRECOMPUTE_INIT
8290 | OPTI_TYPE_PRECOMPUTE_MERKLE
8291 | OPTI_TYPE_EARLY_SKIP;
8292 dgst_pos0 = 0;
8293 dgst_pos1 = 3;
8294 dgst_pos2 = 2;
8295 dgst_pos3 = 1;
8296 break;
8297
8298 case 2611: hash_type = HASH_TYPE_MD5;
8299 salt_type = SALT_TYPE_INTERN;
8300 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8301 opts_type = OPTS_TYPE_PT_GENERATE_LE
8302 | OPTS_TYPE_PT_ADD80
8303 | OPTS_TYPE_PT_ADDBITS14
8304 | OPTS_TYPE_ST_ADD80;
8305 kern_type = KERN_TYPE_MD55_PWSLT1;
8306 dgst_size = DGST_SIZE_4_4;
8307 parse_func = vb3_parse_hash;
8308 sort_by_digest = sort_by_digest_4_4;
8309 opti_type = OPTI_TYPE_ZERO_BYTE
8310 | OPTI_TYPE_PRECOMPUTE_INIT
8311 | OPTI_TYPE_PRECOMPUTE_MERKLE
8312 | OPTI_TYPE_EARLY_SKIP;
8313 dgst_pos0 = 0;
8314 dgst_pos1 = 3;
8315 dgst_pos2 = 2;
8316 dgst_pos3 = 1;
8317 break;
8318
8319 case 2612: hash_type = HASH_TYPE_MD5;
8320 salt_type = SALT_TYPE_EMBEDDED;
8321 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8322 opts_type = OPTS_TYPE_PT_GENERATE_LE
8323 | OPTS_TYPE_PT_ADD80
8324 | OPTS_TYPE_PT_ADDBITS14
8325 | OPTS_TYPE_ST_ADD80
8326 | OPTS_TYPE_ST_HEX;
8327 kern_type = KERN_TYPE_MD55_PWSLT1;
8328 dgst_size = DGST_SIZE_4_4;
8329 parse_func = phps_parse_hash;
8330 sort_by_digest = sort_by_digest_4_4;
8331 opti_type = OPTI_TYPE_ZERO_BYTE
8332 | OPTI_TYPE_PRECOMPUTE_INIT
8333 | OPTI_TYPE_PRECOMPUTE_MERKLE
8334 | OPTI_TYPE_EARLY_SKIP;
8335 dgst_pos0 = 0;
8336 dgst_pos1 = 3;
8337 dgst_pos2 = 2;
8338 dgst_pos3 = 1;
8339 break;
8340
8341 case 2711: hash_type = HASH_TYPE_MD5;
8342 salt_type = SALT_TYPE_INTERN;
8343 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8344 opts_type = OPTS_TYPE_PT_GENERATE_LE
8345 | OPTS_TYPE_PT_ADD80
8346 | OPTS_TYPE_PT_ADDBITS14
8347 | OPTS_TYPE_ST_ADD80;
8348 kern_type = KERN_TYPE_MD55_PWSLT2;
8349 dgst_size = DGST_SIZE_4_4;
8350 parse_func = vb30_parse_hash;
8351 sort_by_digest = sort_by_digest_4_4;
8352 opti_type = OPTI_TYPE_ZERO_BYTE
8353 | OPTI_TYPE_PRECOMPUTE_INIT
8354 | OPTI_TYPE_EARLY_SKIP;
8355 dgst_pos0 = 0;
8356 dgst_pos1 = 3;
8357 dgst_pos2 = 2;
8358 dgst_pos3 = 1;
8359 break;
8360
8361 case 2811: hash_type = HASH_TYPE_MD5;
8362 salt_type = SALT_TYPE_INTERN;
8363 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8364 opts_type = OPTS_TYPE_PT_GENERATE_LE
8365 | OPTS_TYPE_PT_ADD80
8366 | OPTS_TYPE_PT_ADDBITS14;
8367 kern_type = KERN_TYPE_MD55_SLTPW;
8368 dgst_size = DGST_SIZE_4_4;
8369 parse_func = ipb2_parse_hash;
8370 sort_by_digest = sort_by_digest_4_4;
8371 opti_type = OPTI_TYPE_ZERO_BYTE
8372 | OPTI_TYPE_PRECOMPUTE_INIT
8373 | OPTI_TYPE_EARLY_SKIP;
8374 dgst_pos0 = 0;
8375 dgst_pos1 = 3;
8376 dgst_pos2 = 2;
8377 dgst_pos3 = 1;
8378 break;
8379
8380 case 3000: hash_type = HASH_TYPE_LM;
8381 salt_type = SALT_TYPE_NONE;
8382 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8383 opts_type = OPTS_TYPE_PT_GENERATE_LE
8384 | OPTS_TYPE_PT_UPPER
8385 | OPTS_TYPE_PT_BITSLICE;
8386 kern_type = KERN_TYPE_LM;
8387 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8388 parse_func = lm_parse_hash;
8389 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8390 opti_type = OPTI_TYPE_ZERO_BYTE
8391 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8392 dgst_pos0 = 0;
8393 dgst_pos1 = 1;
8394 dgst_pos2 = 2;
8395 dgst_pos3 = 3;
8396 break;
8397
8398 case 3100: hash_type = HASH_TYPE_ORACLEH;
8399 salt_type = SALT_TYPE_INTERN;
8400 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8401 opts_type = OPTS_TYPE_PT_GENERATE_LE
8402 | OPTS_TYPE_PT_UPPER
8403 | OPTS_TYPE_ST_UPPER;
8404 kern_type = KERN_TYPE_ORACLEH;
8405 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8406 parse_func = oracleh_parse_hash;
8407 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8408 opti_type = OPTI_TYPE_ZERO_BYTE;
8409 dgst_pos0 = 0;
8410 dgst_pos1 = 1;
8411 dgst_pos2 = 2;
8412 dgst_pos3 = 3;
8413 break;
8414
8415 case 3200: hash_type = HASH_TYPE_BCRYPT;
8416 salt_type = SALT_TYPE_EMBEDDED;
8417 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8418 opts_type = OPTS_TYPE_PT_GENERATE_LE
8419 | OPTS_TYPE_ST_GENERATE_LE;
8420 kern_type = KERN_TYPE_BCRYPT;
8421 dgst_size = DGST_SIZE_4_6;
8422 parse_func = bcrypt_parse_hash;
8423 sort_by_digest = sort_by_digest_4_6;
8424 opti_type = OPTI_TYPE_ZERO_BYTE;
8425 dgst_pos0 = 0;
8426 dgst_pos1 = 1;
8427 dgst_pos2 = 2;
8428 dgst_pos3 = 3;
8429 break;
8430
8431 case 3710: hash_type = HASH_TYPE_MD5;
8432 salt_type = SALT_TYPE_INTERN;
8433 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8434 opts_type = OPTS_TYPE_PT_GENERATE_LE
8435 | OPTS_TYPE_PT_ADD80
8436 | OPTS_TYPE_PT_ADDBITS14;
8437 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8438 dgst_size = DGST_SIZE_4_4;
8439 parse_func = md5s_parse_hash;
8440 sort_by_digest = sort_by_digest_4_4;
8441 opti_type = OPTI_TYPE_ZERO_BYTE
8442 | OPTI_TYPE_PRECOMPUTE_INIT
8443 | OPTI_TYPE_PRECOMPUTE_MERKLE
8444 | OPTI_TYPE_EARLY_SKIP;
8445 dgst_pos0 = 0;
8446 dgst_pos1 = 3;
8447 dgst_pos2 = 2;
8448 dgst_pos3 = 1;
8449 break;
8450
8451 case 3711: hash_type = HASH_TYPE_MD5;
8452 salt_type = SALT_TYPE_EMBEDDED;
8453 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8454 opts_type = OPTS_TYPE_PT_GENERATE_LE
8455 | OPTS_TYPE_PT_ADD80
8456 | OPTS_TYPE_PT_ADDBITS14;
8457 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8458 dgst_size = DGST_SIZE_4_4;
8459 parse_func = mediawiki_b_parse_hash;
8460 sort_by_digest = sort_by_digest_4_4;
8461 opti_type = OPTI_TYPE_ZERO_BYTE
8462 | OPTI_TYPE_PRECOMPUTE_INIT
8463 | OPTI_TYPE_PRECOMPUTE_MERKLE
8464 | OPTI_TYPE_EARLY_SKIP;
8465 dgst_pos0 = 0;
8466 dgst_pos1 = 3;
8467 dgst_pos2 = 2;
8468 dgst_pos3 = 1;
8469 break;
8470
8471 case 3800: hash_type = HASH_TYPE_MD5;
8472 salt_type = SALT_TYPE_INTERN;
8473 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8474 opts_type = OPTS_TYPE_PT_GENERATE_LE
8475 | OPTS_TYPE_ST_ADDBITS14;
8476 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8477 dgst_size = DGST_SIZE_4_4;
8478 parse_func = md5s_parse_hash;
8479 sort_by_digest = sort_by_digest_4_4;
8480 opti_type = OPTI_TYPE_ZERO_BYTE
8481 | OPTI_TYPE_PRECOMPUTE_INIT
8482 | OPTI_TYPE_PRECOMPUTE_MERKLE
8483 | OPTI_TYPE_EARLY_SKIP
8484 | OPTI_TYPE_NOT_ITERATED
8485 | OPTI_TYPE_RAW_HASH;
8486 dgst_pos0 = 0;
8487 dgst_pos1 = 3;
8488 dgst_pos2 = 2;
8489 dgst_pos3 = 1;
8490 break;
8491
8492 case 4300: hash_type = HASH_TYPE_MD5;
8493 salt_type = SALT_TYPE_VIRTUAL;
8494 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8495 opts_type = OPTS_TYPE_PT_GENERATE_LE
8496 | OPTS_TYPE_PT_ADD80
8497 | OPTS_TYPE_PT_ADDBITS14
8498 | OPTS_TYPE_ST_ADD80;
8499 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8500 dgst_size = DGST_SIZE_4_4;
8501 parse_func = md5md5_parse_hash;
8502 sort_by_digest = sort_by_digest_4_4;
8503 opti_type = OPTI_TYPE_ZERO_BYTE
8504 | OPTI_TYPE_PRECOMPUTE_INIT
8505 | OPTI_TYPE_PRECOMPUTE_MERKLE
8506 | OPTI_TYPE_EARLY_SKIP;
8507 dgst_pos0 = 0;
8508 dgst_pos1 = 3;
8509 dgst_pos2 = 2;
8510 dgst_pos3 = 1;
8511 break;
8512
8513
8514 case 4400: hash_type = HASH_TYPE_MD5;
8515 salt_type = SALT_TYPE_NONE;
8516 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8517 opts_type = OPTS_TYPE_PT_GENERATE_BE
8518 | OPTS_TYPE_PT_ADD80
8519 | OPTS_TYPE_PT_ADDBITS15;
8520 kern_type = KERN_TYPE_MD5_SHA1;
8521 dgst_size = DGST_SIZE_4_4;
8522 parse_func = md5_parse_hash;
8523 sort_by_digest = sort_by_digest_4_4;
8524 opti_type = OPTI_TYPE_ZERO_BYTE
8525 | OPTI_TYPE_PRECOMPUTE_INIT
8526 | OPTI_TYPE_PRECOMPUTE_MERKLE
8527 | OPTI_TYPE_EARLY_SKIP
8528 | OPTI_TYPE_NOT_ITERATED
8529 | OPTI_TYPE_NOT_SALTED
8530 | OPTI_TYPE_RAW_HASH;
8531 dgst_pos0 = 0;
8532 dgst_pos1 = 3;
8533 dgst_pos2 = 2;
8534 dgst_pos3 = 1;
8535 break;
8536
8537 case 4500: hash_type = HASH_TYPE_SHA1;
8538 salt_type = SALT_TYPE_NONE;
8539 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8540 opts_type = OPTS_TYPE_PT_GENERATE_BE
8541 | OPTS_TYPE_PT_ADD80
8542 | OPTS_TYPE_PT_ADDBITS15;
8543 kern_type = KERN_TYPE_SHA11;
8544 dgst_size = DGST_SIZE_4_5;
8545 parse_func = sha1_parse_hash;
8546 sort_by_digest = sort_by_digest_4_5;
8547 opti_type = OPTI_TYPE_ZERO_BYTE
8548 | OPTI_TYPE_PRECOMPUTE_INIT
8549 | OPTI_TYPE_PRECOMPUTE_MERKLE
8550 | OPTI_TYPE_EARLY_SKIP
8551 | OPTI_TYPE_NOT_SALTED;
8552 dgst_pos0 = 3;
8553 dgst_pos1 = 4;
8554 dgst_pos2 = 2;
8555 dgst_pos3 = 1;
8556 break;
8557
8558 case 4700: hash_type = HASH_TYPE_SHA1;
8559 salt_type = SALT_TYPE_NONE;
8560 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8561 opts_type = OPTS_TYPE_PT_GENERATE_LE
8562 | OPTS_TYPE_PT_ADD80
8563 | OPTS_TYPE_PT_ADDBITS14;
8564 kern_type = KERN_TYPE_SHA1_MD5;
8565 dgst_size = DGST_SIZE_4_5;
8566 parse_func = sha1_parse_hash;
8567 sort_by_digest = sort_by_digest_4_5;
8568 opti_type = OPTI_TYPE_ZERO_BYTE
8569 | OPTI_TYPE_PRECOMPUTE_INIT
8570 | OPTI_TYPE_PRECOMPUTE_MERKLE
8571 | OPTI_TYPE_EARLY_SKIP
8572 | OPTI_TYPE_NOT_ITERATED
8573 | OPTI_TYPE_NOT_SALTED
8574 | OPTI_TYPE_RAW_HASH;
8575 dgst_pos0 = 3;
8576 dgst_pos1 = 4;
8577 dgst_pos2 = 2;
8578 dgst_pos3 = 1;
8579 break;
8580
8581 case 4800: hash_type = HASH_TYPE_MD5;
8582 salt_type = SALT_TYPE_EMBEDDED;
8583 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8584 opts_type = OPTS_TYPE_PT_GENERATE_LE
8585 | OPTS_TYPE_PT_ADDBITS14;
8586 kern_type = KERN_TYPE_MD5_CHAP;
8587 dgst_size = DGST_SIZE_4_4;
8588 parse_func = chap_parse_hash;
8589 sort_by_digest = sort_by_digest_4_4;
8590 opti_type = OPTI_TYPE_ZERO_BYTE
8591 | OPTI_TYPE_PRECOMPUTE_INIT
8592 | OPTI_TYPE_PRECOMPUTE_MERKLE
8593 | OPTI_TYPE_MEET_IN_MIDDLE
8594 | OPTI_TYPE_EARLY_SKIP
8595 | OPTI_TYPE_NOT_ITERATED
8596 | OPTI_TYPE_RAW_HASH;
8597 dgst_pos0 = 0;
8598 dgst_pos1 = 3;
8599 dgst_pos2 = 2;
8600 dgst_pos3 = 1;
8601 break;
8602
8603 case 4900: hash_type = HASH_TYPE_SHA1;
8604 salt_type = SALT_TYPE_INTERN;
8605 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8606 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8607 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8608 dgst_size = DGST_SIZE_4_5;
8609 parse_func = sha1s_parse_hash;
8610 sort_by_digest = sort_by_digest_4_5;
8611 opti_type = OPTI_TYPE_ZERO_BYTE
8612 | OPTI_TYPE_PRECOMPUTE_INIT
8613 | OPTI_TYPE_PRECOMPUTE_MERKLE
8614 | OPTI_TYPE_EARLY_SKIP;
8615 dgst_pos0 = 3;
8616 dgst_pos1 = 4;
8617 dgst_pos2 = 2;
8618 dgst_pos3 = 1;
8619 break;
8620
8621 case 5000: hash_type = HASH_TYPE_KECCAK;
8622 salt_type = SALT_TYPE_EMBEDDED;
8623 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8624 opts_type = OPTS_TYPE_PT_GENERATE_LE
8625 | OPTS_TYPE_PT_ADD01;
8626 kern_type = KERN_TYPE_KECCAK;
8627 dgst_size = DGST_SIZE_8_25;
8628 parse_func = keccak_parse_hash;
8629 sort_by_digest = sort_by_digest_8_25;
8630 opti_type = OPTI_TYPE_ZERO_BYTE
8631 | OPTI_TYPE_USES_BITS_64
8632 | OPTI_TYPE_RAW_HASH;
8633 dgst_pos0 = 2;
8634 dgst_pos1 = 3;
8635 dgst_pos2 = 4;
8636 dgst_pos3 = 5;
8637 break;
8638
8639 case 5100: hash_type = HASH_TYPE_MD5H;
8640 salt_type = SALT_TYPE_NONE;
8641 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8642 opts_type = OPTS_TYPE_PT_GENERATE_LE
8643 | OPTS_TYPE_PT_ADD80
8644 | OPTS_TYPE_PT_ADDBITS14;
8645 kern_type = KERN_TYPE_MD5H;
8646 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8647 parse_func = md5half_parse_hash;
8648 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8649 opti_type = OPTI_TYPE_ZERO_BYTE
8650 | OPTI_TYPE_RAW_HASH;
8651 dgst_pos0 = 0;
8652 dgst_pos1 = 1;
8653 dgst_pos2 = 2;
8654 dgst_pos3 = 3;
8655 break;
8656
8657 case 5200: hash_type = HASH_TYPE_SHA256;
8658 salt_type = SALT_TYPE_EMBEDDED;
8659 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8660 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8661 kern_type = KERN_TYPE_PSAFE3;
8662 dgst_size = DGST_SIZE_4_8;
8663 parse_func = psafe3_parse_hash;
8664 sort_by_digest = sort_by_digest_4_8;
8665 opti_type = OPTI_TYPE_ZERO_BYTE;
8666 dgst_pos0 = 0;
8667 dgst_pos1 = 1;
8668 dgst_pos2 = 2;
8669 dgst_pos3 = 3;
8670 break;
8671
8672 case 5300: hash_type = HASH_TYPE_MD5;
8673 salt_type = SALT_TYPE_EMBEDDED;
8674 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8675 opts_type = OPTS_TYPE_PT_GENERATE_LE
8676 | OPTS_TYPE_ST_ADD80;
8677 kern_type = KERN_TYPE_IKEPSK_MD5;
8678 dgst_size = DGST_SIZE_4_4;
8679 parse_func = ikepsk_md5_parse_hash;
8680 sort_by_digest = sort_by_digest_4_4;
8681 opti_type = OPTI_TYPE_ZERO_BYTE;
8682 dgst_pos0 = 0;
8683 dgst_pos1 = 3;
8684 dgst_pos2 = 2;
8685 dgst_pos3 = 1;
8686 break;
8687
8688 case 5400: hash_type = HASH_TYPE_SHA1;
8689 salt_type = SALT_TYPE_EMBEDDED;
8690 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8691 opts_type = OPTS_TYPE_PT_GENERATE_BE
8692 | OPTS_TYPE_ST_ADD80;
8693 kern_type = KERN_TYPE_IKEPSK_SHA1;
8694 dgst_size = DGST_SIZE_4_5;
8695 parse_func = ikepsk_sha1_parse_hash;
8696 sort_by_digest = sort_by_digest_4_5;
8697 opti_type = OPTI_TYPE_ZERO_BYTE;
8698 dgst_pos0 = 3;
8699 dgst_pos1 = 4;
8700 dgst_pos2 = 2;
8701 dgst_pos3 = 1;
8702 break;
8703
8704 case 5500: hash_type = HASH_TYPE_NETNTLM;
8705 salt_type = SALT_TYPE_EMBEDDED;
8706 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8707 opts_type = OPTS_TYPE_PT_GENERATE_LE
8708 | OPTS_TYPE_PT_ADD80
8709 | OPTS_TYPE_PT_ADDBITS14
8710 | OPTS_TYPE_PT_UNICODE
8711 | OPTS_TYPE_ST_HEX;
8712 kern_type = KERN_TYPE_NETNTLMv1;
8713 dgst_size = DGST_SIZE_4_4;
8714 parse_func = netntlmv1_parse_hash;
8715 sort_by_digest = sort_by_digest_4_4;
8716 opti_type = OPTI_TYPE_ZERO_BYTE
8717 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8718 dgst_pos0 = 0;
8719 dgst_pos1 = 1;
8720 dgst_pos2 = 2;
8721 dgst_pos3 = 3;
8722 break;
8723
8724 case 5600: hash_type = HASH_TYPE_MD5;
8725 salt_type = SALT_TYPE_EMBEDDED;
8726 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8727 opts_type = OPTS_TYPE_PT_GENERATE_LE
8728 | OPTS_TYPE_PT_ADD80
8729 | OPTS_TYPE_PT_ADDBITS14
8730 | OPTS_TYPE_PT_UNICODE;
8731 kern_type = KERN_TYPE_NETNTLMv2;
8732 dgst_size = DGST_SIZE_4_4;
8733 parse_func = netntlmv2_parse_hash;
8734 sort_by_digest = sort_by_digest_4_4;
8735 opti_type = OPTI_TYPE_ZERO_BYTE;
8736 dgst_pos0 = 0;
8737 dgst_pos1 = 3;
8738 dgst_pos2 = 2;
8739 dgst_pos3 = 1;
8740 break;
8741
8742 case 5700: hash_type = HASH_TYPE_SHA256;
8743 salt_type = SALT_TYPE_NONE;
8744 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8745 opts_type = OPTS_TYPE_PT_GENERATE_BE
8746 | OPTS_TYPE_PT_ADD80
8747 | OPTS_TYPE_PT_ADDBITS15;
8748 kern_type = KERN_TYPE_SHA256;
8749 dgst_size = DGST_SIZE_4_8;
8750 parse_func = cisco4_parse_hash;
8751 sort_by_digest = sort_by_digest_4_8;
8752 opti_type = OPTI_TYPE_ZERO_BYTE
8753 | OPTI_TYPE_PRECOMPUTE_INIT
8754 | OPTI_TYPE_PRECOMPUTE_MERKLE
8755 | OPTI_TYPE_EARLY_SKIP
8756 | OPTI_TYPE_NOT_ITERATED
8757 | OPTI_TYPE_NOT_SALTED
8758 | OPTI_TYPE_RAW_HASH;
8759 dgst_pos0 = 3;
8760 dgst_pos1 = 7;
8761 dgst_pos2 = 2;
8762 dgst_pos3 = 6;
8763 break;
8764
8765 case 5800: hash_type = HASH_TYPE_SHA1;
8766 salt_type = SALT_TYPE_INTERN;
8767 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8768 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8769 | OPTS_TYPE_ST_ADD80;
8770 kern_type = KERN_TYPE_ANDROIDPIN;
8771 dgst_size = DGST_SIZE_4_5;
8772 parse_func = androidpin_parse_hash;
8773 sort_by_digest = sort_by_digest_4_5;
8774 opti_type = OPTI_TYPE_ZERO_BYTE;
8775 dgst_pos0 = 0;
8776 dgst_pos1 = 1;
8777 dgst_pos2 = 2;
8778 dgst_pos3 = 3;
8779 break;
8780
8781 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8782 salt_type = SALT_TYPE_NONE;
8783 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8784 opts_type = OPTS_TYPE_PT_GENERATE_LE
8785 | OPTS_TYPE_PT_ADD80;
8786 kern_type = KERN_TYPE_RIPEMD160;
8787 dgst_size = DGST_SIZE_4_5;
8788 parse_func = ripemd160_parse_hash;
8789 sort_by_digest = sort_by_digest_4_5;
8790 opti_type = OPTI_TYPE_ZERO_BYTE;
8791 dgst_pos0 = 0;
8792 dgst_pos1 = 1;
8793 dgst_pos2 = 2;
8794 dgst_pos3 = 3;
8795 break;
8796
8797 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8798 salt_type = SALT_TYPE_NONE;
8799 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8800 opts_type = OPTS_TYPE_PT_GENERATE_BE
8801 | OPTS_TYPE_PT_ADD80;
8802 kern_type = KERN_TYPE_WHIRLPOOL;
8803 dgst_size = DGST_SIZE_4_16;
8804 parse_func = whirlpool_parse_hash;
8805 sort_by_digest = sort_by_digest_4_16;
8806 opti_type = OPTI_TYPE_ZERO_BYTE;
8807 dgst_pos0 = 0;
8808 dgst_pos1 = 1;
8809 dgst_pos2 = 2;
8810 dgst_pos3 = 3;
8811 break;
8812
8813 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8814 salt_type = SALT_TYPE_EMBEDDED;
8815 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8816 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8817 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8818 dgst_size = DGST_SIZE_4_5;
8819 parse_func = truecrypt_parse_hash_2k;
8820 sort_by_digest = sort_by_digest_4_5;
8821 opti_type = OPTI_TYPE_ZERO_BYTE;
8822 dgst_pos0 = 0;
8823 dgst_pos1 = 1;
8824 dgst_pos2 = 2;
8825 dgst_pos3 = 3;
8826 break;
8827
8828 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8829 salt_type = SALT_TYPE_EMBEDDED;
8830 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8831 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8832 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8833 dgst_size = DGST_SIZE_4_5;
8834 parse_func = truecrypt_parse_hash_2k;
8835 sort_by_digest = sort_by_digest_4_5;
8836 opti_type = OPTI_TYPE_ZERO_BYTE;
8837 dgst_pos0 = 0;
8838 dgst_pos1 = 1;
8839 dgst_pos2 = 2;
8840 dgst_pos3 = 3;
8841 break;
8842
8843 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8844 salt_type = SALT_TYPE_EMBEDDED;
8845 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8846 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8847 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8848 dgst_size = DGST_SIZE_4_5;
8849 parse_func = truecrypt_parse_hash_2k;
8850 sort_by_digest = sort_by_digest_4_5;
8851 opti_type = OPTI_TYPE_ZERO_BYTE;
8852 dgst_pos0 = 0;
8853 dgst_pos1 = 1;
8854 dgst_pos2 = 2;
8855 dgst_pos3 = 3;
8856 break;
8857
8858 case 6221: hash_type = HASH_TYPE_SHA512;
8859 salt_type = SALT_TYPE_EMBEDDED;
8860 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8861 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8862 kern_type = KERN_TYPE_TCSHA512_XTS512;
8863 dgst_size = DGST_SIZE_8_8;
8864 parse_func = truecrypt_parse_hash_1k;
8865 sort_by_digest = sort_by_digest_8_8;
8866 opti_type = OPTI_TYPE_ZERO_BYTE
8867 | OPTI_TYPE_USES_BITS_64;
8868 dgst_pos0 = 0;
8869 dgst_pos1 = 1;
8870 dgst_pos2 = 2;
8871 dgst_pos3 = 3;
8872 break;
8873
8874 case 6222: hash_type = HASH_TYPE_SHA512;
8875 salt_type = SALT_TYPE_EMBEDDED;
8876 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8877 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8878 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8879 dgst_size = DGST_SIZE_8_8;
8880 parse_func = truecrypt_parse_hash_1k;
8881 sort_by_digest = sort_by_digest_8_8;
8882 opti_type = OPTI_TYPE_ZERO_BYTE
8883 | OPTI_TYPE_USES_BITS_64;
8884 dgst_pos0 = 0;
8885 dgst_pos1 = 1;
8886 dgst_pos2 = 2;
8887 dgst_pos3 = 3;
8888 break;
8889
8890 case 6223: hash_type = HASH_TYPE_SHA512;
8891 salt_type = SALT_TYPE_EMBEDDED;
8892 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8893 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8894 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8895 dgst_size = DGST_SIZE_8_8;
8896 parse_func = truecrypt_parse_hash_1k;
8897 sort_by_digest = sort_by_digest_8_8;
8898 opti_type = OPTI_TYPE_ZERO_BYTE
8899 | OPTI_TYPE_USES_BITS_64;
8900 dgst_pos0 = 0;
8901 dgst_pos1 = 1;
8902 dgst_pos2 = 2;
8903 dgst_pos3 = 3;
8904 break;
8905
8906 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8907 salt_type = SALT_TYPE_EMBEDDED;
8908 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8909 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8910 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8911 dgst_size = DGST_SIZE_4_8;
8912 parse_func = truecrypt_parse_hash_1k;
8913 sort_by_digest = sort_by_digest_4_8;
8914 opti_type = OPTI_TYPE_ZERO_BYTE;
8915 dgst_pos0 = 0;
8916 dgst_pos1 = 1;
8917 dgst_pos2 = 2;
8918 dgst_pos3 = 3;
8919 break;
8920
8921 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8922 salt_type = SALT_TYPE_EMBEDDED;
8923 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8924 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8925 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8926 dgst_size = DGST_SIZE_4_8;
8927 parse_func = truecrypt_parse_hash_1k;
8928 sort_by_digest = sort_by_digest_4_8;
8929 opti_type = OPTI_TYPE_ZERO_BYTE;
8930 dgst_pos0 = 0;
8931 dgst_pos1 = 1;
8932 dgst_pos2 = 2;
8933 dgst_pos3 = 3;
8934 break;
8935
8936 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8937 salt_type = SALT_TYPE_EMBEDDED;
8938 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8939 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8940 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8941 dgst_size = DGST_SIZE_4_8;
8942 parse_func = truecrypt_parse_hash_1k;
8943 sort_by_digest = sort_by_digest_4_8;
8944 opti_type = OPTI_TYPE_ZERO_BYTE;
8945 dgst_pos0 = 0;
8946 dgst_pos1 = 1;
8947 dgst_pos2 = 2;
8948 dgst_pos3 = 3;
8949 break;
8950
8951 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8952 salt_type = SALT_TYPE_EMBEDDED;
8953 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8954 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8955 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8956 dgst_size = DGST_SIZE_4_5;
8957 parse_func = truecrypt_parse_hash_1k;
8958 sort_by_digest = sort_by_digest_4_5;
8959 opti_type = OPTI_TYPE_ZERO_BYTE;
8960 dgst_pos0 = 0;
8961 dgst_pos1 = 1;
8962 dgst_pos2 = 2;
8963 dgst_pos3 = 3;
8964 break;
8965
8966 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8967 salt_type = SALT_TYPE_EMBEDDED;
8968 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8969 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8970 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8971 dgst_size = DGST_SIZE_4_5;
8972 parse_func = truecrypt_parse_hash_1k;
8973 sort_by_digest = sort_by_digest_4_5;
8974 opti_type = OPTI_TYPE_ZERO_BYTE;
8975 dgst_pos0 = 0;
8976 dgst_pos1 = 1;
8977 dgst_pos2 = 2;
8978 dgst_pos3 = 3;
8979 break;
8980
8981 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8982 salt_type = SALT_TYPE_EMBEDDED;
8983 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8984 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8985 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8986 dgst_size = DGST_SIZE_4_5;
8987 parse_func = truecrypt_parse_hash_1k;
8988 sort_by_digest = sort_by_digest_4_5;
8989 opti_type = OPTI_TYPE_ZERO_BYTE;
8990 dgst_pos0 = 0;
8991 dgst_pos1 = 1;
8992 dgst_pos2 = 2;
8993 dgst_pos3 = 3;
8994 break;
8995
8996 case 6300: hash_type = HASH_TYPE_MD5;
8997 salt_type = SALT_TYPE_EMBEDDED;
8998 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8999 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9000 kern_type = KERN_TYPE_MD5AIX;
9001 dgst_size = DGST_SIZE_4_4;
9002 parse_func = md5aix_parse_hash;
9003 sort_by_digest = sort_by_digest_4_4;
9004 opti_type = OPTI_TYPE_ZERO_BYTE;
9005 dgst_pos0 = 0;
9006 dgst_pos1 = 1;
9007 dgst_pos2 = 2;
9008 dgst_pos3 = 3;
9009 break;
9010
9011 case 6400: hash_type = HASH_TYPE_SHA256;
9012 salt_type = SALT_TYPE_EMBEDDED;
9013 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9014 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9015 kern_type = KERN_TYPE_SHA256AIX;
9016 dgst_size = DGST_SIZE_4_8;
9017 parse_func = sha256aix_parse_hash;
9018 sort_by_digest = sort_by_digest_4_8;
9019 opti_type = OPTI_TYPE_ZERO_BYTE;
9020 dgst_pos0 = 0;
9021 dgst_pos1 = 1;
9022 dgst_pos2 = 2;
9023 dgst_pos3 = 3;
9024 break;
9025
9026 case 6500: hash_type = HASH_TYPE_SHA512;
9027 salt_type = SALT_TYPE_EMBEDDED;
9028 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9029 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9030 kern_type = KERN_TYPE_SHA512AIX;
9031 dgst_size = DGST_SIZE_8_8;
9032 parse_func = sha512aix_parse_hash;
9033 sort_by_digest = sort_by_digest_8_8;
9034 opti_type = OPTI_TYPE_ZERO_BYTE
9035 | OPTI_TYPE_USES_BITS_64;
9036 dgst_pos0 = 0;
9037 dgst_pos1 = 1;
9038 dgst_pos2 = 2;
9039 dgst_pos3 = 3;
9040 break;
9041
9042 case 6600: hash_type = HASH_TYPE_AES;
9043 salt_type = SALT_TYPE_EMBEDDED;
9044 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9045 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9046 kern_type = KERN_TYPE_AGILEKEY;
9047 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9048 parse_func = agilekey_parse_hash;
9049 sort_by_digest = sort_by_digest_4_5;
9050 opti_type = OPTI_TYPE_ZERO_BYTE;
9051 dgst_pos0 = 0;
9052 dgst_pos1 = 1;
9053 dgst_pos2 = 2;
9054 dgst_pos3 = 3;
9055 break;
9056
9057 case 6700: hash_type = HASH_TYPE_SHA1;
9058 salt_type = SALT_TYPE_EMBEDDED;
9059 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9060 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9061 kern_type = KERN_TYPE_SHA1AIX;
9062 dgst_size = DGST_SIZE_4_5;
9063 parse_func = sha1aix_parse_hash;
9064 sort_by_digest = sort_by_digest_4_5;
9065 opti_type = OPTI_TYPE_ZERO_BYTE;
9066 dgst_pos0 = 0;
9067 dgst_pos1 = 1;
9068 dgst_pos2 = 2;
9069 dgst_pos3 = 3;
9070 break;
9071
9072 case 6800: hash_type = HASH_TYPE_AES;
9073 salt_type = SALT_TYPE_EMBEDDED;
9074 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9075 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9076 kern_type = KERN_TYPE_LASTPASS;
9077 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9078 parse_func = lastpass_parse_hash;
9079 sort_by_digest = sort_by_digest_4_8;
9080 opti_type = OPTI_TYPE_ZERO_BYTE;
9081 dgst_pos0 = 0;
9082 dgst_pos1 = 1;
9083 dgst_pos2 = 2;
9084 dgst_pos3 = 3;
9085 break;
9086
9087 case 6900: hash_type = HASH_TYPE_GOST;
9088 salt_type = SALT_TYPE_NONE;
9089 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9090 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9091 kern_type = KERN_TYPE_GOST;
9092 dgst_size = DGST_SIZE_4_8;
9093 parse_func = gost_parse_hash;
9094 sort_by_digest = sort_by_digest_4_8;
9095 opti_type = OPTI_TYPE_ZERO_BYTE;
9096 dgst_pos0 = 0;
9097 dgst_pos1 = 1;
9098 dgst_pos2 = 2;
9099 dgst_pos3 = 3;
9100 break;
9101
9102 case 7100: hash_type = HASH_TYPE_SHA512;
9103 salt_type = SALT_TYPE_EMBEDDED;
9104 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9105 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9106 kern_type = KERN_TYPE_PBKDF2_SHA512;
9107 dgst_size = DGST_SIZE_8_16;
9108 parse_func = sha512osx_parse_hash;
9109 sort_by_digest = sort_by_digest_8_16;
9110 opti_type = OPTI_TYPE_ZERO_BYTE
9111 | OPTI_TYPE_USES_BITS_64;
9112 dgst_pos0 = 0;
9113 dgst_pos1 = 1;
9114 dgst_pos2 = 2;
9115 dgst_pos3 = 3;
9116 break;
9117
9118 case 7200: hash_type = HASH_TYPE_SHA512;
9119 salt_type = SALT_TYPE_EMBEDDED;
9120 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9121 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9122 kern_type = KERN_TYPE_PBKDF2_SHA512;
9123 dgst_size = DGST_SIZE_8_16;
9124 parse_func = sha512grub_parse_hash;
9125 sort_by_digest = sort_by_digest_8_16;
9126 opti_type = OPTI_TYPE_ZERO_BYTE
9127 | OPTI_TYPE_USES_BITS_64;
9128 dgst_pos0 = 0;
9129 dgst_pos1 = 1;
9130 dgst_pos2 = 2;
9131 dgst_pos3 = 3;
9132 break;
9133
9134 case 7300: hash_type = HASH_TYPE_SHA1;
9135 salt_type = SALT_TYPE_EMBEDDED;
9136 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9137 opts_type = OPTS_TYPE_PT_GENERATE_BE
9138 | OPTS_TYPE_ST_ADD80
9139 | OPTS_TYPE_ST_ADDBITS15;
9140 kern_type = KERN_TYPE_RAKP;
9141 dgst_size = DGST_SIZE_4_5;
9142 parse_func = rakp_parse_hash;
9143 sort_by_digest = sort_by_digest_4_5;
9144 opti_type = OPTI_TYPE_ZERO_BYTE
9145 | OPTI_TYPE_NOT_ITERATED;
9146 dgst_pos0 = 3;
9147 dgst_pos1 = 4;
9148 dgst_pos2 = 2;
9149 dgst_pos3 = 1;
9150 break;
9151
9152 case 7400: hash_type = HASH_TYPE_SHA256;
9153 salt_type = SALT_TYPE_EMBEDDED;
9154 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9155 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9156 kern_type = KERN_TYPE_SHA256CRYPT;
9157 dgst_size = DGST_SIZE_4_8;
9158 parse_func = sha256crypt_parse_hash;
9159 sort_by_digest = sort_by_digest_4_8;
9160 opti_type = OPTI_TYPE_ZERO_BYTE;
9161 dgst_pos0 = 0;
9162 dgst_pos1 = 1;
9163 dgst_pos2 = 2;
9164 dgst_pos3 = 3;
9165 break;
9166
9167 case 7500: hash_type = HASH_TYPE_KRB5PA;
9168 salt_type = SALT_TYPE_EMBEDDED;
9169 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9170 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9171 kern_type = KERN_TYPE_KRB5PA;
9172 dgst_size = DGST_SIZE_4_4;
9173 parse_func = krb5pa_parse_hash;
9174 sort_by_digest = sort_by_digest_4_4;
9175 opti_type = OPTI_TYPE_ZERO_BYTE
9176 | OPTI_TYPE_NOT_ITERATED;
9177 dgst_pos0 = 0;
9178 dgst_pos1 = 1;
9179 dgst_pos2 = 2;
9180 dgst_pos3 = 3;
9181 break;
9182
9183 case 7600: hash_type = HASH_TYPE_SHA1;
9184 salt_type = SALT_TYPE_INTERN;
9185 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9186 opts_type = OPTS_TYPE_PT_GENERATE_BE
9187 | OPTS_TYPE_PT_ADD80
9188 | OPTS_TYPE_PT_ADDBITS15;
9189 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9190 dgst_size = DGST_SIZE_4_5;
9191 parse_func = redmine_parse_hash;
9192 sort_by_digest = sort_by_digest_4_5;
9193 opti_type = OPTI_TYPE_ZERO_BYTE
9194 | OPTI_TYPE_PRECOMPUTE_INIT
9195 | OPTI_TYPE_EARLY_SKIP
9196 | OPTI_TYPE_NOT_ITERATED
9197 | OPTI_TYPE_PREPENDED_SALT;
9198 dgst_pos0 = 3;
9199 dgst_pos1 = 4;
9200 dgst_pos2 = 2;
9201 dgst_pos3 = 1;
9202 break;
9203
9204 case 7700: hash_type = HASH_TYPE_SAPB;
9205 salt_type = SALT_TYPE_EMBEDDED;
9206 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9207 opts_type = OPTS_TYPE_PT_GENERATE_LE
9208 | OPTS_TYPE_PT_UPPER
9209 | OPTS_TYPE_ST_UPPER;
9210 kern_type = KERN_TYPE_SAPB;
9211 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9212 parse_func = sapb_parse_hash;
9213 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9214 opti_type = OPTI_TYPE_ZERO_BYTE
9215 | OPTI_TYPE_PRECOMPUTE_INIT
9216 | OPTI_TYPE_NOT_ITERATED;
9217 dgst_pos0 = 0;
9218 dgst_pos1 = 1;
9219 dgst_pos2 = 2;
9220 dgst_pos3 = 3;
9221 break;
9222
9223 case 7800: hash_type = HASH_TYPE_SAPG;
9224 salt_type = SALT_TYPE_EMBEDDED;
9225 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9226 opts_type = OPTS_TYPE_PT_GENERATE_BE
9227 | OPTS_TYPE_ST_ADD80
9228 | OPTS_TYPE_ST_UPPER;
9229 kern_type = KERN_TYPE_SAPG;
9230 dgst_size = DGST_SIZE_4_5;
9231 parse_func = sapg_parse_hash;
9232 sort_by_digest = sort_by_digest_4_5;
9233 opti_type = OPTI_TYPE_ZERO_BYTE
9234 | OPTI_TYPE_PRECOMPUTE_INIT
9235 | OPTI_TYPE_NOT_ITERATED;
9236 dgst_pos0 = 3;
9237 dgst_pos1 = 4;
9238 dgst_pos2 = 2;
9239 dgst_pos3 = 1;
9240 break;
9241
9242 case 7900: hash_type = HASH_TYPE_SHA512;
9243 salt_type = SALT_TYPE_EMBEDDED;
9244 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9245 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9246 kern_type = KERN_TYPE_DRUPAL7;
9247 dgst_size = DGST_SIZE_8_8;
9248 parse_func = drupal7_parse_hash;
9249 sort_by_digest = sort_by_digest_8_8;
9250 opti_type = OPTI_TYPE_ZERO_BYTE
9251 | OPTI_TYPE_USES_BITS_64;
9252 dgst_pos0 = 0;
9253 dgst_pos1 = 1;
9254 dgst_pos2 = 2;
9255 dgst_pos3 = 3;
9256 break;
9257
9258 case 8000: hash_type = HASH_TYPE_SHA256;
9259 salt_type = SALT_TYPE_EMBEDDED;
9260 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9261 opts_type = OPTS_TYPE_PT_GENERATE_BE
9262 | OPTS_TYPE_PT_UNICODE
9263 | OPTS_TYPE_ST_ADD80
9264 | OPTS_TYPE_ST_HEX;
9265 kern_type = KERN_TYPE_SYBASEASE;
9266 dgst_size = DGST_SIZE_4_8;
9267 parse_func = sybasease_parse_hash;
9268 sort_by_digest = sort_by_digest_4_8;
9269 opti_type = OPTI_TYPE_ZERO_BYTE
9270 | OPTI_TYPE_PRECOMPUTE_INIT
9271 | OPTI_TYPE_EARLY_SKIP
9272 | OPTI_TYPE_NOT_ITERATED
9273 | OPTI_TYPE_RAW_HASH;
9274 dgst_pos0 = 3;
9275 dgst_pos1 = 7;
9276 dgst_pos2 = 2;
9277 dgst_pos3 = 6;
9278 break;
9279
9280 case 8100: hash_type = HASH_TYPE_SHA1;
9281 salt_type = SALT_TYPE_EMBEDDED;
9282 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9283 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9284 kern_type = KERN_TYPE_NETSCALER;
9285 dgst_size = DGST_SIZE_4_5;
9286 parse_func = netscaler_parse_hash;
9287 sort_by_digest = sort_by_digest_4_5;
9288 opti_type = OPTI_TYPE_ZERO_BYTE
9289 | OPTI_TYPE_PRECOMPUTE_INIT
9290 | OPTI_TYPE_PRECOMPUTE_MERKLE
9291 | OPTI_TYPE_EARLY_SKIP
9292 | OPTI_TYPE_NOT_ITERATED
9293 | OPTI_TYPE_PREPENDED_SALT
9294 | OPTI_TYPE_RAW_HASH;
9295 dgst_pos0 = 3;
9296 dgst_pos1 = 4;
9297 dgst_pos2 = 2;
9298 dgst_pos3 = 1;
9299 break;
9300
9301 case 8200: hash_type = HASH_TYPE_SHA256;
9302 salt_type = SALT_TYPE_EMBEDDED;
9303 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9304 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9305 kern_type = KERN_TYPE_CLOUDKEY;
9306 dgst_size = DGST_SIZE_4_8;
9307 parse_func = cloudkey_parse_hash;
9308 sort_by_digest = sort_by_digest_4_8;
9309 opti_type = OPTI_TYPE_ZERO_BYTE;
9310 dgst_pos0 = 0;
9311 dgst_pos1 = 1;
9312 dgst_pos2 = 2;
9313 dgst_pos3 = 3;
9314 break;
9315
9316 case 8300: hash_type = HASH_TYPE_SHA1;
9317 salt_type = SALT_TYPE_EMBEDDED;
9318 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9319 opts_type = OPTS_TYPE_PT_GENERATE_BE
9320 | OPTS_TYPE_ST_HEX
9321 | OPTS_TYPE_ST_ADD80;
9322 kern_type = KERN_TYPE_NSEC3;
9323 dgst_size = DGST_SIZE_4_5;
9324 parse_func = nsec3_parse_hash;
9325 sort_by_digest = sort_by_digest_4_5;
9326 opti_type = OPTI_TYPE_ZERO_BYTE;
9327 dgst_pos0 = 3;
9328 dgst_pos1 = 4;
9329 dgst_pos2 = 2;
9330 dgst_pos3 = 1;
9331 break;
9332
9333 case 8400: hash_type = HASH_TYPE_SHA1;
9334 salt_type = SALT_TYPE_INTERN;
9335 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9336 opts_type = OPTS_TYPE_PT_GENERATE_BE
9337 | OPTS_TYPE_PT_ADD80
9338 | OPTS_TYPE_PT_ADDBITS15;
9339 kern_type = KERN_TYPE_WBB3;
9340 dgst_size = DGST_SIZE_4_5;
9341 parse_func = wbb3_parse_hash;
9342 sort_by_digest = sort_by_digest_4_5;
9343 opti_type = OPTI_TYPE_ZERO_BYTE
9344 | OPTI_TYPE_PRECOMPUTE_INIT
9345 | OPTI_TYPE_NOT_ITERATED;
9346 dgst_pos0 = 3;
9347 dgst_pos1 = 4;
9348 dgst_pos2 = 2;
9349 dgst_pos3 = 1;
9350 break;
9351
9352 case 8500: hash_type = HASH_TYPE_DESRACF;
9353 salt_type = SALT_TYPE_EMBEDDED;
9354 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9355 opts_type = OPTS_TYPE_PT_GENERATE_LE
9356 | OPTS_TYPE_ST_UPPER;
9357 kern_type = KERN_TYPE_RACF;
9358 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9359 parse_func = racf_parse_hash;
9360 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9361 opti_type = OPTI_TYPE_ZERO_BYTE
9362 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9363 dgst_pos0 = 0;
9364 dgst_pos1 = 1;
9365 dgst_pos2 = 2;
9366 dgst_pos3 = 3;
9367 break;
9368
9369 case 8600: hash_type = HASH_TYPE_LOTUS5;
9370 salt_type = SALT_TYPE_NONE;
9371 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9372 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9373 kern_type = KERN_TYPE_LOTUS5;
9374 dgst_size = DGST_SIZE_4_4;
9375 parse_func = lotus5_parse_hash;
9376 sort_by_digest = sort_by_digest_4_4;
9377 opti_type = OPTI_TYPE_EARLY_SKIP
9378 | OPTI_TYPE_NOT_ITERATED
9379 | OPTI_TYPE_NOT_SALTED
9380 | OPTI_TYPE_RAW_HASH;
9381 dgst_pos0 = 0;
9382 dgst_pos1 = 1;
9383 dgst_pos2 = 2;
9384 dgst_pos3 = 3;
9385 break;
9386
9387 case 8700: hash_type = HASH_TYPE_LOTUS6;
9388 salt_type = SALT_TYPE_EMBEDDED;
9389 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9390 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9391 kern_type = KERN_TYPE_LOTUS6;
9392 dgst_size = DGST_SIZE_4_4;
9393 parse_func = lotus6_parse_hash;
9394 sort_by_digest = sort_by_digest_4_4;
9395 opti_type = OPTI_TYPE_EARLY_SKIP
9396 | OPTI_TYPE_NOT_ITERATED
9397 | OPTI_TYPE_RAW_HASH;
9398 dgst_pos0 = 0;
9399 dgst_pos1 = 1;
9400 dgst_pos2 = 2;
9401 dgst_pos3 = 3;
9402 break;
9403
9404 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9405 salt_type = SALT_TYPE_EMBEDDED;
9406 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9407 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9408 kern_type = KERN_TYPE_ANDROIDFDE;
9409 dgst_size = DGST_SIZE_4_4;
9410 parse_func = androidfde_parse_hash;
9411 sort_by_digest = sort_by_digest_4_4;
9412 opti_type = OPTI_TYPE_ZERO_BYTE;
9413 dgst_pos0 = 0;
9414 dgst_pos1 = 1;
9415 dgst_pos2 = 2;
9416 dgst_pos3 = 3;
9417 break;
9418
9419 case 8900: hash_type = HASH_TYPE_SCRYPT;
9420 salt_type = SALT_TYPE_EMBEDDED;
9421 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9422 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9423 kern_type = KERN_TYPE_SCRYPT;
9424 dgst_size = DGST_SIZE_4_8;
9425 parse_func = scrypt_parse_hash;
9426 sort_by_digest = sort_by_digest_4_8;
9427 opti_type = OPTI_TYPE_ZERO_BYTE;
9428 dgst_pos0 = 0;
9429 dgst_pos1 = 1;
9430 dgst_pos2 = 2;
9431 dgst_pos3 = 3;
9432 break;
9433
9434 case 9000: hash_type = HASH_TYPE_SHA1;
9435 salt_type = SALT_TYPE_EMBEDDED;
9436 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9437 opts_type = OPTS_TYPE_PT_GENERATE_LE
9438 | OPTS_TYPE_ST_GENERATE_LE;
9439 kern_type = KERN_TYPE_PSAFE2;
9440 dgst_size = DGST_SIZE_4_5;
9441 parse_func = psafe2_parse_hash;
9442 sort_by_digest = sort_by_digest_4_5;
9443 opti_type = OPTI_TYPE_ZERO_BYTE;
9444 dgst_pos0 = 0;
9445 dgst_pos1 = 1;
9446 dgst_pos2 = 2;
9447 dgst_pos3 = 3;
9448 break;
9449
9450 case 9100: hash_type = HASH_TYPE_LOTUS8;
9451 salt_type = SALT_TYPE_EMBEDDED;
9452 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9453 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9454 kern_type = KERN_TYPE_LOTUS8;
9455 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9456 parse_func = lotus8_parse_hash;
9457 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9458 opti_type = OPTI_TYPE_ZERO_BYTE;
9459 dgst_pos0 = 0;
9460 dgst_pos1 = 1;
9461 dgst_pos2 = 2;
9462 dgst_pos3 = 3;
9463 break;
9464
9465 case 9200: hash_type = HASH_TYPE_SHA256;
9466 salt_type = SALT_TYPE_EMBEDDED;
9467 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9468 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9469 kern_type = KERN_TYPE_PBKDF2_SHA256;
9470 dgst_size = DGST_SIZE_4_32;
9471 parse_func = cisco8_parse_hash;
9472 sort_by_digest = sort_by_digest_4_32;
9473 opti_type = OPTI_TYPE_ZERO_BYTE;
9474 dgst_pos0 = 0;
9475 dgst_pos1 = 1;
9476 dgst_pos2 = 2;
9477 dgst_pos3 = 3;
9478 break;
9479
9480 case 9300: hash_type = HASH_TYPE_SCRYPT;
9481 salt_type = SALT_TYPE_EMBEDDED;
9482 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9483 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9484 kern_type = KERN_TYPE_SCRYPT;
9485 dgst_size = DGST_SIZE_4_8;
9486 parse_func = cisco9_parse_hash;
9487 sort_by_digest = sort_by_digest_4_8;
9488 opti_type = OPTI_TYPE_ZERO_BYTE;
9489 dgst_pos0 = 0;
9490 dgst_pos1 = 1;
9491 dgst_pos2 = 2;
9492 dgst_pos3 = 3;
9493 break;
9494
9495 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9496 salt_type = SALT_TYPE_EMBEDDED;
9497 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9498 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9499 kern_type = KERN_TYPE_OFFICE2007;
9500 dgst_size = DGST_SIZE_4_4;
9501 parse_func = office2007_parse_hash;
9502 sort_by_digest = sort_by_digest_4_4;
9503 opti_type = OPTI_TYPE_ZERO_BYTE;
9504 dgst_pos0 = 0;
9505 dgst_pos1 = 1;
9506 dgst_pos2 = 2;
9507 dgst_pos3 = 3;
9508 break;
9509
9510 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9511 salt_type = SALT_TYPE_EMBEDDED;
9512 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9513 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9514 kern_type = KERN_TYPE_OFFICE2010;
9515 dgst_size = DGST_SIZE_4_4;
9516 parse_func = office2010_parse_hash;
9517 sort_by_digest = sort_by_digest_4_4;
9518 opti_type = OPTI_TYPE_ZERO_BYTE;
9519 dgst_pos0 = 0;
9520 dgst_pos1 = 1;
9521 dgst_pos2 = 2;
9522 dgst_pos3 = 3;
9523 break;
9524
9525 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9526 salt_type = SALT_TYPE_EMBEDDED;
9527 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9528 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9529 kern_type = KERN_TYPE_OFFICE2013;
9530 dgst_size = DGST_SIZE_4_4;
9531 parse_func = office2013_parse_hash;
9532 sort_by_digest = sort_by_digest_4_4;
9533 opti_type = OPTI_TYPE_ZERO_BYTE;
9534 dgst_pos0 = 0;
9535 dgst_pos1 = 1;
9536 dgst_pos2 = 2;
9537 dgst_pos3 = 3;
9538 break;
9539
9540 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9541 salt_type = SALT_TYPE_EMBEDDED;
9542 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9543 opts_type = OPTS_TYPE_PT_GENERATE_LE
9544 | OPTS_TYPE_PT_ADD80
9545 | OPTS_TYPE_PT_UNICODE;
9546 kern_type = KERN_TYPE_OLDOFFICE01;
9547 dgst_size = DGST_SIZE_4_4;
9548 parse_func = oldoffice01_parse_hash;
9549 sort_by_digest = sort_by_digest_4_4;
9550 opti_type = OPTI_TYPE_ZERO_BYTE
9551 | OPTI_TYPE_PRECOMPUTE_INIT
9552 | OPTI_TYPE_NOT_ITERATED;
9553 dgst_pos0 = 0;
9554 dgst_pos1 = 1;
9555 dgst_pos2 = 2;
9556 dgst_pos3 = 3;
9557 break;
9558
9559 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9560 salt_type = SALT_TYPE_EMBEDDED;
9561 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9562 opts_type = OPTS_TYPE_PT_GENERATE_LE
9563 | OPTS_TYPE_PT_ADD80;
9564 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9565 dgst_size = DGST_SIZE_4_4;
9566 parse_func = oldoffice01cm1_parse_hash;
9567 sort_by_digest = sort_by_digest_4_4;
9568 opti_type = OPTI_TYPE_ZERO_BYTE
9569 | OPTI_TYPE_PRECOMPUTE_INIT
9570 | OPTI_TYPE_NOT_ITERATED;
9571 dgst_pos0 = 0;
9572 dgst_pos1 = 1;
9573 dgst_pos2 = 2;
9574 dgst_pos3 = 3;
9575 break;
9576
9577 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9578 salt_type = SALT_TYPE_EMBEDDED;
9579 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9580 opts_type = OPTS_TYPE_PT_GENERATE_LE
9581 | OPTS_TYPE_PT_ADD80
9582 | OPTS_TYPE_PT_UNICODE
9583 | OPTS_TYPE_PT_NEVERCRACK;
9584 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9585 dgst_size = DGST_SIZE_4_4;
9586 parse_func = oldoffice01cm2_parse_hash;
9587 sort_by_digest = sort_by_digest_4_4;
9588 opti_type = OPTI_TYPE_ZERO_BYTE
9589 | OPTI_TYPE_PRECOMPUTE_INIT
9590 | OPTI_TYPE_NOT_ITERATED;
9591 dgst_pos0 = 0;
9592 dgst_pos1 = 1;
9593 dgst_pos2 = 2;
9594 dgst_pos3 = 3;
9595 break;
9596
9597 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9598 salt_type = SALT_TYPE_EMBEDDED;
9599 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9600 opts_type = OPTS_TYPE_PT_GENERATE_BE
9601 | OPTS_TYPE_PT_ADD80
9602 | OPTS_TYPE_PT_UNICODE;
9603 kern_type = KERN_TYPE_OLDOFFICE34;
9604 dgst_size = DGST_SIZE_4_4;
9605 parse_func = oldoffice34_parse_hash;
9606 sort_by_digest = sort_by_digest_4_4;
9607 opti_type = OPTI_TYPE_ZERO_BYTE
9608 | OPTI_TYPE_PRECOMPUTE_INIT
9609 | OPTI_TYPE_NOT_ITERATED;
9610 dgst_pos0 = 0;
9611 dgst_pos1 = 1;
9612 dgst_pos2 = 2;
9613 dgst_pos3 = 3;
9614 break;
9615
9616 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9617 salt_type = SALT_TYPE_EMBEDDED;
9618 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9619 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9620 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9621 dgst_size = DGST_SIZE_4_4;
9622 parse_func = oldoffice34cm1_parse_hash;
9623 sort_by_digest = sort_by_digest_4_4;
9624 opti_type = OPTI_TYPE_ZERO_BYTE
9625 | OPTI_TYPE_PRECOMPUTE_INIT
9626 | OPTI_TYPE_NOT_ITERATED;
9627 dgst_pos0 = 0;
9628 dgst_pos1 = 1;
9629 dgst_pos2 = 2;
9630 dgst_pos3 = 3;
9631 break;
9632
9633 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9634 salt_type = SALT_TYPE_EMBEDDED;
9635 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9636 opts_type = OPTS_TYPE_PT_GENERATE_BE
9637 | OPTS_TYPE_PT_ADD80
9638 | OPTS_TYPE_PT_UNICODE
9639 | OPTS_TYPE_PT_NEVERCRACK;
9640 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9641 dgst_size = DGST_SIZE_4_4;
9642 parse_func = oldoffice34cm2_parse_hash;
9643 sort_by_digest = sort_by_digest_4_4;
9644 opti_type = OPTI_TYPE_ZERO_BYTE
9645 | OPTI_TYPE_PRECOMPUTE_INIT
9646 | OPTI_TYPE_NOT_ITERATED;
9647 dgst_pos0 = 0;
9648 dgst_pos1 = 1;
9649 dgst_pos2 = 2;
9650 dgst_pos3 = 3;
9651 break;
9652
9653 case 9900: hash_type = HASH_TYPE_MD5;
9654 salt_type = SALT_TYPE_NONE;
9655 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9656 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9657 kern_type = KERN_TYPE_RADMIN2;
9658 dgst_size = DGST_SIZE_4_4;
9659 parse_func = radmin2_parse_hash;
9660 sort_by_digest = sort_by_digest_4_4;
9661 opti_type = OPTI_TYPE_ZERO_BYTE
9662 | OPTI_TYPE_PRECOMPUTE_INIT
9663 | OPTI_TYPE_EARLY_SKIP
9664 | OPTI_TYPE_NOT_ITERATED
9665 | OPTI_TYPE_NOT_SALTED;
9666 dgst_pos0 = 0;
9667 dgst_pos1 = 3;
9668 dgst_pos2 = 2;
9669 dgst_pos3 = 1;
9670 break;
9671
9672 case 10000: hash_type = HASH_TYPE_SHA256;
9673 salt_type = SALT_TYPE_EMBEDDED;
9674 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9675 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9676 kern_type = KERN_TYPE_PBKDF2_SHA256;
9677 dgst_size = DGST_SIZE_4_32;
9678 parse_func = djangopbkdf2_parse_hash;
9679 sort_by_digest = sort_by_digest_4_32;
9680 opti_type = OPTI_TYPE_ZERO_BYTE;
9681 dgst_pos0 = 0;
9682 dgst_pos1 = 1;
9683 dgst_pos2 = 2;
9684 dgst_pos3 = 3;
9685 break;
9686
9687 case 10100: hash_type = HASH_TYPE_SIPHASH;
9688 salt_type = SALT_TYPE_EMBEDDED;
9689 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9690 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9691 kern_type = KERN_TYPE_SIPHASH;
9692 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9693 parse_func = siphash_parse_hash;
9694 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9695 opti_type = OPTI_TYPE_ZERO_BYTE
9696 | OPTI_TYPE_NOT_ITERATED
9697 | OPTI_TYPE_RAW_HASH;
9698 dgst_pos0 = 0;
9699 dgst_pos1 = 1;
9700 dgst_pos2 = 2;
9701 dgst_pos3 = 3;
9702 break;
9703
9704 case 10200: hash_type = HASH_TYPE_MD5;
9705 salt_type = SALT_TYPE_EMBEDDED;
9706 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9707 opts_type = OPTS_TYPE_PT_GENERATE_LE
9708 | OPTS_TYPE_ST_ADD80
9709 | OPTS_TYPE_ST_ADDBITS14;
9710 kern_type = KERN_TYPE_HMACMD5_PW;
9711 dgst_size = DGST_SIZE_4_4;
9712 parse_func = crammd5_parse_hash;
9713 sort_by_digest = sort_by_digest_4_4;
9714 opti_type = OPTI_TYPE_ZERO_BYTE
9715 | OPTI_TYPE_NOT_ITERATED;
9716 dgst_pos0 = 0;
9717 dgst_pos1 = 3;
9718 dgst_pos2 = 2;
9719 dgst_pos3 = 1;
9720 break;
9721
9722 case 10300: hash_type = HASH_TYPE_SHA1;
9723 salt_type = SALT_TYPE_EMBEDDED;
9724 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9725 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9726 kern_type = KERN_TYPE_SAPH_SHA1;
9727 dgst_size = DGST_SIZE_4_5;
9728 parse_func = saph_sha1_parse_hash;
9729 sort_by_digest = sort_by_digest_4_5;
9730 opti_type = OPTI_TYPE_ZERO_BYTE;
9731 dgst_pos0 = 0;
9732 dgst_pos1 = 1;
9733 dgst_pos2 = 2;
9734 dgst_pos3 = 3;
9735 break;
9736
9737 case 10400: hash_type = HASH_TYPE_PDFU16;
9738 salt_type = SALT_TYPE_EMBEDDED;
9739 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9740 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9741 kern_type = KERN_TYPE_PDF11;
9742 dgst_size = DGST_SIZE_4_4;
9743 parse_func = pdf11_parse_hash;
9744 sort_by_digest = sort_by_digest_4_4;
9745 opti_type = OPTI_TYPE_ZERO_BYTE
9746 | OPTI_TYPE_NOT_ITERATED;
9747 dgst_pos0 = 0;
9748 dgst_pos1 = 1;
9749 dgst_pos2 = 2;
9750 dgst_pos3 = 3;
9751 break;
9752
9753 case 10410: hash_type = HASH_TYPE_PDFU16;
9754 salt_type = SALT_TYPE_EMBEDDED;
9755 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9756 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9757 kern_type = KERN_TYPE_PDF11CM1;
9758 dgst_size = DGST_SIZE_4_4;
9759 parse_func = pdf11cm1_parse_hash;
9760 sort_by_digest = sort_by_digest_4_4;
9761 opti_type = OPTI_TYPE_ZERO_BYTE
9762 | OPTI_TYPE_NOT_ITERATED;
9763 dgst_pos0 = 0;
9764 dgst_pos1 = 1;
9765 dgst_pos2 = 2;
9766 dgst_pos3 = 3;
9767 break;
9768
9769 case 10420: hash_type = HASH_TYPE_PDFU16;
9770 salt_type = SALT_TYPE_EMBEDDED;
9771 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9772 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9773 kern_type = KERN_TYPE_PDF11CM2;
9774 dgst_size = DGST_SIZE_4_4;
9775 parse_func = pdf11cm2_parse_hash;
9776 sort_by_digest = sort_by_digest_4_4;
9777 opti_type = OPTI_TYPE_ZERO_BYTE
9778 | OPTI_TYPE_NOT_ITERATED;
9779 dgst_pos0 = 0;
9780 dgst_pos1 = 1;
9781 dgst_pos2 = 2;
9782 dgst_pos3 = 3;
9783 break;
9784
9785 case 10500: hash_type = HASH_TYPE_PDFU16;
9786 salt_type = SALT_TYPE_EMBEDDED;
9787 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9788 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9789 kern_type = KERN_TYPE_PDF14;
9790 dgst_size = DGST_SIZE_4_4;
9791 parse_func = pdf14_parse_hash;
9792 sort_by_digest = sort_by_digest_4_4;
9793 opti_type = OPTI_TYPE_ZERO_BYTE
9794 | OPTI_TYPE_NOT_ITERATED;
9795 dgst_pos0 = 0;
9796 dgst_pos1 = 1;
9797 dgst_pos2 = 2;
9798 dgst_pos3 = 3;
9799 break;
9800
9801 case 10600: hash_type = HASH_TYPE_SHA256;
9802 salt_type = SALT_TYPE_EMBEDDED;
9803 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9804 opts_type = OPTS_TYPE_PT_GENERATE_BE
9805 | OPTS_TYPE_ST_ADD80
9806 | OPTS_TYPE_ST_ADDBITS15
9807 | OPTS_TYPE_HASH_COPY;
9808 kern_type = KERN_TYPE_SHA256_PWSLT;
9809 dgst_size = DGST_SIZE_4_8;
9810 parse_func = pdf17l3_parse_hash;
9811 sort_by_digest = sort_by_digest_4_8;
9812 opti_type = OPTI_TYPE_ZERO_BYTE
9813 | OPTI_TYPE_PRECOMPUTE_INIT
9814 | OPTI_TYPE_PRECOMPUTE_MERKLE
9815 | OPTI_TYPE_EARLY_SKIP
9816 | OPTI_TYPE_NOT_ITERATED
9817 | OPTI_TYPE_APPENDED_SALT
9818 | OPTI_TYPE_RAW_HASH;
9819 dgst_pos0 = 3;
9820 dgst_pos1 = 7;
9821 dgst_pos2 = 2;
9822 dgst_pos3 = 6;
9823 break;
9824
9825 case 10700: hash_type = HASH_TYPE_PDFU32;
9826 salt_type = SALT_TYPE_EMBEDDED;
9827 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9828 opts_type = OPTS_TYPE_PT_GENERATE_LE
9829 | OPTS_TYPE_HASH_COPY;
9830 kern_type = KERN_TYPE_PDF17L8;
9831 dgst_size = DGST_SIZE_4_8;
9832 parse_func = pdf17l8_parse_hash;
9833 sort_by_digest = sort_by_digest_4_8;
9834 opti_type = OPTI_TYPE_ZERO_BYTE
9835 | OPTI_TYPE_NOT_ITERATED;
9836 dgst_pos0 = 0;
9837 dgst_pos1 = 1;
9838 dgst_pos2 = 2;
9839 dgst_pos3 = 3;
9840 break;
9841
9842 case 10800: hash_type = HASH_TYPE_SHA384;
9843 salt_type = SALT_TYPE_NONE;
9844 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9845 opts_type = OPTS_TYPE_PT_GENERATE_BE
9846 | OPTS_TYPE_PT_ADD80
9847 | OPTS_TYPE_PT_ADDBITS15;
9848 kern_type = KERN_TYPE_SHA384;
9849 dgst_size = DGST_SIZE_8_8;
9850 parse_func = sha384_parse_hash;
9851 sort_by_digest = sort_by_digest_8_8;
9852 opti_type = OPTI_TYPE_ZERO_BYTE
9853 | OPTI_TYPE_PRECOMPUTE_INIT
9854 | OPTI_TYPE_PRECOMPUTE_MERKLE
9855 | OPTI_TYPE_EARLY_SKIP
9856 | OPTI_TYPE_NOT_ITERATED
9857 | OPTI_TYPE_NOT_SALTED
9858 | OPTI_TYPE_USES_BITS_64
9859 | OPTI_TYPE_RAW_HASH;
9860 dgst_pos0 = 6;
9861 dgst_pos1 = 7;
9862 dgst_pos2 = 4;
9863 dgst_pos3 = 5;
9864 break;
9865
9866 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9867 salt_type = SALT_TYPE_EMBEDDED;
9868 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9869 opts_type = OPTS_TYPE_PT_GENERATE_LE
9870 | OPTS_TYPE_ST_BASE64
9871 | OPTS_TYPE_HASH_COPY;
9872 kern_type = KERN_TYPE_PBKDF2_SHA256;
9873 dgst_size = DGST_SIZE_4_32;
9874 parse_func = pbkdf2_sha256_parse_hash;
9875 sort_by_digest = sort_by_digest_4_32;
9876 opti_type = OPTI_TYPE_ZERO_BYTE;
9877 dgst_pos0 = 0;
9878 dgst_pos1 = 1;
9879 dgst_pos2 = 2;
9880 dgst_pos3 = 3;
9881 break;
9882
9883 case 11000: hash_type = HASH_TYPE_MD5;
9884 salt_type = SALT_TYPE_INTERN;
9885 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9886 opts_type = OPTS_TYPE_PT_GENERATE_LE
9887 | OPTS_TYPE_PT_ADD80;
9888 kern_type = KERN_TYPE_PRESTASHOP;
9889 dgst_size = DGST_SIZE_4_4;
9890 parse_func = prestashop_parse_hash;
9891 sort_by_digest = sort_by_digest_4_4;
9892 opti_type = OPTI_TYPE_ZERO_BYTE
9893 | OPTI_TYPE_PRECOMPUTE_INIT
9894 | OPTI_TYPE_NOT_ITERATED
9895 | OPTI_TYPE_PREPENDED_SALT;
9896 dgst_pos0 = 0;
9897 dgst_pos1 = 3;
9898 dgst_pos2 = 2;
9899 dgst_pos3 = 1;
9900 break;
9901
9902 case 11100: hash_type = HASH_TYPE_MD5;
9903 salt_type = SALT_TYPE_EMBEDDED;
9904 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9905 opts_type = OPTS_TYPE_PT_GENERATE_LE
9906 | OPTS_TYPE_ST_ADD80;
9907 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9908 dgst_size = DGST_SIZE_4_4;
9909 parse_func = postgresql_auth_parse_hash;
9910 sort_by_digest = sort_by_digest_4_4;
9911 opti_type = OPTI_TYPE_ZERO_BYTE
9912 | OPTI_TYPE_PRECOMPUTE_INIT
9913 | OPTI_TYPE_PRECOMPUTE_MERKLE
9914 | OPTI_TYPE_EARLY_SKIP;
9915 dgst_pos0 = 0;
9916 dgst_pos1 = 3;
9917 dgst_pos2 = 2;
9918 dgst_pos3 = 1;
9919 break;
9920
9921 case 11200: hash_type = HASH_TYPE_SHA1;
9922 salt_type = SALT_TYPE_EMBEDDED;
9923 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9924 opts_type = OPTS_TYPE_PT_GENERATE_BE
9925 | OPTS_TYPE_PT_ADD80
9926 | OPTS_TYPE_ST_HEX;
9927 kern_type = KERN_TYPE_MYSQL_AUTH;
9928 dgst_size = DGST_SIZE_4_5;
9929 parse_func = mysql_auth_parse_hash;
9930 sort_by_digest = sort_by_digest_4_5;
9931 opti_type = OPTI_TYPE_ZERO_BYTE
9932 | OPTI_TYPE_EARLY_SKIP;
9933 dgst_pos0 = 3;
9934 dgst_pos1 = 4;
9935 dgst_pos2 = 2;
9936 dgst_pos3 = 1;
9937 break;
9938
9939 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9940 salt_type = SALT_TYPE_EMBEDDED;
9941 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9942 opts_type = OPTS_TYPE_PT_GENERATE_LE
9943 | OPTS_TYPE_ST_HEX
9944 | OPTS_TYPE_ST_ADD80;
9945 kern_type = KERN_TYPE_BITCOIN_WALLET;
9946 dgst_size = DGST_SIZE_4_4;
9947 parse_func = bitcoin_wallet_parse_hash;
9948 sort_by_digest = sort_by_digest_4_4;
9949 opti_type = OPTI_TYPE_ZERO_BYTE;
9950 dgst_pos0 = 0;
9951 dgst_pos1 = 1;
9952 dgst_pos2 = 2;
9953 dgst_pos3 = 3;
9954 break;
9955
9956 case 11400: hash_type = HASH_TYPE_MD5;
9957 salt_type = SALT_TYPE_EMBEDDED;
9958 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9959 opts_type = OPTS_TYPE_PT_GENERATE_LE
9960 | OPTS_TYPE_PT_ADD80
9961 | OPTS_TYPE_HASH_COPY;
9962 kern_type = KERN_TYPE_SIP_AUTH;
9963 dgst_size = DGST_SIZE_4_4;
9964 parse_func = sip_auth_parse_hash;
9965 sort_by_digest = sort_by_digest_4_4;
9966 opti_type = OPTI_TYPE_ZERO_BYTE;
9967 dgst_pos0 = 0;
9968 dgst_pos1 = 3;
9969 dgst_pos2 = 2;
9970 dgst_pos3 = 1;
9971 break;
9972
9973 case 11500: hash_type = HASH_TYPE_CRC32;
9974 salt_type = SALT_TYPE_INTERN;
9975 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9976 opts_type = OPTS_TYPE_PT_GENERATE_LE
9977 | OPTS_TYPE_ST_GENERATE_LE
9978 | OPTS_TYPE_ST_HEX;
9979 kern_type = KERN_TYPE_CRC32;
9980 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9981 parse_func = crc32_parse_hash;
9982 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9983 opti_type = OPTI_TYPE_ZERO_BYTE;
9984 dgst_pos0 = 0;
9985 dgst_pos1 = 1;
9986 dgst_pos2 = 2;
9987 dgst_pos3 = 3;
9988 break;
9989
9990 case 11600: hash_type = HASH_TYPE_AES;
9991 salt_type = SALT_TYPE_EMBEDDED;
9992 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9993 opts_type = OPTS_TYPE_PT_GENERATE_LE
9994 | OPTS_TYPE_PT_NEVERCRACK;
9995 kern_type = KERN_TYPE_SEVEN_ZIP;
9996 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9997 parse_func = seven_zip_parse_hash;
9998 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9999 opti_type = OPTI_TYPE_ZERO_BYTE;
10000 dgst_pos0 = 0;
10001 dgst_pos1 = 1;
10002 dgst_pos2 = 2;
10003 dgst_pos3 = 3;
10004 break;
10005
10006 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10007 salt_type = SALT_TYPE_NONE;
10008 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10009 opts_type = OPTS_TYPE_PT_GENERATE_LE
10010 | OPTS_TYPE_PT_ADD01;
10011 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10012 dgst_size = DGST_SIZE_4_8;
10013 parse_func = gost2012sbog_256_parse_hash;
10014 sort_by_digest = sort_by_digest_4_8;
10015 opti_type = OPTI_TYPE_ZERO_BYTE;
10016 dgst_pos0 = 0;
10017 dgst_pos1 = 1;
10018 dgst_pos2 = 2;
10019 dgst_pos3 = 3;
10020 break;
10021
10022 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10023 salt_type = SALT_TYPE_NONE;
10024 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10025 opts_type = OPTS_TYPE_PT_GENERATE_LE
10026 | OPTS_TYPE_PT_ADD01;
10027 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10028 dgst_size = DGST_SIZE_4_16;
10029 parse_func = gost2012sbog_512_parse_hash;
10030 sort_by_digest = sort_by_digest_4_16;
10031 opti_type = OPTI_TYPE_ZERO_BYTE;
10032 dgst_pos0 = 0;
10033 dgst_pos1 = 1;
10034 dgst_pos2 = 2;
10035 dgst_pos3 = 3;
10036 break;
10037
10038 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10039 salt_type = SALT_TYPE_EMBEDDED;
10040 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10041 opts_type = OPTS_TYPE_PT_GENERATE_LE
10042 | OPTS_TYPE_ST_BASE64
10043 | OPTS_TYPE_HASH_COPY;
10044 kern_type = KERN_TYPE_PBKDF2_MD5;
10045 dgst_size = DGST_SIZE_4_32;
10046 parse_func = pbkdf2_md5_parse_hash;
10047 sort_by_digest = sort_by_digest_4_32;
10048 opti_type = OPTI_TYPE_ZERO_BYTE;
10049 dgst_pos0 = 0;
10050 dgst_pos1 = 1;
10051 dgst_pos2 = 2;
10052 dgst_pos3 = 3;
10053 break;
10054
10055 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10056 salt_type = SALT_TYPE_EMBEDDED;
10057 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10058 opts_type = OPTS_TYPE_PT_GENERATE_LE
10059 | OPTS_TYPE_ST_BASE64
10060 | OPTS_TYPE_HASH_COPY;
10061 kern_type = KERN_TYPE_PBKDF2_SHA1;
10062 dgst_size = DGST_SIZE_4_32;
10063 parse_func = pbkdf2_sha1_parse_hash;
10064 sort_by_digest = sort_by_digest_4_32;
10065 opti_type = OPTI_TYPE_ZERO_BYTE;
10066 dgst_pos0 = 0;
10067 dgst_pos1 = 1;
10068 dgst_pos2 = 2;
10069 dgst_pos3 = 3;
10070 break;
10071
10072 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10073 salt_type = SALT_TYPE_EMBEDDED;
10074 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10075 opts_type = OPTS_TYPE_PT_GENERATE_LE
10076 | OPTS_TYPE_ST_BASE64
10077 | OPTS_TYPE_HASH_COPY;
10078 kern_type = KERN_TYPE_PBKDF2_SHA512;
10079 dgst_size = DGST_SIZE_8_16;
10080 parse_func = pbkdf2_sha512_parse_hash;
10081 sort_by_digest = sort_by_digest_8_16;
10082 opti_type = OPTI_TYPE_ZERO_BYTE
10083 | OPTI_TYPE_USES_BITS_64;
10084 dgst_pos0 = 0;
10085 dgst_pos1 = 1;
10086 dgst_pos2 = 2;
10087 dgst_pos3 = 3;
10088 break;
10089
10090 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10091 salt_type = SALT_TYPE_EMBEDDED;
10092 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10093 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10094 kern_type = KERN_TYPE_ECRYPTFS;
10095 dgst_size = DGST_SIZE_8_8;
10096 parse_func = ecryptfs_parse_hash;
10097 sort_by_digest = sort_by_digest_8_8;
10098 opti_type = OPTI_TYPE_ZERO_BYTE
10099 | OPTI_TYPE_USES_BITS_64;
10100 dgst_pos0 = 0;
10101 dgst_pos1 = 1;
10102 dgst_pos2 = 2;
10103 dgst_pos3 = 3;
10104 break;
10105
10106 case 12300: hash_type = HASH_TYPE_ORACLET;
10107 salt_type = SALT_TYPE_EMBEDDED;
10108 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10109 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10110 kern_type = KERN_TYPE_ORACLET;
10111 dgst_size = DGST_SIZE_8_16;
10112 parse_func = oraclet_parse_hash;
10113 sort_by_digest = sort_by_digest_8_16;
10114 opti_type = OPTI_TYPE_ZERO_BYTE
10115 | OPTI_TYPE_USES_BITS_64;
10116 dgst_pos0 = 0;
10117 dgst_pos1 = 1;
10118 dgst_pos2 = 2;
10119 dgst_pos3 = 3;
10120 break;
10121
10122 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10123 salt_type = SALT_TYPE_EMBEDDED;
10124 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10125 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10126 kern_type = KERN_TYPE_BSDICRYPT;
10127 dgst_size = DGST_SIZE_4_4;
10128 parse_func = bsdicrypt_parse_hash;
10129 sort_by_digest = sort_by_digest_4_4;
10130 opti_type = OPTI_TYPE_ZERO_BYTE
10131 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10132 dgst_pos0 = 0;
10133 dgst_pos1 = 1;
10134 dgst_pos2 = 2;
10135 dgst_pos3 = 3;
10136 break;
10137
10138 case 12500: hash_type = HASH_TYPE_RAR3HP;
10139 salt_type = SALT_TYPE_EMBEDDED;
10140 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10141 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10142 kern_type = KERN_TYPE_RAR3;
10143 dgst_size = DGST_SIZE_4_4;
10144 parse_func = rar3hp_parse_hash;
10145 sort_by_digest = sort_by_digest_4_4;
10146 opti_type = OPTI_TYPE_ZERO_BYTE;
10147 dgst_pos0 = 0;
10148 dgst_pos1 = 1;
10149 dgst_pos2 = 2;
10150 dgst_pos3 = 3;
10151 break;
10152
10153 case 12600: hash_type = HASH_TYPE_SHA256;
10154 salt_type = SALT_TYPE_INTERN;
10155 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10156 opts_type = OPTS_TYPE_PT_GENERATE_BE
10157 | OPTS_TYPE_PT_ADD80;
10158 kern_type = KERN_TYPE_CF10;
10159 dgst_size = DGST_SIZE_4_8;
10160 parse_func = cf10_parse_hash;
10161 sort_by_digest = sort_by_digest_4_8;
10162 opti_type = OPTI_TYPE_ZERO_BYTE
10163 | OPTI_TYPE_PRECOMPUTE_INIT
10164 | OPTI_TYPE_EARLY_SKIP
10165 | OPTI_TYPE_NOT_ITERATED;
10166 dgst_pos0 = 3;
10167 dgst_pos1 = 7;
10168 dgst_pos2 = 2;
10169 dgst_pos3 = 6;
10170 break;
10171
10172 case 12700: hash_type = HASH_TYPE_AES;
10173 salt_type = SALT_TYPE_EMBEDDED;
10174 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10175 opts_type = OPTS_TYPE_PT_GENERATE_LE
10176 | OPTS_TYPE_HASH_COPY;
10177 kern_type = KERN_TYPE_MYWALLET;
10178 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10179 parse_func = mywallet_parse_hash;
10180 sort_by_digest = sort_by_digest_4_5;
10181 opti_type = OPTI_TYPE_ZERO_BYTE;
10182 dgst_pos0 = 0;
10183 dgst_pos1 = 1;
10184 dgst_pos2 = 2;
10185 dgst_pos3 = 3;
10186 break;
10187
10188 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10189 salt_type = SALT_TYPE_EMBEDDED;
10190 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10191 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10192 kern_type = KERN_TYPE_MS_DRSR;
10193 dgst_size = DGST_SIZE_4_8;
10194 parse_func = ms_drsr_parse_hash;
10195 sort_by_digest = sort_by_digest_4_8;
10196 opti_type = OPTI_TYPE_ZERO_BYTE;
10197 dgst_pos0 = 0;
10198 dgst_pos1 = 1;
10199 dgst_pos2 = 2;
10200 dgst_pos3 = 3;
10201 break;
10202
10203 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10204 salt_type = SALT_TYPE_EMBEDDED;
10205 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10206 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10207 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10208 dgst_size = DGST_SIZE_4_8;
10209 parse_func = androidfde_samsung_parse_hash;
10210 sort_by_digest = sort_by_digest_4_8;
10211 opti_type = OPTI_TYPE_ZERO_BYTE;
10212 dgst_pos0 = 0;
10213 dgst_pos1 = 1;
10214 dgst_pos2 = 2;
10215 dgst_pos3 = 3;
10216 break;
10217
10218 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10219 salt_type = SALT_TYPE_EMBEDDED;
10220 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10221 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10222 kern_type = KERN_TYPE_RAR5;
10223 dgst_size = DGST_SIZE_4_4;
10224 parse_func = rar5_parse_hash;
10225 sort_by_digest = sort_by_digest_4_4;
10226 opti_type = OPTI_TYPE_ZERO_BYTE;
10227 dgst_pos0 = 0;
10228 dgst_pos1 = 1;
10229 dgst_pos2 = 2;
10230 dgst_pos3 = 3;
10231 break;
10232
10233 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10234 salt_type = SALT_TYPE_EMBEDDED;
10235 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10236 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10237 kern_type = KERN_TYPE_KRB5TGS;
10238 dgst_size = DGST_SIZE_4_4;
10239 parse_func = krb5tgs_parse_hash;
10240 sort_by_digest = sort_by_digest_4_4;
10241 opti_type = OPTI_TYPE_ZERO_BYTE
10242 | OPTI_TYPE_NOT_ITERATED;
10243 dgst_pos0 = 0;
10244 dgst_pos1 = 1;
10245 dgst_pos2 = 2;
10246 dgst_pos3 = 3;
10247 break;
10248
10249 case 13200: hash_type = HASH_TYPE_AES;
10250 salt_type = SALT_TYPE_EMBEDDED;
10251 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10252 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10253 kern_type = KERN_TYPE_AXCRYPT;
10254 dgst_size = DGST_SIZE_4_4;
10255 parse_func = axcrypt_parse_hash;
10256 sort_by_digest = sort_by_digest_4_4;
10257 opti_type = OPTI_TYPE_ZERO_BYTE;
10258 dgst_pos0 = 0;
10259 dgst_pos1 = 1;
10260 dgst_pos2 = 2;
10261 dgst_pos3 = 3;
10262 break;
10263
10264 case 13300: hash_type = HASH_TYPE_SHA1;
10265 salt_type = SALT_TYPE_NONE;
10266 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10267 opts_type = OPTS_TYPE_PT_GENERATE_BE
10268 | OPTS_TYPE_PT_ADD80
10269 | OPTS_TYPE_PT_ADDBITS15;
10270 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10271 dgst_size = DGST_SIZE_4_5;
10272 parse_func = sha1axcrypt_parse_hash;
10273 sort_by_digest = sort_by_digest_4_5;
10274 opti_type = OPTI_TYPE_ZERO_BYTE
10275 | OPTI_TYPE_PRECOMPUTE_INIT
10276 | OPTI_TYPE_EARLY_SKIP
10277 | OPTI_TYPE_NOT_ITERATED
10278 | OPTI_TYPE_NOT_SALTED;
10279 dgst_pos0 = 0;
10280 dgst_pos1 = 4;
10281 dgst_pos2 = 3;
10282 dgst_pos3 = 2;
10283 break;
10284
10285 case 13400: hash_type = HASH_TYPE_AES;
10286 salt_type = SALT_TYPE_EMBEDDED;
10287 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10288 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10289 kern_type = KERN_TYPE_KEEPASS;
10290 dgst_size = DGST_SIZE_4_4;
10291 parse_func = keepass_parse_hash;
10292 sort_by_digest = sort_by_digest_4_4;
10293 opti_type = OPTI_TYPE_ZERO_BYTE;
10294 dgst_pos0 = 0;
10295 dgst_pos1 = 1;
10296 dgst_pos2 = 2;
10297 dgst_pos3 = 3;
10298 break;
10299
10300 default: usage_mini_print (PROGNAME); return (-1);
10301 }
10302
10303 /**
10304 * parser
10305 */
10306
10307 data.parse_func = parse_func;
10308
10309 /**
10310 * misc stuff
10311 */
10312
10313 if (hex_salt)
10314 {
10315 if (salt_type == SALT_TYPE_INTERN)
10316 {
10317 opts_type |= OPTS_TYPE_ST_HEX;
10318 }
10319 else
10320 {
10321 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10322
10323 return (-1);
10324 }
10325 }
10326
10327 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10328 | (salt_type == SALT_TYPE_EXTERN)
10329 | (salt_type == SALT_TYPE_EMBEDDED)
10330 | (salt_type == SALT_TYPE_VIRTUAL));
10331
10332 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10333
10334 data.hash_type = hash_type;
10335 data.attack_mode = attack_mode;
10336 data.attack_kern = attack_kern;
10337 data.attack_exec = attack_exec;
10338 data.kern_type = kern_type;
10339 data.opts_type = opts_type;
10340 data.dgst_size = dgst_size;
10341 data.salt_type = salt_type;
10342 data.isSalted = isSalted;
10343 data.sort_by_digest = sort_by_digest;
10344 data.dgst_pos0 = dgst_pos0;
10345 data.dgst_pos1 = dgst_pos1;
10346 data.dgst_pos2 = dgst_pos2;
10347 data.dgst_pos3 = dgst_pos3;
10348
10349 esalt_size = 0;
10350
10351 switch (hash_mode)
10352 {
10353 case 2500: esalt_size = sizeof (wpa_t); break;
10354 case 5300: esalt_size = sizeof (ikepsk_t); break;
10355 case 5400: esalt_size = sizeof (ikepsk_t); break;
10356 case 5500: esalt_size = sizeof (netntlm_t); break;
10357 case 5600: esalt_size = sizeof (netntlm_t); break;
10358 case 6211: esalt_size = sizeof (tc_t); break;
10359 case 6212: esalt_size = sizeof (tc_t); break;
10360 case 6213: esalt_size = sizeof (tc_t); break;
10361 case 6221: esalt_size = sizeof (tc_t); break;
10362 case 6222: esalt_size = sizeof (tc_t); break;
10363 case 6223: esalt_size = sizeof (tc_t); break;
10364 case 6231: esalt_size = sizeof (tc_t); break;
10365 case 6232: esalt_size = sizeof (tc_t); break;
10366 case 6233: esalt_size = sizeof (tc_t); break;
10367 case 6241: esalt_size = sizeof (tc_t); break;
10368 case 6242: esalt_size = sizeof (tc_t); break;
10369 case 6243: esalt_size = sizeof (tc_t); break;
10370 case 6600: esalt_size = sizeof (agilekey_t); break;
10371 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10372 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10373 case 7300: esalt_size = sizeof (rakp_t); break;
10374 case 7500: esalt_size = sizeof (krb5pa_t); break;
10375 case 8200: esalt_size = sizeof (cloudkey_t); break;
10376 case 8800: esalt_size = sizeof (androidfde_t); break;
10377 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10378 case 9400: esalt_size = sizeof (office2007_t); break;
10379 case 9500: esalt_size = sizeof (office2010_t); break;
10380 case 9600: esalt_size = sizeof (office2013_t); break;
10381 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10382 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10383 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10384 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10385 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10386 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10387 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10388 case 10200: esalt_size = sizeof (cram_md5_t); break;
10389 case 10400: esalt_size = sizeof (pdf_t); break;
10390 case 10410: esalt_size = sizeof (pdf_t); break;
10391 case 10420: esalt_size = sizeof (pdf_t); break;
10392 case 10500: esalt_size = sizeof (pdf_t); break;
10393 case 10600: esalt_size = sizeof (pdf_t); break;
10394 case 10700: esalt_size = sizeof (pdf_t); break;
10395 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10396 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10397 case 11400: esalt_size = sizeof (sip_t); break;
10398 case 11600: esalt_size = sizeof (seven_zip_t); break;
10399 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10400 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10401 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10402 case 13000: esalt_size = sizeof (rar5_t); break;
10403 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10404 case 13400: esalt_size = sizeof (keepass_t); break;
10405 }
10406
10407 data.esalt_size = esalt_size;
10408
10409 /**
10410 * choose dictionary parser
10411 */
10412
10413 if (hash_type == HASH_TYPE_LM)
10414 {
10415 get_next_word_func = get_next_word_lm;
10416 }
10417 else if (opts_type & OPTS_TYPE_PT_UPPER)
10418 {
10419 get_next_word_func = get_next_word_uc;
10420 }
10421 else
10422 {
10423 get_next_word_func = get_next_word_std;
10424 }
10425
10426 /**
10427 * dictstat
10428 */
10429
10430 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10431
10432 #ifdef _POSIX
10433 size_t dictstat_nmemb = 0;
10434 #endif
10435
10436 #ifdef _WIN
10437 uint dictstat_nmemb = 0;
10438 #endif
10439
10440 char dictstat[256] = { 0 };
10441
10442 FILE *dictstat_fp = NULL;
10443
10444 if (keyspace == 0)
10445 {
10446 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10447
10448 dictstat_fp = fopen (dictstat, "rb");
10449
10450 if (dictstat_fp)
10451 {
10452 #ifdef _POSIX
10453 struct stat tmpstat;
10454
10455 fstat (fileno (dictstat_fp), &tmpstat);
10456 #endif
10457
10458 #ifdef _WIN
10459 struct stat64 tmpstat;
10460
10461 _fstat64 (fileno (dictstat_fp), &tmpstat);
10462 #endif
10463
10464 if (tmpstat.st_mtime < COMPTIME)
10465 {
10466 /* with v0.15 the format changed so we have to ensure user is using a good version
10467 since there is no version-header in the dictstat file */
10468
10469 fclose (dictstat_fp);
10470
10471 unlink (dictstat);
10472 }
10473 else
10474 {
10475 while (!feof (dictstat_fp))
10476 {
10477 dictstat_t d;
10478
10479 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10480
10481 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10482
10483 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10484 {
10485 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10486
10487 return -1;
10488 }
10489 }
10490
10491 fclose (dictstat_fp);
10492 }
10493 }
10494 }
10495
10496 /**
10497 * potfile
10498 */
10499
10500 char potfile[256] = { 0 };
10501
10502 if (potfile_path == NULL)
10503 {
10504 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10505 }
10506 else
10507 {
10508 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10509 }
10510
10511 data.pot_fp = NULL;
10512
10513 FILE *out_fp = NULL;
10514 FILE *pot_fp = NULL;
10515
10516 if (show == 1 || left == 1)
10517 {
10518 pot_fp = fopen (potfile, "rb");
10519
10520 if (pot_fp == NULL)
10521 {
10522 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10523
10524 return (-1);
10525 }
10526
10527 if (outfile != NULL)
10528 {
10529 if ((out_fp = fopen (outfile, "ab")) == NULL)
10530 {
10531 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10532
10533 fclose (pot_fp);
10534
10535 return (-1);
10536 }
10537 }
10538 else
10539 {
10540 out_fp = stdout;
10541 }
10542 }
10543 else
10544 {
10545 if (potfile_disable == 0)
10546 {
10547 pot_fp = fopen (potfile, "ab");
10548
10549 if (pot_fp == NULL)
10550 {
10551 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10552
10553 return (-1);
10554 }
10555
10556 data.pot_fp = pot_fp;
10557 }
10558 }
10559
10560 pot_t *pot = NULL;
10561
10562 uint pot_cnt = 0;
10563 uint pot_avail = 0;
10564
10565 if (show == 1 || left == 1)
10566 {
10567 SUPPRESS_OUTPUT = 1;
10568
10569 pot_avail = count_lines (pot_fp);
10570
10571 rewind (pot_fp);
10572
10573 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10574
10575 uint pot_hashes_avail = 0;
10576
10577 uint line_num = 0;
10578
10579 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10580
10581 while (!feof (pot_fp))
10582 {
10583 line_num++;
10584
10585 int line_len = fgetl (pot_fp, line_buf);
10586
10587 if (line_len == 0) continue;
10588
10589 char *plain_buf = line_buf + line_len;
10590
10591 pot_t *pot_ptr = &pot[pot_cnt];
10592
10593 hash_t *hashes_buf = &pot_ptr->hash;
10594
10595 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10596 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10597
10598 if (pot_cnt == pot_hashes_avail)
10599 {
10600 uint pos = 0;
10601
10602 for (pos = 0; pos < INCR_POT; pos++)
10603 {
10604 if ((pot_cnt + pos) >= pot_avail) break;
10605
10606 pot_t *tmp_pot = &pot[pot_cnt + pos];
10607
10608 hash_t *tmp_hash = &tmp_pot->hash;
10609
10610 tmp_hash->digest = mymalloc (dgst_size);
10611
10612 if (isSalted)
10613 {
10614 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10615 }
10616
10617 if (esalt_size)
10618 {
10619 tmp_hash->esalt = mymalloc (esalt_size);
10620 }
10621
10622 pot_hashes_avail++;
10623 }
10624 }
10625
10626 int plain_len = 0;
10627
10628 int parser_status;
10629
10630 int iter = MAX_CUT_TRIES;
10631
10632 do
10633 {
10634 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10635 {
10636 if (line_buf[i] == ':')
10637 {
10638 line_len--;
10639
10640 break;
10641 }
10642 }
10643
10644 if (data.hash_mode != 2500)
10645 {
10646 parser_status = parse_func (line_buf, line_len, hashes_buf);
10647 }
10648 else
10649 {
10650 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10651
10652 if (line_len > max_salt_size)
10653 {
10654 parser_status = PARSER_GLOBAL_LENGTH;
10655 }
10656 else
10657 {
10658 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10659
10660 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10661
10662 hashes_buf->salt->salt_len = line_len;
10663
10664 parser_status = PARSER_OK;
10665 }
10666 }
10667
10668 // if NOT parsed without error, we add the ":" to the plain
10669
10670 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10671 {
10672 plain_len++;
10673 plain_buf--;
10674 }
10675
10676 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10677
10678 if (parser_status < PARSER_GLOBAL_ZERO)
10679 {
10680 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10681
10682 continue;
10683 }
10684
10685 if (plain_len >= 255) continue;
10686
10687 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10688
10689 pot_ptr->plain_len = plain_len;
10690
10691 pot_cnt++;
10692 }
10693
10694 myfree (line_buf);
10695
10696 fclose (pot_fp);
10697
10698 SUPPRESS_OUTPUT = 0;
10699
10700 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10701 }
10702
10703 /**
10704 * word len
10705 */
10706
10707 uint pw_min = PW_MIN;
10708 uint pw_max = PW_MAX;
10709
10710 switch (hash_mode)
10711 {
10712 case 125: if (pw_max > 32) pw_max = 32;
10713 break;
10714 case 400: if (pw_max > 40) pw_max = 40;
10715 break;
10716 case 500: if (pw_max > 16) pw_max = 16;
10717 break;
10718 case 1500: if (pw_max > 8) pw_max = 8;
10719 break;
10720 case 1600: if (pw_max > 16) pw_max = 16;
10721 break;
10722 case 1800: if (pw_max > 16) pw_max = 16;
10723 break;
10724 case 2100: if (pw_max > 16) pw_max = 16;
10725 break;
10726 case 2500: if (pw_min < 8) pw_min = 8;
10727 break;
10728 case 3000: if (pw_max > 7) pw_max = 7;
10729 break;
10730 case 5200: if (pw_max > 24) pw_max = 24;
10731 break;
10732 case 5800: if (pw_max > 16) pw_max = 16;
10733 break;
10734 case 6300: if (pw_max > 16) pw_max = 16;
10735 break;
10736 case 7400: if (pw_max > 16) pw_max = 16;
10737 break;
10738 case 7900: if (pw_max > 48) pw_max = 48;
10739 break;
10740 case 8500: if (pw_max > 8) pw_max = 8;
10741 break;
10742 case 8600: if (pw_max > 16) pw_max = 16;
10743 break;
10744 case 9710: pw_min = 5;
10745 pw_max = 5;
10746 break;
10747 case 9810: pw_min = 5;
10748 pw_max = 5;
10749 break;
10750 case 10410: pw_min = 5;
10751 pw_max = 5;
10752 break;
10753 case 10300: if (pw_max < 3) pw_min = 3;
10754 if (pw_max > 40) pw_max = 40;
10755 break;
10756 case 10500: if (pw_max < 3) pw_min = 3;
10757 if (pw_max > 40) pw_max = 40;
10758 break;
10759 case 10700: if (pw_max > 16) pw_max = 16;
10760 break;
10761 case 11300: if (pw_max > 40) pw_max = 40;
10762 break;
10763 case 12500: if (pw_max > 20) pw_max = 20;
10764 break;
10765 case 12800: if (pw_max > 24) pw_max = 24;
10766 break;
10767 }
10768
10769 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10770 {
10771 switch (attack_kern)
10772 {
10773 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10774 break;
10775 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10776 break;
10777 }
10778 }
10779
10780 /**
10781 * charsets : keep them together for more easy maintainnce
10782 */
10783
10784 cs_t mp_sys[6] = { { { 0 }, 0 } };
10785 cs_t mp_usr[4] = { { { 0 }, 0 } };
10786
10787 mp_setup_sys (mp_sys);
10788
10789 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10790 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10791 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10792 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10793
10794 /**
10795 * load hashes, part I: find input mode, count hashes
10796 */
10797
10798 uint hashlist_mode = 0;
10799 uint hashlist_format = HLFMT_HASHCAT;
10800
10801 uint hashes_avail = 0;
10802
10803 if (benchmark == 0)
10804 {
10805 struct stat f;
10806
10807 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10808
10809 if ((hash_mode == 2500) ||
10810 (hash_mode == 5200) ||
10811 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10812 (hash_mode == 9000))
10813 {
10814 hashlist_mode = HL_MODE_ARG;
10815
10816 char *hashfile = myargv[optind];
10817
10818 data.hashfile = hashfile;
10819
10820 logfile_top_var_string ("target", hashfile);
10821 }
10822
10823 if (hashlist_mode == HL_MODE_ARG)
10824 {
10825 if (hash_mode == 2500)
10826 {
10827 struct stat st;
10828
10829 if (stat (data.hashfile, &st) == -1)
10830 {
10831 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10832
10833 return (-1);
10834 }
10835
10836 hashes_avail = st.st_size / sizeof (hccap_t);
10837 }
10838 else
10839 {
10840 hashes_avail = 1;
10841 }
10842 }
10843 else if (hashlist_mode == HL_MODE_FILE)
10844 {
10845 char *hashfile = myargv[optind];
10846
10847 data.hashfile = hashfile;
10848
10849 logfile_top_var_string ("target", hashfile);
10850
10851 FILE *fp = NULL;
10852
10853 if ((fp = fopen (hashfile, "rb")) == NULL)
10854 {
10855 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10856
10857 return (-1);
10858 }
10859
10860 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10861
10862 hashes_avail = count_lines (fp);
10863
10864 rewind (fp);
10865
10866 if (hashes_avail == 0)
10867 {
10868 log_error ("ERROR: hashfile is empty or corrupt");
10869
10870 fclose (fp);
10871
10872 return (-1);
10873 }
10874
10875 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10876
10877 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10878 {
10879 log_error ("ERROR: remove not supported in native hashfile-format mode");
10880
10881 fclose (fp);
10882
10883 return (-1);
10884 }
10885
10886 fclose (fp);
10887 }
10888 }
10889 else
10890 {
10891 hashlist_mode = HL_MODE_ARG;
10892
10893 hashes_avail = 1;
10894 }
10895
10896 if (hash_mode == 3000) hashes_avail *= 2;
10897
10898 data.hashlist_mode = hashlist_mode;
10899 data.hashlist_format = hashlist_format;
10900
10901 logfile_top_uint (hashlist_mode);
10902 logfile_top_uint (hashlist_format);
10903
10904 /**
10905 * load hashes, part II: allocate required memory, set pointers
10906 */
10907
10908 hash_t *hashes_buf = NULL;
10909 void *digests_buf = NULL;
10910 salt_t *salts_buf = NULL;
10911 void *esalts_buf = NULL;
10912
10913 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10914
10915 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10916
10917 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10918 {
10919 u32 hash_pos;
10920
10921 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10922 {
10923 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10924
10925 hashes_buf[hash_pos].hash_info = hash_info;
10926
10927 if (username && (remove || show || left))
10928 {
10929 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10930 }
10931
10932 if (benchmark)
10933 {
10934 hash_info->orighash = (char *) mymalloc (256);
10935 }
10936 }
10937 }
10938
10939 if (isSalted)
10940 {
10941 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10942
10943 if (esalt_size)
10944 {
10945 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10946 }
10947 }
10948 else
10949 {
10950 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10951 }
10952
10953 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10954 {
10955 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10956
10957 if (isSalted)
10958 {
10959 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10960
10961 if (esalt_size)
10962 {
10963 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10964 }
10965 }
10966 else
10967 {
10968 hashes_buf[hash_pos].salt = &salts_buf[0];
10969 }
10970 }
10971
10972 /**
10973 * load hashes, part III: parse hashes or generate them if benchmark
10974 */
10975
10976 uint hashes_cnt = 0;
10977
10978 if (benchmark == 0)
10979 {
10980 if (keyspace == 1)
10981 {
10982 // useless to read hash file for keyspace, cheat a little bit w/ optind
10983 }
10984 else if (hashes_avail == 0)
10985 {
10986 }
10987 else if (hashlist_mode == HL_MODE_ARG)
10988 {
10989 char *input_buf = myargv[optind];
10990
10991 uint input_len = strlen (input_buf);
10992
10993 logfile_top_var_string ("target", input_buf);
10994
10995 char *hash_buf = NULL;
10996 int hash_len = 0;
10997
10998 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10999
11000 bool hash_fmt_error = 0;
11001
11002 if (hash_len < 1) hash_fmt_error = 1;
11003 if (hash_buf == NULL) hash_fmt_error = 1;
11004
11005 if (hash_fmt_error)
11006 {
11007 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11008 }
11009 else
11010 {
11011 if (opts_type & OPTS_TYPE_HASH_COPY)
11012 {
11013 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11014
11015 hash_info_tmp->orighash = mystrdup (hash_buf);
11016 }
11017
11018 if (isSalted)
11019 {
11020 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11021 }
11022
11023 int parser_status = PARSER_OK;
11024
11025 if (hash_mode == 2500)
11026 {
11027 if (hash_len == 0)
11028 {
11029 log_error ("ERROR: hccap file not specified");
11030
11031 return (-1);
11032 }
11033
11034 hashlist_mode = HL_MODE_FILE;
11035
11036 data.hashlist_mode = hashlist_mode;
11037
11038 FILE *fp = fopen (hash_buf, "rb");
11039
11040 if (fp == NULL)
11041 {
11042 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11043
11044 return (-1);
11045 }
11046
11047 if (hashes_avail < 1)
11048 {
11049 log_error ("ERROR: hccap file is empty or corrupt");
11050
11051 fclose (fp);
11052
11053 return (-1);
11054 }
11055
11056 uint hccap_size = sizeof (hccap_t);
11057
11058 char *in = (char *) mymalloc (hccap_size);
11059
11060 while (!feof (fp))
11061 {
11062 int n = fread (in, hccap_size, 1, fp);
11063
11064 if (n != 1)
11065 {
11066 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11067
11068 break;
11069 }
11070
11071 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11072
11073 if (parser_status != PARSER_OK)
11074 {
11075 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11076
11077 continue;
11078 }
11079
11080 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11081
11082 if ((show == 1) || (left == 1))
11083 {
11084 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11085
11086 char *salt_ptr = (char *) tmp_salt->salt_buf;
11087
11088 int cur_pos = tmp_salt->salt_len;
11089 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11090
11091 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11092
11093 // do the appending task
11094
11095 snprintf (salt_ptr + cur_pos,
11096 rem_len,
11097 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11098 wpa->orig_mac1[0],
11099 wpa->orig_mac1[1],
11100 wpa->orig_mac1[2],
11101 wpa->orig_mac1[3],
11102 wpa->orig_mac1[4],
11103 wpa->orig_mac1[5],
11104 wpa->orig_mac2[0],
11105 wpa->orig_mac2[1],
11106 wpa->orig_mac2[2],
11107 wpa->orig_mac2[3],
11108 wpa->orig_mac2[4],
11109 wpa->orig_mac2[5]);
11110
11111 // memset () the remaining part of the salt
11112
11113 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11114 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11115
11116 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11117
11118 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11119 }
11120
11121 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);
11122 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);
11123
11124 hashes_cnt++;
11125 }
11126
11127 fclose (fp);
11128
11129 myfree (in);
11130 }
11131 else if (hash_mode == 3000)
11132 {
11133 if (hash_len == 32)
11134 {
11135 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11136
11137 hash_t *lm_hash_left = NULL;
11138
11139 if (parser_status == PARSER_OK)
11140 {
11141 lm_hash_left = &hashes_buf[hashes_cnt];
11142
11143 hashes_cnt++;
11144 }
11145 else
11146 {
11147 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11148 }
11149
11150 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11151
11152 hash_t *lm_hash_right = NULL;
11153
11154 if (parser_status == PARSER_OK)
11155 {
11156 lm_hash_right = &hashes_buf[hashes_cnt];
11157
11158 hashes_cnt++;
11159 }
11160 else
11161 {
11162 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11163 }
11164
11165 // show / left
11166
11167 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11168 {
11169 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);
11170 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);
11171 }
11172 }
11173 else
11174 {
11175 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11176
11177 if (parser_status == PARSER_OK)
11178 {
11179 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11180 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11181 }
11182
11183 if (parser_status == PARSER_OK)
11184 {
11185 hashes_cnt++;
11186 }
11187 else
11188 {
11189 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11190 }
11191 }
11192 }
11193 else
11194 {
11195 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11196
11197 if (parser_status == PARSER_OK)
11198 {
11199 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11200 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11201 }
11202
11203 if (parser_status == PARSER_OK)
11204 {
11205 hashes_cnt++;
11206 }
11207 else
11208 {
11209 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11210 }
11211 }
11212 }
11213 }
11214 else if (hashlist_mode == HL_MODE_FILE)
11215 {
11216 char *hashfile = data.hashfile;
11217
11218 FILE *fp;
11219
11220 if ((fp = fopen (hashfile, "rb")) == NULL)
11221 {
11222 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11223
11224 return (-1);
11225 }
11226
11227 uint line_num = 0;
11228
11229 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11230
11231 while (!feof (fp))
11232 {
11233 line_num++;
11234
11235 int line_len = fgetl (fp, line_buf);
11236
11237 if (line_len == 0) continue;
11238
11239 char *hash_buf = NULL;
11240 int hash_len = 0;
11241
11242 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11243
11244 bool hash_fmt_error = 0;
11245
11246 if (hash_len < 1) hash_fmt_error = 1;
11247 if (hash_buf == NULL) hash_fmt_error = 1;
11248
11249 if (hash_fmt_error)
11250 {
11251 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11252
11253 continue;
11254 }
11255
11256 if (username)
11257 {
11258 char *user_buf = NULL;
11259 int user_len = 0;
11260
11261 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11262
11263 if (remove || show)
11264 {
11265 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11266
11267 *user = (user_t *) mymalloc (sizeof (user_t));
11268
11269 user_t *user_ptr = *user;
11270
11271 if (user_buf != NULL)
11272 {
11273 user_ptr->user_name = mystrdup (user_buf);
11274 }
11275 else
11276 {
11277 user_ptr->user_name = mystrdup ("");
11278 }
11279
11280 user_ptr->user_len = user_len;
11281 }
11282 }
11283
11284 if (opts_type & OPTS_TYPE_HASH_COPY)
11285 {
11286 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11287
11288 hash_info_tmp->orighash = mystrdup (hash_buf);
11289 }
11290
11291 if (isSalted)
11292 {
11293 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11294 }
11295
11296 if (hash_mode == 3000)
11297 {
11298 if (hash_len == 32)
11299 {
11300 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11301
11302 if (parser_status < PARSER_GLOBAL_ZERO)
11303 {
11304 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11305
11306 continue;
11307 }
11308
11309 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11310
11311 hashes_cnt++;
11312
11313 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11314
11315 if (parser_status < PARSER_GLOBAL_ZERO)
11316 {
11317 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11318
11319 continue;
11320 }
11321
11322 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11323
11324 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);
11325
11326 hashes_cnt++;
11327
11328 // show / left
11329
11330 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);
11331 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);
11332 }
11333 else
11334 {
11335 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11336
11337 if (parser_status < PARSER_GLOBAL_ZERO)
11338 {
11339 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11340
11341 continue;
11342 }
11343
11344 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);
11345
11346 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11347 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11348
11349 hashes_cnt++;
11350 }
11351 }
11352 else
11353 {
11354 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11355
11356 if (parser_status < PARSER_GLOBAL_ZERO)
11357 {
11358 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11359
11360 continue;
11361 }
11362
11363 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);
11364
11365 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11366 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11367
11368 hashes_cnt++;
11369 }
11370 }
11371
11372 myfree (line_buf);
11373
11374 fclose (fp);
11375
11376 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11377
11378 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11379 }
11380 }
11381 else
11382 {
11383 if (isSalted)
11384 {
11385 hashes_buf[0].salt->salt_len = 8;
11386
11387 // special salt handling
11388
11389 switch (hash_mode)
11390 {
11391 case 1500: hashes_buf[0].salt->salt_len = 2;
11392 break;
11393 case 1731: hashes_buf[0].salt->salt_len = 4;
11394 break;
11395 case 2410: hashes_buf[0].salt->salt_len = 4;
11396 break;
11397 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11398 break;
11399 case 3100: hashes_buf[0].salt->salt_len = 1;
11400 break;
11401 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11402 break;
11403 case 5800: hashes_buf[0].salt->salt_len = 16;
11404 break;
11405 case 6800: hashes_buf[0].salt->salt_len = 32;
11406 break;
11407 case 8400: hashes_buf[0].salt->salt_len = 40;
11408 break;
11409 case 8800: hashes_buf[0].salt->salt_len = 16;
11410 break;
11411 case 8900: hashes_buf[0].salt->salt_len = 16;
11412 hashes_buf[0].salt->scrypt_N = 1024;
11413 hashes_buf[0].salt->scrypt_r = 1;
11414 hashes_buf[0].salt->scrypt_p = 1;
11415 break;
11416 case 9100: hashes_buf[0].salt->salt_len = 16;
11417 break;
11418 case 9300: hashes_buf[0].salt->salt_len = 14;
11419 hashes_buf[0].salt->scrypt_N = 16384;
11420 hashes_buf[0].salt->scrypt_r = 1;
11421 hashes_buf[0].salt->scrypt_p = 1;
11422 break;
11423 case 9400: hashes_buf[0].salt->salt_len = 16;
11424 break;
11425 case 9500: hashes_buf[0].salt->salt_len = 16;
11426 break;
11427 case 9600: hashes_buf[0].salt->salt_len = 16;
11428 break;
11429 case 9700: hashes_buf[0].salt->salt_len = 16;
11430 break;
11431 case 9710: hashes_buf[0].salt->salt_len = 16;
11432 break;
11433 case 9720: hashes_buf[0].salt->salt_len = 16;
11434 break;
11435 case 9800: hashes_buf[0].salt->salt_len = 16;
11436 break;
11437 case 9810: hashes_buf[0].salt->salt_len = 16;
11438 break;
11439 case 9820: hashes_buf[0].salt->salt_len = 16;
11440 break;
11441 case 10300: hashes_buf[0].salt->salt_len = 12;
11442 break;
11443 case 11500: hashes_buf[0].salt->salt_len = 4;
11444 break;
11445 case 11600: hashes_buf[0].salt->salt_len = 4;
11446 break;
11447 case 12400: hashes_buf[0].salt->salt_len = 4;
11448 break;
11449 case 12500: hashes_buf[0].salt->salt_len = 8;
11450 break;
11451 case 12600: hashes_buf[0].salt->salt_len = 64;
11452 break;
11453 }
11454
11455 // special esalt handling
11456
11457 switch (hash_mode)
11458 {
11459 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11460 break;
11461 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11462 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11463 break;
11464 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11465 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11466 break;
11467 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11468 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11469 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11470 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11471 break;
11472 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11473 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11474 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11475 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11476 break;
11477 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11478 break;
11479 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11480 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11481 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11482 break;
11483 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11484 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11485 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11486 break;
11487 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11488 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11489 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11490 break;
11491 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11492 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11493 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11494 break;
11495 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11496 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11497 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11498 break;
11499 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11500 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11501 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11502 break;
11503 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11504 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11505 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11506 break;
11507 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11508 break;
11509 }
11510 }
11511
11512 // set hashfile
11513
11514 switch (hash_mode)
11515 {
11516 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11517 break;
11518 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11519 break;
11520 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11521 break;
11522 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11523 break;
11524 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11525 break;
11526 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11527 break;
11528 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11529 break;
11530 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11531 break;
11532 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11533 break;
11534 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11535 break;
11536 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11537 break;
11538 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11539 break;
11540 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11541 break;
11542 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11543 break;
11544 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11545 break;
11546 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11547 break;
11548 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11549 break;
11550 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11551 break;
11552 }
11553
11554 // set default iterations
11555
11556 switch (hash_mode)
11557 {
11558 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11559 break;
11560 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11561 break;
11562 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11563 break;
11564 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11565 break;
11566 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11567 break;
11568 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11569 break;
11570 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11571 break;
11572 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11573 break;
11574 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11575 break;
11576 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11577 break;
11578 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11579 break;
11580 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11581 break;
11582 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11583 break;
11584 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11585 break;
11586 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11587 break;
11588 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11589 break;
11590 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11591 break;
11592 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11593 break;
11594 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11595 break;
11596 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11597 break;
11598 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11599 break;
11600 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11601 break;
11602 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11603 break;
11604 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11605 break;
11606 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11607 break;
11608 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11609 break;
11610 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11611 break;
11612 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11613 break;
11614 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11615 break;
11616 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11617 break;
11618 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11619 break;
11620 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11621 break;
11622 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11623 break;
11624 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11625 break;
11626 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11627 break;
11628 case 8900: hashes_buf[0].salt->salt_iter = 1;
11629 break;
11630 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11631 break;
11632 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11633 break;
11634 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11635 break;
11636 case 9300: hashes_buf[0].salt->salt_iter = 1;
11637 break;
11638 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11639 break;
11640 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11641 break;
11642 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11643 break;
11644 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11645 break;
11646 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11647 break;
11648 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11649 break;
11650 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11651 break;
11652 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11653 break;
11654 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11655 break;
11656 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11657 break;
11658 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11659 break;
11660 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11661 break;
11662 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11663 break;
11664 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11665 break;
11666 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11667 break;
11668 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11669 break;
11670 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11671 break;
11672 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11673 break;
11674 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11675 break;
11676 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11677 break;
11678 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11679 break;
11680 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
11681 break;
11682 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
11683 break;
11684 }
11685
11686 hashes_cnt = 1;
11687 }
11688
11689 if (show == 1 || left == 1)
11690 {
11691 for (uint i = 0; i < pot_cnt; i++)
11692 {
11693 pot_t *pot_ptr = &pot[i];
11694
11695 hash_t *hashes_buf = &pot_ptr->hash;
11696
11697 local_free (hashes_buf->digest);
11698
11699 if (isSalted)
11700 {
11701 local_free (hashes_buf->salt);
11702 }
11703 }
11704
11705 local_free (pot);
11706
11707 if (data.quiet == 0) log_info_nn ("");
11708
11709 return (0);
11710 }
11711
11712 if (keyspace == 0)
11713 {
11714 if (hashes_cnt == 0)
11715 {
11716 log_error ("ERROR: No hashes loaded");
11717
11718 return (-1);
11719 }
11720 }
11721
11722 /**
11723 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11724 */
11725
11726 if (data.outfile != NULL)
11727 {
11728 if (data.hashfile != NULL)
11729 {
11730 #ifdef _POSIX
11731 struct stat tmpstat_outfile;
11732 struct stat tmpstat_hashfile;
11733 #endif
11734
11735 #ifdef _WIN
11736 struct stat64 tmpstat_outfile;
11737 struct stat64 tmpstat_hashfile;
11738 #endif
11739
11740 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11741
11742 if (tmp_outfile_fp)
11743 {
11744 #ifdef _POSIX
11745 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11746 #endif
11747
11748 #ifdef _WIN
11749 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11750 #endif
11751
11752 fclose (tmp_outfile_fp);
11753 }
11754
11755 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11756
11757 if (tmp_hashfile_fp)
11758 {
11759 #ifdef _POSIX
11760 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11761 #endif
11762
11763 #ifdef _WIN
11764 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11765 #endif
11766
11767 fclose (tmp_hashfile_fp);
11768 }
11769
11770 if (tmp_outfile_fp && tmp_outfile_fp)
11771 {
11772 tmpstat_outfile.st_mode = 0;
11773 tmpstat_outfile.st_nlink = 0;
11774 tmpstat_outfile.st_uid = 0;
11775 tmpstat_outfile.st_gid = 0;
11776 tmpstat_outfile.st_rdev = 0;
11777 tmpstat_outfile.st_atime = 0;
11778
11779 tmpstat_hashfile.st_mode = 0;
11780 tmpstat_hashfile.st_nlink = 0;
11781 tmpstat_hashfile.st_uid = 0;
11782 tmpstat_hashfile.st_gid = 0;
11783 tmpstat_hashfile.st_rdev = 0;
11784 tmpstat_hashfile.st_atime = 0;
11785
11786 #ifdef _POSIX
11787 tmpstat_outfile.st_blksize = 0;
11788 tmpstat_outfile.st_blocks = 0;
11789
11790 tmpstat_hashfile.st_blksize = 0;
11791 tmpstat_hashfile.st_blocks = 0;
11792 #endif
11793
11794 #ifdef _POSIX
11795 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11796 {
11797 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11798
11799 return (-1);
11800 }
11801 #endif
11802
11803 #ifdef _WIN
11804 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11805 {
11806 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11807
11808 return (-1);
11809 }
11810 #endif
11811 }
11812 }
11813 }
11814
11815 /**
11816 * Remove duplicates
11817 */
11818
11819 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11820
11821 if (isSalted)
11822 {
11823 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11824 }
11825 else
11826 {
11827 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11828 }
11829
11830 uint hashes_cnt_orig = hashes_cnt;
11831
11832 hashes_cnt = 1;
11833
11834 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11835 {
11836 if (isSalted)
11837 {
11838 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11839 {
11840 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11841 }
11842 }
11843 else
11844 {
11845 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11846 }
11847
11848 if (hashes_pos > hashes_cnt)
11849 {
11850 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11851 }
11852
11853 hashes_cnt++;
11854 }
11855
11856 /**
11857 * Potfile removes
11858 */
11859
11860 uint potfile_remove_cracks = 0;
11861
11862 if (potfile_disable == 0)
11863 {
11864 hash_t hash_buf;
11865
11866 hash_buf.digest = mymalloc (dgst_size);
11867 hash_buf.salt = NULL;
11868 hash_buf.esalt = NULL;
11869 hash_buf.hash_info = NULL;
11870 hash_buf.cracked = 0;
11871
11872 if (isSalted)
11873 {
11874 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11875 }
11876
11877 if (esalt_size)
11878 {
11879 hash_buf.esalt = mymalloc (esalt_size);
11880 }
11881
11882 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11883
11884 // no solution for these special hash types (for instane because they use hashfile in output etc)
11885 if ((hash_mode != 5200) &&
11886 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11887 (hash_mode != 9000))
11888 {
11889 FILE *fp = fopen (potfile, "rb");
11890
11891 if (fp != NULL)
11892 {
11893 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11894
11895 // to be safe work with a copy (because of line_len loop, i etc)
11896 // moved up here because it's easier to handle continue case
11897 // it's just 64kb
11898
11899 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
11900
11901 while (!feof (fp))
11902 {
11903 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
11904
11905 if (ptr == NULL) break;
11906
11907 int line_len = strlen (line_buf);
11908
11909 if (line_len == 0) continue;
11910
11911 int iter = MAX_CUT_TRIES;
11912
11913 for (int i = line_len - 1; i && iter; i--, line_len--)
11914 {
11915 if (line_buf[i] != ':') continue;
11916
11917 if (isSalted)
11918 {
11919 memset (hash_buf.salt, 0, sizeof (salt_t));
11920 }
11921
11922 hash_t *found = NULL;
11923
11924 if (hash_mode == 6800)
11925 {
11926 if (i < 64) // 64 = 16 * uint in salt_buf[]
11927 {
11928 // manipulate salt_buf
11929 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11930
11931 hash_buf.salt->salt_len = i;
11932
11933 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11934 }
11935 }
11936 else if (hash_mode == 2500)
11937 {
11938 if (i < 64) // 64 = 16 * uint in salt_buf[]
11939 {
11940 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11941 // manipulate salt_buf
11942
11943 memcpy (line_buf_cpy, line_buf, i);
11944
11945 char *mac2_pos = strrchr (line_buf_cpy, ':');
11946
11947 if (mac2_pos == NULL) continue;
11948
11949 mac2_pos[0] = 0;
11950 mac2_pos++;
11951
11952 if (strlen (mac2_pos) != 12) continue;
11953
11954 char *mac1_pos = strrchr (line_buf_cpy, ':');
11955
11956 if (mac1_pos == NULL) continue;
11957
11958 mac1_pos[0] = 0;
11959 mac1_pos++;
11960
11961 if (strlen (mac1_pos) != 12) continue;
11962
11963 uint essid_length = mac1_pos - line_buf_cpy - 1;
11964
11965 // here we need the ESSID
11966 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11967
11968 hash_buf.salt->salt_len = essid_length;
11969
11970 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11971
11972 if (found)
11973 {
11974 wpa_t *wpa = (wpa_t *) found->esalt;
11975
11976 // compare hex string(s) vs binary MAC address(es)
11977
11978 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11979 {
11980 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11981 {
11982 found = NULL;
11983
11984 break;
11985 }
11986 }
11987
11988 // early skip ;)
11989 if (!found) continue;
11990
11991 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11992 {
11993 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11994 {
11995 found = NULL;
11996
11997 break;
11998 }
11999 }
12000 }
12001 }
12002 }
12003 else
12004 {
12005 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12006
12007 if (parser_status == PARSER_OK)
12008 {
12009 if (isSalted)
12010 {
12011 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12012 }
12013 else
12014 {
12015 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12016 }
12017 }
12018 }
12019
12020 if (found == NULL) continue;
12021
12022 if (!found->cracked) potfile_remove_cracks++;
12023
12024 found->cracked = 1;
12025
12026 if (found) break;
12027
12028 iter--;
12029 }
12030 }
12031
12032 myfree (line_buf_cpy);
12033
12034 myfree (line_buf);
12035
12036 fclose (fp);
12037 }
12038 }
12039
12040 if (esalt_size)
12041 {
12042 local_free (hash_buf.esalt);
12043 }
12044
12045 if (isSalted)
12046 {
12047 local_free (hash_buf.salt);
12048 }
12049
12050 local_free (hash_buf.digest);
12051 }
12052
12053 /**
12054 * Now generate all the buffers required for later
12055 */
12056
12057 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12058
12059 salt_t *salts_buf_new = NULL;
12060 void *esalts_buf_new = NULL;
12061
12062 if (isSalted)
12063 {
12064 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12065
12066 if (esalt_size)
12067 {
12068 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12069 }
12070 }
12071 else
12072 {
12073 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12074 }
12075
12076 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12077
12078 uint digests_cnt = hashes_cnt;
12079 uint digests_done = 0;
12080
12081 uint size_digests = digests_cnt * dgst_size;
12082 uint size_shown = digests_cnt * sizeof (uint);
12083
12084 uint *digests_shown = (uint *) mymalloc (size_shown);
12085 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12086
12087 uint salts_cnt = 0;
12088 uint salts_done = 0;
12089
12090 hashinfo_t **hash_info = NULL;
12091
12092 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12093 {
12094 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12095
12096 if (username && (remove || show))
12097 {
12098 uint user_pos;
12099
12100 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12101 {
12102 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12103
12104 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12105 }
12106 }
12107 }
12108
12109 uint *salts_shown = (uint *) mymalloc (size_shown);
12110
12111 salt_t *salt_buf;
12112
12113 {
12114 // copied from inner loop
12115
12116 salt_buf = &salts_buf_new[salts_cnt];
12117
12118 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12119
12120 if (esalt_size)
12121 {
12122 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12123 }
12124
12125 salt_buf->digests_cnt = 0;
12126 salt_buf->digests_done = 0;
12127 salt_buf->digests_offset = 0;
12128
12129 salts_cnt++;
12130 }
12131
12132 if (hashes_buf[0].cracked == 1)
12133 {
12134 digests_shown[0] = 1;
12135
12136 digests_done++;
12137
12138 salt_buf->digests_done++;
12139 }
12140
12141 salt_buf->digests_cnt++;
12142
12143 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12144
12145 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12146 {
12147 hash_info[0] = hashes_buf[0].hash_info;
12148 }
12149
12150 // copy from inner loop
12151
12152 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12153 {
12154 if (isSalted)
12155 {
12156 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12157 {
12158 salt_buf = &salts_buf_new[salts_cnt];
12159
12160 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12161
12162 if (esalt_size)
12163 {
12164 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12165 }
12166
12167 salt_buf->digests_cnt = 0;
12168 salt_buf->digests_done = 0;
12169 salt_buf->digests_offset = hashes_pos;
12170
12171 salts_cnt++;
12172 }
12173 }
12174
12175 if (hashes_buf[hashes_pos].cracked == 1)
12176 {
12177 digests_shown[hashes_pos] = 1;
12178
12179 digests_done++;
12180
12181 salt_buf->digests_done++;
12182 }
12183
12184 salt_buf->digests_cnt++;
12185
12186 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12187
12188 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12189 {
12190 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12191 }
12192 }
12193
12194 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12195 {
12196 salt_t *salt_buf = &salts_buf_new[salt_pos];
12197
12198 if (salt_buf->digests_done == salt_buf->digests_cnt)
12199 {
12200 salts_shown[salt_pos] = 1;
12201
12202 salts_done++;
12203 }
12204
12205 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12206 }
12207
12208 local_free (digests_buf);
12209 local_free (salts_buf);
12210 local_free (esalts_buf);
12211
12212 digests_buf = digests_buf_new;
12213 salts_buf = salts_buf_new;
12214 esalts_buf = esalts_buf_new;
12215
12216 local_free (hashes_buf);
12217
12218 /**
12219 * special modification not set from parser
12220 */
12221
12222 switch (hash_mode)
12223 {
12224 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12225 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12226 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12227 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12228 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12229 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12230 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12231 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12232 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12233 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12234 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12235 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12236 }
12237
12238 if (truecrypt_keyfiles)
12239 {
12240 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12241
12242 char *keyfiles = strdup (truecrypt_keyfiles);
12243
12244 char *keyfile = strtok (keyfiles, ",");
12245
12246 do
12247 {
12248 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12249
12250 } while ((keyfile = strtok (NULL, ",")) != NULL);
12251
12252 free (keyfiles);
12253 }
12254
12255 data.digests_cnt = digests_cnt;
12256 data.digests_done = digests_done;
12257 data.digests_buf = digests_buf;
12258 data.digests_shown = digests_shown;
12259 data.digests_shown_tmp = digests_shown_tmp;
12260
12261 data.salts_cnt = salts_cnt;
12262 data.salts_done = salts_done;
12263 data.salts_buf = salts_buf;
12264 data.salts_shown = salts_shown;
12265
12266 data.esalts_buf = esalts_buf;
12267 data.hash_info = hash_info;
12268
12269 /**
12270 * Automatic Optimizers
12271 */
12272
12273 if (salts_cnt == 1)
12274 opti_type |= OPTI_TYPE_SINGLE_SALT;
12275
12276 if (digests_cnt == 1)
12277 opti_type |= OPTI_TYPE_SINGLE_HASH;
12278
12279 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12280 opti_type |= OPTI_TYPE_NOT_ITERATED;
12281
12282 if (attack_mode == ATTACK_MODE_BF)
12283 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12284
12285 data.opti_type = opti_type;
12286
12287 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12288 {
12289 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12290 {
12291 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12292 {
12293 if (opts_type & OPTS_TYPE_ST_ADD80)
12294 {
12295 opts_type &= ~OPTS_TYPE_ST_ADD80;
12296 opts_type |= OPTS_TYPE_PT_ADD80;
12297 }
12298
12299 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12300 {
12301 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12302 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12303 }
12304
12305 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12306 {
12307 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12308 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12309 }
12310 }
12311 }
12312 }
12313
12314 /**
12315 * Some algorithm, like descrypt, can benefit from JIT compilation
12316 */
12317
12318 int force_jit_compilation = -1;
12319
12320 if (hash_mode == 8900)
12321 {
12322 force_jit_compilation = 8900;
12323 }
12324 else if (hash_mode == 9300)
12325 {
12326 force_jit_compilation = 8900;
12327 }
12328 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12329 {
12330 force_jit_compilation = 1500;
12331 }
12332
12333 /**
12334 * generate bitmap tables
12335 */
12336
12337 const uint bitmap_shift1 = 5;
12338 const uint bitmap_shift2 = 13;
12339
12340 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12341
12342 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12343 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12344 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12345 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12346 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12347 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12348 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12349 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12350
12351 uint bitmap_bits;
12352 uint bitmap_nums;
12353 uint bitmap_mask;
12354 uint bitmap_size;
12355
12356 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12357 {
12358 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12359
12360 bitmap_nums = 1 << bitmap_bits;
12361
12362 bitmap_mask = bitmap_nums - 1;
12363
12364 bitmap_size = bitmap_nums * sizeof (uint);
12365
12366 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12367
12368 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;
12369 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;
12370
12371 break;
12372 }
12373
12374 bitmap_nums = 1 << bitmap_bits;
12375
12376 bitmap_mask = bitmap_nums - 1;
12377
12378 bitmap_size = bitmap_nums * sizeof (uint);
12379
12380 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);
12381 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);
12382
12383 /**
12384 * prepare quick rule
12385 */
12386
12387 data.rule_buf_l = rule_buf_l;
12388 data.rule_buf_r = rule_buf_r;
12389
12390 int rule_len_l = (int) strlen (rule_buf_l);
12391 int rule_len_r = (int) strlen (rule_buf_r);
12392
12393 data.rule_len_l = rule_len_l;
12394 data.rule_len_r = rule_len_r;
12395
12396 /**
12397 * load rules
12398 */
12399
12400 uint *all_kernel_rules_cnt = NULL;
12401
12402 kernel_rule_t **all_kernel_rules_buf = NULL;
12403
12404 if (rp_files_cnt)
12405 {
12406 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12407
12408 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12409 }
12410
12411 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12412
12413 int rule_len = 0;
12414
12415 for (uint i = 0; i < rp_files_cnt; i++)
12416 {
12417 uint kernel_rules_avail = 0;
12418
12419 uint kernel_rules_cnt = 0;
12420
12421 kernel_rule_t *kernel_rules_buf = NULL;
12422
12423 char *rp_file = rp_files[i];
12424
12425 char in[BLOCK_SIZE] = { 0 };
12426 char out[BLOCK_SIZE] = { 0 };
12427
12428 FILE *fp = NULL;
12429
12430 uint rule_line = 0;
12431
12432 if ((fp = fopen (rp_file, "rb")) == NULL)
12433 {
12434 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12435
12436 return (-1);
12437 }
12438
12439 while (!feof (fp))
12440 {
12441 memset (rule_buf, 0, HCBUFSIZ);
12442
12443 rule_len = fgetl (fp, rule_buf);
12444
12445 rule_line++;
12446
12447 if (rule_len == 0) continue;
12448
12449 if (rule_buf[0] == '#') continue;
12450
12451 if (kernel_rules_avail == kernel_rules_cnt)
12452 {
12453 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12454
12455 kernel_rules_avail += INCR_RULES;
12456 }
12457
12458 memset (in, 0, BLOCK_SIZE);
12459 memset (out, 0, BLOCK_SIZE);
12460
12461 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12462
12463 if (result == -1)
12464 {
12465 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12466
12467 continue;
12468 }
12469
12470 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12471 {
12472 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12473
12474 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12475
12476 continue;
12477 }
12478
12479 /* its so slow
12480 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12481 {
12482 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12483
12484 continue;
12485 }
12486 */
12487
12488 kernel_rules_cnt++;
12489 }
12490
12491 fclose (fp);
12492
12493 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12494
12495 all_kernel_rules_buf[i] = kernel_rules_buf;
12496 }
12497
12498 /**
12499 * merge rules or automatic rule generator
12500 */
12501
12502 uint kernel_rules_cnt = 0;
12503
12504 kernel_rule_t *kernel_rules_buf = NULL;
12505
12506 if (attack_mode == ATTACK_MODE_STRAIGHT)
12507 {
12508 if (rp_files_cnt)
12509 {
12510 kernel_rules_cnt = 1;
12511
12512 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12513
12514 repeats[0] = kernel_rules_cnt;
12515
12516 for (uint i = 0; i < rp_files_cnt; i++)
12517 {
12518 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12519
12520 repeats[i + 1] = kernel_rules_cnt;
12521 }
12522
12523 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12524
12525 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12526
12527 for (uint i = 0; i < kernel_rules_cnt; i++)
12528 {
12529 uint out_pos = 0;
12530
12531 kernel_rule_t *out = &kernel_rules_buf[i];
12532
12533 for (uint j = 0; j < rp_files_cnt; j++)
12534 {
12535 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12536 uint in_pos;
12537
12538 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12539
12540 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12541 {
12542 if (out_pos == RULES_MAX - 1)
12543 {
12544 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12545
12546 break;
12547 }
12548
12549 out->cmds[out_pos] = in->cmds[in_pos];
12550 }
12551 }
12552 }
12553
12554 local_free (repeats);
12555 }
12556 else if (rp_gen)
12557 {
12558 uint kernel_rules_avail = 0;
12559
12560 while (kernel_rules_cnt < rp_gen)
12561 {
12562 if (kernel_rules_avail == kernel_rules_cnt)
12563 {
12564 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12565
12566 kernel_rules_avail += INCR_RULES;
12567 }
12568
12569 memset (rule_buf, 0, HCBUFSIZ);
12570
12571 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12572
12573 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12574
12575 kernel_rules_cnt++;
12576 }
12577 }
12578 }
12579
12580 myfree (rule_buf);
12581
12582 /**
12583 * generate NOP rules
12584 */
12585
12586 if (kernel_rules_cnt == 0)
12587 {
12588 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12589
12590 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12591
12592 kernel_rules_cnt++;
12593 }
12594
12595 data.kernel_rules_cnt = kernel_rules_cnt;
12596 data.kernel_rules_buf = kernel_rules_buf;
12597
12598 /**
12599 * OpenCL platforms: detect
12600 */
12601
12602 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12603 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12604
12605 cl_uint platforms_cnt = 0;
12606 cl_uint platform_devices_cnt = 0;
12607
12608 if (keyspace == 0)
12609 {
12610 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12611
12612 if (platforms_cnt == 0)
12613 {
12614 log_error ("ERROR: No OpenCL compatible platform found");
12615
12616 return (-1);
12617 }
12618
12619 if (opencl_platforms_filter != (uint) -1)
12620 {
12621 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
12622
12623 if (opencl_platforms_filter > platform_cnt_mask)
12624 {
12625 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
12626
12627 return (-1);
12628 }
12629 }
12630 }
12631
12632 /**
12633 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12634 */
12635
12636 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12637 {
12638 cl_platform_id platform = platforms[platform_id];
12639
12640 char platform_vendor[INFOSZ] = { 0 };
12641
12642 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12643
12644 #ifdef HAVE_HWMON
12645 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12646 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12647 {
12648 // make sure that we do not directly control the fan for NVidia
12649
12650 gpu_temp_retain = 0;
12651
12652 data.gpu_temp_retain = gpu_temp_retain;
12653 }
12654 #endif // HAVE_NVML || HAVE_NVAPI
12655 #endif
12656 }
12657
12658 /**
12659 * OpenCL devices: simply push all devices from all platforms into the same device array
12660 */
12661
12662 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12663
12664 data.devices_param = devices_param;
12665
12666 uint devices_cnt = 0;
12667
12668 uint devices_active = 0;
12669
12670 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12671 {
12672 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12673
12674 cl_platform_id platform = platforms[platform_id];
12675
12676 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12677
12678 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12679 {
12680 size_t param_value_size = 0;
12681
12682 const uint device_id = devices_cnt;
12683
12684 hc_device_param_t *device_param = &data.devices_param[device_id];
12685
12686 device_param->device = platform_devices[platform_devices_id];
12687
12688 device_param->device_id = device_id;
12689
12690 device_param->platform_devices_id = platform_devices_id;
12691
12692 // device_type
12693
12694 cl_device_type device_type;
12695
12696 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12697
12698 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12699
12700 device_param->device_type = device_type;
12701
12702 // vendor_id
12703
12704 cl_uint vendor_id = 0;
12705
12706 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12707
12708 device_param->vendor_id = vendor_id;
12709
12710 // device_name
12711
12712 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12713
12714 char *device_name = (char *) mymalloc (param_value_size);
12715
12716 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12717
12718 device_param->device_name = device_name;
12719
12720 // tuning db
12721
12722 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12723
12724 // device_version
12725
12726 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12727
12728 char *device_version = (char *) mymalloc (param_value_size);
12729
12730 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12731
12732 device_param->device_version = device_version;
12733
12734 // device_opencl_version
12735
12736 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12737
12738 char *device_opencl_version = (char *) mymalloc (param_value_size);
12739
12740 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12741
12742 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12743
12744 myfree (device_opencl_version);
12745
12746 if (strstr (device_version, "pocl"))
12747 {
12748 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12749 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12750
12751 cl_uint vendor_id = VENDOR_ID_GENERIC;
12752
12753 device_param->vendor_id = vendor_id;
12754 }
12755
12756 // vector_width
12757
12758 cl_uint vector_width;
12759
12760 if (opencl_vector_width_chgd == 0)
12761 {
12762 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12763 {
12764 if (opti_type & OPTI_TYPE_USES_BITS_64)
12765 {
12766 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12767 }
12768 else
12769 {
12770 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12771 }
12772 }
12773 else
12774 {
12775 vector_width = (cl_uint) tuningdb_entry->vector_width;
12776 }
12777 }
12778 else
12779 {
12780 vector_width = opencl_vector_width;
12781 }
12782
12783 if (vector_width > 16) vector_width = 16;
12784
12785 device_param->vector_width = vector_width;
12786
12787 // max_compute_units
12788
12789 cl_uint device_processors;
12790
12791 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12792
12793 device_param->device_processors = device_processors;
12794
12795 // max_mem_alloc_size
12796
12797 cl_ulong device_maxmem_alloc;
12798
12799 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12800
12801 device_param->device_maxmem_alloc = device_maxmem_alloc;
12802
12803 // max_mem_alloc_size
12804
12805 cl_ulong device_global_mem;
12806
12807 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12808
12809 device_param->device_global_mem = device_global_mem;
12810
12811 // max_clock_frequency
12812
12813 cl_uint device_maxclock_frequency;
12814
12815 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12816
12817 device_param->device_maxclock_frequency = device_maxclock_frequency;
12818
12819 // skipped
12820
12821 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12822 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12823
12824 device_param->skipped = (skipped1 || skipped2);
12825
12826 // driver_version
12827 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12828
12829 char *driver_version = (char *) mymalloc (param_value_size);
12830
12831 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12832
12833 device_param->driver_version = driver_version;
12834
12835 // device_name_chksum
12836
12837 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12838
12839 #if __x86_64__
12840 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);
12841 #else
12842 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);
12843 #endif
12844
12845 uint device_name_digest[4] = { 0 };
12846
12847 md5_64 ((uint *) device_name_chksum, device_name_digest);
12848
12849 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12850
12851 device_param->device_name_chksum = device_name_chksum;
12852
12853 // device_processor_cores
12854
12855 if (device_type & CL_DEVICE_TYPE_CPU)
12856 {
12857 cl_uint device_processor_cores = 1;
12858
12859 device_param->device_processor_cores = device_processor_cores;
12860 }
12861
12862 if (device_type & CL_DEVICE_TYPE_GPU)
12863 {
12864 if (vendor_id == VENDOR_ID_AMD)
12865 {
12866 cl_uint device_processor_cores = 0;
12867
12868 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12869
12870 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12871
12872 device_param->device_processor_cores = device_processor_cores;
12873 }
12874 else if (vendor_id == VENDOR_ID_NV)
12875 {
12876 cl_uint kernel_exec_timeout = 0;
12877
12878 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12879
12880 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12881
12882 device_param->kernel_exec_timeout = kernel_exec_timeout;
12883
12884 cl_uint device_processor_cores = 0;
12885
12886 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12887
12888 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12889
12890 device_param->device_processor_cores = device_processor_cores;
12891
12892 cl_uint sm_minor = 0;
12893 cl_uint sm_major = 0;
12894
12895 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12896 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12897
12898 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12899 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12900
12901 device_param->sm_minor = sm_minor;
12902 device_param->sm_major = sm_major;
12903 }
12904 else
12905 {
12906 cl_uint device_processor_cores = 1;
12907
12908 device_param->device_processor_cores = device_processor_cores;
12909 }
12910 }
12911
12912 // display results
12913
12914 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12915 {
12916 if (device_param->skipped == 0)
12917 {
12918 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12919 device_id + 1,
12920 device_name,
12921 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12922 (unsigned int) (device_global_mem / 1024 / 1024),
12923 (unsigned int) (device_maxclock_frequency),
12924 (unsigned int) device_processors);
12925 }
12926 else
12927 {
12928 log_info ("Device #%u: %s, skipped",
12929 device_id + 1,
12930 device_name);
12931 }
12932 }
12933
12934 // common driver check
12935
12936 if (device_param->skipped == 0)
12937 {
12938 if (strstr (device_version, "pocl"))
12939 {
12940 if (force == 0)
12941 {
12942 log_info ("");
12943 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12944 log_info ("You are STRONGLY encouraged not to use it");
12945 log_info ("You can use --force to override this but do not post error reports if you do so");
12946 log_info ("");
12947
12948 return (-1);
12949 }
12950 }
12951
12952 if (device_type & CL_DEVICE_TYPE_GPU)
12953 {
12954 if (vendor_id == VENDOR_ID_NV)
12955 {
12956 if (device_param->kernel_exec_timeout != 0)
12957 {
12958 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);
12959 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12960 }
12961 }
12962 else if (vendor_id == VENDOR_ID_AMD)
12963 {
12964 int catalyst_check = (force == 1) ? 0 : 1;
12965
12966 int catalyst_warn = 0;
12967
12968 int catalyst_broken = 0;
12969
12970 if (catalyst_check == 1)
12971 {
12972 catalyst_warn = 1;
12973
12974 // v14.9 and higher
12975 if (atoi (device_param->driver_version) >= 1573)
12976 {
12977 catalyst_warn = 0;
12978 }
12979
12980 catalyst_check = 0;
12981 }
12982
12983 if (catalyst_broken == 1)
12984 {
12985 log_info ("");
12986 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12987 log_info ("It will pass over cracked hashes and does not report them as cracked");
12988 log_info ("You are STRONGLY encouraged not to use it");
12989 log_info ("You can use --force to override this but do not post error reports if you do so");
12990 log_info ("");
12991
12992 return (-1);
12993 }
12994
12995 if (catalyst_warn == 1)
12996 {
12997 log_info ("");
12998 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12999 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13000 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
13001 #ifdef _WIN
13002 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13003 #endif
13004 log_info ("You can use --force to override this but do not post error reports if you do so");
13005 log_info ("");
13006
13007 return (-1);
13008 }
13009 }
13010 }
13011
13012 /**
13013 * kernel accel and loops tuning db adjustment
13014 */
13015
13016 device_param->kernel_accel_min = 1;
13017 device_param->kernel_accel_max = 1024;
13018
13019 device_param->kernel_loops_min = 1;
13020 device_param->kernel_loops_max = 1024;
13021
13022 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13023
13024 if (tuningdb_entry)
13025 {
13026 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13027 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13028
13029 if (_kernel_accel)
13030 {
13031 device_param->kernel_accel_min = _kernel_accel;
13032 device_param->kernel_accel_max = _kernel_accel;
13033 }
13034
13035 if (_kernel_loops)
13036 {
13037 if (workload_profile == 1)
13038 {
13039 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13040 }
13041 else if (workload_profile == 2)
13042 {
13043 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13044 }
13045
13046 device_param->kernel_loops_min = _kernel_loops;
13047 device_param->kernel_loops_max = _kernel_loops;
13048 }
13049 }
13050
13051 // commandline parameters overwrite tuningdb entries
13052
13053 if (kernel_accel)
13054 {
13055 device_param->kernel_accel_min = kernel_accel;
13056 device_param->kernel_accel_max = kernel_accel;
13057 }
13058
13059 if (kernel_loops)
13060 {
13061 device_param->kernel_loops_min = kernel_loops;
13062 device_param->kernel_loops_max = kernel_loops;
13063 }
13064
13065 /**
13066 * activate device
13067 */
13068
13069 devices_active++;
13070 }
13071
13072 // next please
13073
13074 devices_cnt++;
13075 }
13076 }
13077
13078 if (keyspace == 0 && devices_active == 0)
13079 {
13080 log_error ("ERROR: No devices found/left");
13081
13082 return (-1);
13083 }
13084
13085 // 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)
13086
13087 if (devices_filter != (uint) -1)
13088 {
13089 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13090
13091 if (devices_filter > devices_cnt_mask)
13092 {
13093 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13094
13095 return (-1);
13096 }
13097 }
13098
13099 data.devices_cnt = devices_cnt;
13100
13101 data.devices_active = devices_active;
13102
13103 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13104 {
13105 log_info ("");
13106 }
13107
13108 /**
13109 * HM devices: init
13110 */
13111
13112 #ifdef HAVE_HWMON
13113 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13114 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13115 #endif
13116
13117 #ifdef HAVE_ADL
13118 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13119 #endif
13120
13121 if (gpu_temp_disable == 0)
13122 {
13123 #if defined(WIN) && defined(HAVE_NVAPI)
13124 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13125
13126 if (nvapi_init (nvapi) == 0)
13127 data.hm_nv = nvapi;
13128
13129 if (data.hm_nv)
13130 {
13131 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13132 {
13133 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13134
13135 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13136
13137 int tmp_out = 0;
13138
13139 for (int i = 0; i < tmp_in; i++)
13140 {
13141 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13142 }
13143
13144 for (int i = 0; i < tmp_out; i++)
13145 {
13146 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13147
13148 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13149
13150 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;
13151 }
13152 }
13153 }
13154 #endif // WIN && HAVE_NVAPI
13155
13156 #if defined(LINUX) && defined(HAVE_NVML)
13157 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13158
13159 if (nvml_init (nvml) == 0)
13160 data.hm_nv = nvml;
13161
13162 if (data.hm_nv)
13163 {
13164 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13165 {
13166 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13167
13168 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13169
13170 int tmp_out = 0;
13171
13172 for (int i = 0; i < tmp_in; i++)
13173 {
13174 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13175 }
13176
13177 for (int i = 0; i < tmp_out; i++)
13178 {
13179 unsigned int speed;
13180
13181 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;
13182 }
13183 }
13184 }
13185 #endif // LINUX && HAVE_NVML
13186
13187 data.hm_amd = NULL;
13188
13189 #ifdef HAVE_ADL
13190 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13191
13192 if (adl_init (adl) == 0)
13193 data.hm_amd = adl;
13194
13195 if (data.hm_amd)
13196 {
13197 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13198 {
13199 // total number of adapters
13200
13201 int hm_adapters_num;
13202
13203 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13204
13205 // adapter info
13206
13207 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13208
13209 if (lpAdapterInfo == NULL) return (-1);
13210
13211 // get a list (of ids of) valid/usable adapters
13212
13213 int num_adl_adapters = 0;
13214
13215 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13216
13217 if (num_adl_adapters > 0)
13218 {
13219 hc_thread_mutex_lock (mux_adl);
13220
13221 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13222
13223 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13224
13225 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13226 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13227
13228 hc_thread_mutex_unlock (mux_adl);
13229 }
13230
13231 myfree (valid_adl_device_list);
13232 myfree (lpAdapterInfo);
13233 }
13234 }
13235 #endif // HAVE_ADL
13236
13237 if (data.hm_amd == NULL && data.hm_nv == NULL)
13238 {
13239 gpu_temp_disable = 1;
13240 }
13241 }
13242
13243 /**
13244 * OpenCL devices: allocate buffer for device specific information
13245 */
13246
13247 #ifdef HAVE_HWMON
13248 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13249
13250 #ifdef HAVE_ADL
13251 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13252
13253 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13254 #endif // ADL
13255 #endif
13256
13257 /**
13258 * enable custom signal handler(s)
13259 */
13260
13261 if (benchmark == 0)
13262 {
13263 hc_signal (sigHandler_default);
13264 }
13265 else
13266 {
13267 hc_signal (sigHandler_benchmark);
13268 }
13269
13270 /**
13271 * User-defined GPU temp handling
13272 */
13273
13274 #ifdef HAVE_HWMON
13275 if (gpu_temp_disable == 1)
13276 {
13277 gpu_temp_abort = 0;
13278 gpu_temp_retain = 0;
13279 }
13280
13281 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13282 {
13283 if (gpu_temp_abort < gpu_temp_retain)
13284 {
13285 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13286
13287 return (-1);
13288 }
13289 }
13290
13291 data.gpu_temp_disable = gpu_temp_disable;
13292 data.gpu_temp_abort = gpu_temp_abort;
13293 data.gpu_temp_retain = gpu_temp_retain;
13294 #endif
13295
13296 /**
13297 * inform the user
13298 */
13299
13300 if (data.quiet == 0)
13301 {
13302 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13303
13304 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);
13305
13306 if (attack_mode == ATTACK_MODE_STRAIGHT)
13307 {
13308 log_info ("Rules: %u", kernel_rules_cnt);
13309 }
13310
13311 if (opti_type)
13312 {
13313 log_info ("Applicable Optimizers:");
13314
13315 for (uint i = 0; i < 32; i++)
13316 {
13317 const uint opti_bit = 1u << i;
13318
13319 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13320 }
13321 }
13322
13323 /**
13324 * Watchdog and Temperature balance
13325 */
13326
13327 #ifdef HAVE_HWMON
13328 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13329 {
13330 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13331 }
13332
13333 if (gpu_temp_abort == 0)
13334 {
13335 log_info ("Watchdog: Temperature abort trigger disabled");
13336 }
13337 else
13338 {
13339 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13340 }
13341
13342 if (gpu_temp_retain == 0)
13343 {
13344 log_info ("Watchdog: Temperature retain trigger disabled");
13345 }
13346 else
13347 {
13348 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13349 }
13350 #endif
13351 }
13352
13353 if (data.quiet == 0) log_info ("");
13354
13355 /**
13356 * HM devices: copy
13357 */
13358
13359 if (gpu_temp_disable == 0)
13360 {
13361 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13362 {
13363 hc_device_param_t *device_param = &data.devices_param[device_id];
13364
13365 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13366
13367 if (device_param->skipped) continue;
13368
13369 const uint platform_devices_id = device_param->platform_devices_id;
13370
13371 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13372 if (device_param->vendor_id == VENDOR_ID_NV)
13373 {
13374 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13375 }
13376 #endif
13377
13378 #ifdef HAVE_ADL
13379 if (device_param->vendor_id == VENDOR_ID_AMD)
13380 {
13381 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13382 }
13383 #endif
13384 }
13385 }
13386
13387 /*
13388 * Temporary fix:
13389 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13390 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13391 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13392 * Driver / ADL bug?
13393 */
13394
13395 #ifdef HAVE_ADL
13396 if (powertune_enable == 1)
13397 {
13398 hc_thread_mutex_lock (mux_adl);
13399
13400 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13401 {
13402 hc_device_param_t *device_param = &data.devices_param[device_id];
13403
13404 if (device_param->skipped) continue;
13405
13406 if (data.hm_device[device_id].od_version == 6)
13407 {
13408 // set powertune value only
13409
13410 int powertune_supported = 0;
13411
13412 int ADL_rc = 0;
13413
13414 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13415 {
13416 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13417
13418 return (-1);
13419 }
13420
13421 if (powertune_supported != 0)
13422 {
13423 // powertune set
13424 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13425
13426 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13427 {
13428 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13429
13430 return (-1);
13431 }
13432
13433 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13434 {
13435 log_error ("ERROR: Failed to set new ADL PowerControl values");
13436
13437 return (-1);
13438 }
13439 }
13440 }
13441 }
13442
13443 hc_thread_mutex_unlock (mux_adl);
13444 }
13445 #endif // HAVE_ADK
13446 #endif // HAVE_HWMON
13447
13448 #ifdef DEBUG
13449 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13450 #endif
13451
13452 uint kernel_power_all = 0;
13453
13454 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13455 {
13456 /**
13457 * host buffer
13458 */
13459
13460 hc_device_param_t *device_param = &data.devices_param[device_id];
13461
13462 if (device_param->skipped) continue;
13463
13464 /**
13465 * device properties
13466 */
13467
13468 const char *device_name_chksum = device_param->device_name_chksum;
13469 const u32 device_processors = device_param->device_processors;
13470 const u32 device_processor_cores = device_param->device_processor_cores;
13471
13472 /**
13473 * create context for each device
13474 */
13475
13476 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13477
13478 /**
13479 * create command-queue
13480 */
13481
13482 // not supported with NV
13483 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13484
13485 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13486
13487 /**
13488 * create input buffers on device : calculate size of fixed memory buffers
13489 */
13490
13491 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13492 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13493
13494 device_param->size_root_css = size_root_css;
13495 device_param->size_markov_css = size_markov_css;
13496
13497 uint size_results = KERNEL_THREADS * sizeof (uint);
13498
13499 device_param->size_results = size_results;
13500
13501 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13502 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13503
13504 uint size_plains = digests_cnt * sizeof (plain_t);
13505 uint size_salts = salts_cnt * sizeof (salt_t);
13506 uint size_esalts = salts_cnt * esalt_size;
13507
13508 device_param->size_plains = size_plains;
13509 device_param->size_digests = size_digests;
13510 device_param->size_shown = size_shown;
13511 device_param->size_salts = size_salts;
13512
13513 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13514 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13515 uint size_tm = 32 * sizeof (bs_word_t);
13516
13517 // scryptV stuff
13518
13519 u64 size_scryptV = 1;
13520
13521 if ((hash_mode == 8900) || (hash_mode == 9300))
13522 {
13523 uint tmto_start = 0;
13524 uint tmto_stop = 10;
13525
13526 if (scrypt_tmto)
13527 {
13528 tmto_start = scrypt_tmto;
13529 }
13530 else
13531 {
13532 // in case the user did not specify the tmto manually
13533 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13534 // but set the lower end only in case the user has a device with too less memory
13535
13536 if (hash_mode == 8900)
13537 {
13538 if (device_param->vendor_id == VENDOR_ID_AMD)
13539 {
13540 tmto_start = 1;
13541 }
13542 else if (device_param->vendor_id == VENDOR_ID_NV)
13543 {
13544 tmto_start = 3;
13545 }
13546 }
13547 else if (hash_mode == 9300)
13548 {
13549 if (device_param->vendor_id == VENDOR_ID_AMD)
13550 {
13551 tmto_start = 3;
13552 }
13553 else if (device_param->vendor_id == VENDOR_ID_NV)
13554 {
13555 tmto_start = 5;
13556 }
13557 }
13558 }
13559
13560 if (quiet == 0) log_info ("");
13561
13562 uint shader_per_mp = 1;
13563
13564 if (device_param->vendor_id == VENDOR_ID_AMD)
13565 {
13566 shader_per_mp = 8;
13567 }
13568 else if (device_param->vendor_id == VENDOR_ID_NV)
13569 {
13570 shader_per_mp = 32;
13571 }
13572
13573 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13574 {
13575 // TODO: in theory the following calculation needs to be done per salt, not global
13576 // we assume all hashes have the same scrypt settings
13577
13578 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13579
13580 size_scryptV /= 1 << tmto;
13581
13582 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13583
13584 if (size_scryptV > device_param->device_maxmem_alloc)
13585 {
13586 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13587
13588 continue;
13589 }
13590
13591 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13592 {
13593 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13594 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13595 }
13596
13597 break;
13598 }
13599
13600 if (data.salts_buf[0].scrypt_phy == 0)
13601 {
13602 log_error ("ERROR: can't allocate enough device memory");
13603
13604 return -1;
13605 }
13606
13607 if (quiet == 0) log_info ("");
13608 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13609 }
13610
13611 /**
13612 * create input buffers on device : calculate size of dynamic size memory buffers
13613 */
13614
13615 uint kernel_threads = KERNEL_THREADS;
13616
13617 // some algorithms need a fixed kernel-threads count (mostly because of shared memory usage)
13618
13619 if (hash_mode == 3200) kernel_threads = 8;
13620 if (hash_mode == 9000) kernel_threads = 8;
13621
13622 /**
13623 * some algorithms need a fixed kernel-loops count
13624 */
13625
13626 if (hash_mode == 1500)
13627 {
13628 const u32 kernel_loops_fixed = 1024;
13629
13630 device_param->kernel_loops_min = kernel_loops_fixed;
13631 device_param->kernel_loops_max = kernel_loops_fixed;
13632 }
13633
13634 if (hash_mode == 3000)
13635 {
13636 const u32 kernel_loops_fixed = 1024;
13637
13638 device_param->kernel_loops_min = kernel_loops_fixed;
13639 device_param->kernel_loops_max = kernel_loops_fixed;
13640 }
13641
13642 if (hash_mode == 8900)
13643 {
13644 const u32 kernel_loops_fixed = 1;
13645
13646 device_param->kernel_loops_min = kernel_loops_fixed;
13647 device_param->kernel_loops_max = kernel_loops_fixed;
13648 }
13649
13650 if (hash_mode == 9300)
13651 {
13652 const u32 kernel_loops_fixed = 1;
13653
13654 device_param->kernel_loops_min = kernel_loops_fixed;
13655 device_param->kernel_loops_max = kernel_loops_fixed;
13656 }
13657
13658 if (hash_mode == 12500)
13659 {
13660 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13661
13662 device_param->kernel_loops_min = kernel_loops_fixed;
13663 device_param->kernel_loops_max = kernel_loops_fixed;
13664 }
13665
13666 /**
13667 * some algorithms have a maximum kernel-loops count
13668 */
13669
13670 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13671 {
13672 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13673 {
13674 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13675 }
13676 }
13677
13678 /**
13679 * some algorithms need a special kernel-accel
13680 */
13681
13682 if (hash_mode == 8900)
13683 {
13684 device_param->kernel_accel_min = 1;
13685 device_param->kernel_accel_max = 64;
13686 }
13687
13688 if (hash_mode == 9300)
13689 {
13690 device_param->kernel_accel_min = 1;
13691 device_param->kernel_accel_max = 64;
13692 }
13693
13694 u32 kernel_accel_min = device_param->kernel_accel_min;
13695 u32 kernel_accel_max = device_param->kernel_accel_max;
13696
13697 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13698
13699 uint size_pws = 4;
13700 uint size_tmps = 4;
13701 uint size_hooks = 4;
13702
13703 while (kernel_accel_max >= kernel_accel_min)
13704 {
13705 uint kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13706
13707 // size_pws
13708
13709 size_pws = kernel_power_max * sizeof (pw_t);
13710
13711 // size_tmps
13712
13713 switch (hash_mode)
13714 {
13715 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13716 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13717 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13718 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13719 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13720 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13721 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13722 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13723 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13724 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13725 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13726 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13727 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13728 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13729 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13730 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13731 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13732 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13733 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13734 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13735 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13736 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13737 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13738 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13739 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13740 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13741 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13742 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13743 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13744 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13745 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13746 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13747 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13748 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13749 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13750 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13751 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13752 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13753 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13754 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13755 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13756 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13757 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13758 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13759 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13760 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13761 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13762 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13763 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13764 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13765 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13766 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13767 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13768 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13769 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13770 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13771 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13772 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13773 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13774 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13775 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13776 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
13777 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
13778 };
13779
13780 // size_hooks
13781
13782 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13783 {
13784 // none yet
13785 }
13786
13787 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13788 // if not, decrease amplifier and try again
13789
13790 int skip = 0;
13791
13792 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13793 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13794 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13795
13796 if (( bitmap_size
13797 + bitmap_size
13798 + bitmap_size
13799 + bitmap_size
13800 + bitmap_size
13801 + bitmap_size
13802 + bitmap_size
13803 + bitmap_size
13804 + size_bfs
13805 + size_combs
13806 + size_digests
13807 + size_esalts
13808 + size_hooks
13809 + size_markov_css
13810 + size_plains
13811 + size_pws
13812 + size_results
13813 + size_root_css
13814 + size_rules
13815 + size_rules_c
13816 + size_salts
13817 + size_scryptV
13818 + size_shown
13819 + size_tm
13820 + size_tmps) > device_param->device_global_mem) skip = 1;
13821
13822 if (skip == 1)
13823 {
13824 kernel_accel_max--;
13825
13826 continue;
13827 }
13828
13829 break;
13830 }
13831
13832 /*
13833 if (kernel_accel_max == 0)
13834 {
13835 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13836
13837 return -1;
13838 }
13839 */
13840
13841 device_param->kernel_accel_min = kernel_accel_min;
13842 device_param->kernel_accel_max = kernel_accel_max;
13843
13844 /*
13845 if (kernel_accel_max < kernel_accel)
13846 {
13847 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13848
13849 device_param->kernel_accel = kernel_accel_max;
13850 }
13851 */
13852
13853 device_param->size_bfs = size_bfs;
13854 device_param->size_combs = size_combs;
13855 device_param->size_rules = size_rules;
13856 device_param->size_rules_c = size_rules_c;
13857 device_param->size_pws = size_pws;
13858 device_param->size_tmps = size_tmps;
13859 device_param->size_hooks = size_hooks;
13860
13861 // do not confuse kernel_accel_max with kernel_accel here
13862
13863 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13864
13865 device_param->kernel_threads = kernel_threads;
13866 device_param->kernel_power_user = kernel_power;
13867
13868 kernel_power_all += kernel_power;
13869
13870 /**
13871 * default building options
13872 */
13873
13874 char build_opts[1024] = { 0 };
13875
13876 // we don't have sm_* on vendors not NV but it doesn't matter
13877
13878 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);
13879
13880 /**
13881 * main kernel
13882 */
13883
13884 {
13885 /**
13886 * kernel source filename
13887 */
13888
13889 char source_file[256] = { 0 };
13890
13891 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13892
13893 struct stat sst;
13894
13895 if (stat (source_file, &sst) == -1)
13896 {
13897 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13898
13899 return -1;
13900 }
13901
13902 /**
13903 * kernel cached filename
13904 */
13905
13906 char cached_file[256] = { 0 };
13907
13908 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13909
13910 int cached = 1;
13911
13912 struct stat cst;
13913
13914 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13915 {
13916 cached = 0;
13917 }
13918
13919 /**
13920 * kernel compile or load
13921 */
13922
13923 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13924
13925 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13926
13927 if (force_jit_compilation == -1)
13928 {
13929 if (cached == 0)
13930 {
13931 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13932
13933 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13934
13935 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13936
13937 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13938
13939 #ifdef DEBUG
13940 size_t build_log_size = 0;
13941
13942 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
13943
13944 if (build_log_size > 1)
13945 {
13946 char *build_log = (char *) malloc (build_log_size + 1);
13947
13948 memset (build_log, 0, build_log_size + 1);
13949
13950 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
13951
13952 puts (build_log);
13953
13954 free (build_log);
13955 }
13956 #endif
13957
13958 if (rc != 0)
13959 {
13960 device_param->skipped = true;
13961 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13962 continue;
13963 }
13964
13965 size_t binary_size;
13966
13967 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13968
13969 u8 *binary = (u8 *) mymalloc (binary_size);
13970
13971 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13972
13973 writeProgramBin (cached_file, binary, binary_size);
13974
13975 local_free (binary);
13976 }
13977 else
13978 {
13979 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13980
13981 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13982
13983 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13984
13985 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
13986 }
13987 }
13988 else
13989 {
13990 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13991
13992 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13993
13994 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13995
13996 char build_opts_update[1024] = { 0 };
13997
13998 if (force_jit_compilation == 1500)
13999 {
14000 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14001 }
14002 else if (force_jit_compilation == 8900)
14003 {
14004 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);
14005 }
14006 else
14007 {
14008 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14009 }
14010
14011 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14012
14013 #ifdef DEBUG
14014 size_t build_log_size = 0;
14015
14016 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14017
14018 if (build_log_size > 1)
14019 {
14020 char *build_log = (char *) malloc (build_log_size + 1);
14021
14022 memset (build_log, 0, build_log_size + 1);
14023
14024 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14025
14026 puts (build_log);
14027
14028 free (build_log);
14029 }
14030 #endif
14031
14032 if (rc != 0)
14033 {
14034 device_param->skipped = true;
14035
14036 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14037 }
14038 }
14039
14040 local_free (kernel_lengths);
14041 local_free (kernel_sources[0]);
14042 local_free (kernel_sources);
14043 }
14044
14045 /**
14046 * word generator kernel
14047 */
14048
14049 if (attack_mode != ATTACK_MODE_STRAIGHT)
14050 {
14051 /**
14052 * kernel mp source filename
14053 */
14054
14055 char source_file[256] = { 0 };
14056
14057 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14058
14059 struct stat sst;
14060
14061 if (stat (source_file, &sst) == -1)
14062 {
14063 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14064
14065 return -1;
14066 }
14067
14068 /**
14069 * kernel mp cached filename
14070 */
14071
14072 char cached_file[256] = { 0 };
14073
14074 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14075
14076 int cached = 1;
14077
14078 struct stat cst;
14079
14080 if (stat (cached_file, &cst) == -1)
14081 {
14082 cached = 0;
14083 }
14084
14085 /**
14086 * kernel compile or load
14087 */
14088
14089 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14090
14091 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14092
14093 if (cached == 0)
14094 {
14095 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14096
14097 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14098
14099 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14100
14101 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14102
14103 if (rc != 0)
14104 {
14105 device_param->skipped = true;
14106 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14107 continue;
14108 }
14109
14110 size_t binary_size;
14111
14112 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14113
14114 u8 *binary = (u8 *) mymalloc (binary_size);
14115
14116 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14117
14118 writeProgramBin (cached_file, binary, binary_size);
14119
14120 local_free (binary);
14121 }
14122 else
14123 {
14124 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14125
14126 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14127
14128 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14129
14130 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14131 }
14132
14133 local_free (kernel_lengths);
14134 local_free (kernel_sources[0]);
14135 local_free (kernel_sources);
14136 }
14137
14138 /**
14139 * amplifier kernel
14140 */
14141
14142 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14143 {
14144
14145 }
14146 else
14147 {
14148 /**
14149 * kernel amp source filename
14150 */
14151
14152 char source_file[256] = { 0 };
14153
14154 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14155
14156 struct stat sst;
14157
14158 if (stat (source_file, &sst) == -1)
14159 {
14160 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14161
14162 return -1;
14163 }
14164
14165 /**
14166 * kernel amp cached filename
14167 */
14168
14169 char cached_file[256] = { 0 };
14170
14171 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14172
14173 int cached = 1;
14174
14175 struct stat cst;
14176
14177 if (stat (cached_file, &cst) == -1)
14178 {
14179 cached = 0;
14180 }
14181
14182 /**
14183 * kernel compile or load
14184 */
14185
14186 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14187
14188 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14189
14190 if (cached == 0)
14191 {
14192 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14193
14194 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14195
14196 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14197
14198 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14199
14200 if (rc != 0)
14201 {
14202 device_param->skipped = true;
14203 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14204 continue;
14205 }
14206
14207 size_t binary_size;
14208
14209 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14210
14211 u8 *binary = (u8 *) mymalloc (binary_size);
14212
14213 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14214
14215 writeProgramBin (cached_file, binary, binary_size);
14216
14217 local_free (binary);
14218 }
14219 else
14220 {
14221 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14222
14223 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14224
14225 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14226
14227 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14228 }
14229
14230 local_free (kernel_lengths);
14231 local_free (kernel_sources[0]);
14232 local_free (kernel_sources);
14233 }
14234
14235 // some algorithm collide too fast, make that impossible
14236
14237 if (benchmark == 1)
14238 {
14239 ((uint *) digests_buf)[0] = -1;
14240 ((uint *) digests_buf)[1] = -1;
14241 ((uint *) digests_buf)[2] = -1;
14242 ((uint *) digests_buf)[3] = -1;
14243 }
14244
14245 /**
14246 * global buffers
14247 */
14248
14249 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14250 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14251 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14252 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14253 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14254 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14255 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14256 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14257 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14258 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14259 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14260 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14261 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14262 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14263 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14264 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14265 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14266 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14267
14268 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);
14269 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);
14270 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);
14271 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);
14272 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);
14273 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);
14274 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);
14275 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);
14276 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14277 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14278 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14279
14280 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14281 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14282 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14283 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14284 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14285 run_kernel_bzero (device_param, device_param->d_result, size_results);
14286
14287 /**
14288 * special buffers
14289 */
14290
14291 if (attack_kern == ATTACK_KERN_STRAIGHT)
14292 {
14293 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14294 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14295
14296 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14297
14298 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14299 }
14300 else if (attack_kern == ATTACK_KERN_COMBI)
14301 {
14302 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14303 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14304 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14305 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14306
14307 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14308 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14309 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14310 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14311 }
14312 else if (attack_kern == ATTACK_KERN_BF)
14313 {
14314 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14315 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14316 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14317 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14318 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14319
14320 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14321 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14322 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14323 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14324 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14325 }
14326
14327 if (size_esalts)
14328 {
14329 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14330
14331 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14332 }
14333
14334 /**
14335 * main host data
14336 */
14337
14338 uint *result = (uint *) mymalloc (size_results);
14339
14340 device_param->result = result;
14341
14342 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14343
14344 device_param->pws_buf = pws_buf;
14345
14346 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14347
14348 device_param->combs_buf = combs_buf;
14349
14350 void *hooks_buf = mymalloc (size_hooks);
14351
14352 device_param->hooks_buf = hooks_buf;
14353
14354 /**
14355 * kernel args
14356 */
14357
14358 device_param->kernel_params_buf32[21] = bitmap_mask;
14359 device_param->kernel_params_buf32[22] = bitmap_shift1;
14360 device_param->kernel_params_buf32[23] = bitmap_shift2;
14361 device_param->kernel_params_buf32[24] = 0; // salt_pos
14362 device_param->kernel_params_buf32[25] = 0; // loop_pos
14363 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14364 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14365 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14366 device_param->kernel_params_buf32[29] = 0; // digests_offset
14367 device_param->kernel_params_buf32[30] = 0; // combs_mode
14368 device_param->kernel_params_buf32[31] = 0; // gid_max
14369
14370 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14371 ? &device_param->d_pws_buf
14372 : &device_param->d_pws_amp_buf;
14373 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14374 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14375 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14376 device_param->kernel_params[ 4] = &device_param->d_tmps;
14377 device_param->kernel_params[ 5] = &device_param->d_hooks;
14378 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14379 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14380 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14381 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14382 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14383 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14384 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14385 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14386 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14387 device_param->kernel_params[15] = &device_param->d_digests_buf;
14388 device_param->kernel_params[16] = &device_param->d_digests_shown;
14389 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14390 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14391 device_param->kernel_params[19] = &device_param->d_result;
14392 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14393 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14394 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14395 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14396 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14397 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14398 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14399 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14400 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14401 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14402 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14403 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14404
14405 device_param->kernel_params_mp_buf64[3] = 0;
14406 device_param->kernel_params_mp_buf32[4] = 0;
14407 device_param->kernel_params_mp_buf32[5] = 0;
14408 device_param->kernel_params_mp_buf32[6] = 0;
14409 device_param->kernel_params_mp_buf32[7] = 0;
14410 device_param->kernel_params_mp_buf32[8] = 0;
14411
14412 device_param->kernel_params_mp[0] = NULL;
14413 device_param->kernel_params_mp[1] = NULL;
14414 device_param->kernel_params_mp[2] = NULL;
14415 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14416 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14417 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14418 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14419 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14420 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14421
14422 device_param->kernel_params_mp_l_buf64[3] = 0;
14423 device_param->kernel_params_mp_l_buf32[4] = 0;
14424 device_param->kernel_params_mp_l_buf32[5] = 0;
14425 device_param->kernel_params_mp_l_buf32[6] = 0;
14426 device_param->kernel_params_mp_l_buf32[7] = 0;
14427 device_param->kernel_params_mp_l_buf32[8] = 0;
14428 device_param->kernel_params_mp_l_buf32[9] = 0;
14429
14430 device_param->kernel_params_mp_l[0] = NULL;
14431 device_param->kernel_params_mp_l[1] = NULL;
14432 device_param->kernel_params_mp_l[2] = NULL;
14433 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14434 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14435 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14436 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14437 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14438 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14439 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14440
14441 device_param->kernel_params_mp_r_buf64[3] = 0;
14442 device_param->kernel_params_mp_r_buf32[4] = 0;
14443 device_param->kernel_params_mp_r_buf32[5] = 0;
14444 device_param->kernel_params_mp_r_buf32[6] = 0;
14445 device_param->kernel_params_mp_r_buf32[7] = 0;
14446 device_param->kernel_params_mp_r_buf32[8] = 0;
14447
14448 device_param->kernel_params_mp_r[0] = NULL;
14449 device_param->kernel_params_mp_r[1] = NULL;
14450 device_param->kernel_params_mp_r[2] = NULL;
14451 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14452 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14453 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14454 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14455 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14456 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14457
14458 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14459 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14460
14461 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14462 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14463 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14464 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14465 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14466 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14467 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14468
14469 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14470 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14471
14472 /**
14473 * kernel name
14474 */
14475
14476 char kernel_name[64] = { 0 };
14477
14478 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14479 {
14480 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14481 {
14482 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14483
14484 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14485
14486 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14487
14488 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14489
14490 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14491
14492 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14493 }
14494 else
14495 {
14496 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14497
14498 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14499
14500 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14501
14502 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14503
14504 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14505
14506 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14507 }
14508
14509 if (data.attack_mode == ATTACK_MODE_BF)
14510 {
14511 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14512 {
14513 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14514
14515 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14516 }
14517 }
14518 }
14519 else
14520 {
14521 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14522
14523 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14524
14525 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14526
14527 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14528
14529 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14530
14531 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14532
14533 if (opts_type & OPTS_TYPE_HOOK12)
14534 {
14535 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14536
14537 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14538 }
14539
14540 if (opts_type & OPTS_TYPE_HOOK23)
14541 {
14542 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14543
14544 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14545 }
14546 }
14547
14548 for (uint i = 0; i <= 20; i++)
14549 {
14550 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14551 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14552 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14553
14554 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14555 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14556 }
14557
14558 for (uint i = 21; i <= 31; i++)
14559 {
14560 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14561 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14562 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14563
14564 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14565 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14566 }
14567
14568 if (attack_mode == ATTACK_MODE_BF)
14569 {
14570 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14571 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14572
14573 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14574 {
14575 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14576 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14577 }
14578 }
14579 else if (attack_mode == ATTACK_MODE_HYBRID1)
14580 {
14581 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14582 }
14583 else if (attack_mode == ATTACK_MODE_HYBRID2)
14584 {
14585 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14586 }
14587
14588 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14589 {
14590 // nothing to do
14591 }
14592 else
14593 {
14594 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14595 }
14596
14597 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14598 {
14599 // nothing to do
14600 }
14601 else
14602 {
14603 for (uint i = 0; i < 5; i++)
14604 {
14605 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14606 }
14607
14608 for (uint i = 5; i < 7; i++)
14609 {
14610 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14611 }
14612 }
14613
14614 /**
14615 * Store initial fanspeed if gpu_temp_retain is enabled
14616 */
14617
14618 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14619 int gpu_temp_retain_set = 0;
14620
14621 if (gpu_temp_disable == 0)
14622 {
14623 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14624 {
14625 hc_thread_mutex_lock (mux_adl);
14626
14627 if (data.hm_device[device_id].fan_supported == 1)
14628 {
14629 if (gpu_temp_retain_chgd == 0)
14630 {
14631 uint cur_temp = 0;
14632 uint default_temp = 0;
14633
14634 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);
14635
14636 if (ADL_rc == ADL_OK)
14637 {
14638 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14639
14640 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14641
14642 // special case with multi gpu setups: always use minimum retain
14643
14644 if (gpu_temp_retain_set == 0)
14645 {
14646 gpu_temp_retain = gpu_temp_retain_target;
14647 gpu_temp_retain_set = 1;
14648 }
14649 else
14650 {
14651 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14652 }
14653
14654 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14655 }
14656 }
14657
14658 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14659
14660 temp_retain_fanspeed_value[device_id] = fan_speed;
14661
14662 if (fan_speed == -1)
14663 {
14664 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14665
14666 temp_retain_fanspeed_value[device_id] = 0;
14667 }
14668 }
14669
14670 hc_thread_mutex_unlock (mux_adl);
14671 }
14672 }
14673
14674 /**
14675 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14676 */
14677
14678 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14679 {
14680 hc_thread_mutex_lock (mux_adl);
14681
14682 if (data.hm_device[device_id].od_version == 6)
14683 {
14684 int ADL_rc;
14685
14686 // check powertune capabilities first, if not available then skip device
14687
14688 int powertune_supported = 0;
14689
14690 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14691 {
14692 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14693
14694 return (-1);
14695 }
14696
14697 if (powertune_supported != 0)
14698 {
14699 // powercontrol settings
14700
14701 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14702
14703 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14704 {
14705 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14706 }
14707
14708 if (ADL_rc != ADL_OK)
14709 {
14710 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14711
14712 return (-1);
14713 }
14714
14715 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14716 {
14717 log_error ("ERROR: Failed to set new ADL PowerControl values");
14718
14719 return (-1);
14720 }
14721
14722 // clocks
14723
14724 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14725
14726 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14727
14728 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)
14729 {
14730 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14731
14732 return (-1);
14733 }
14734
14735 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14736
14737 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14738
14739 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14740 {
14741 log_error ("ERROR: Failed to get ADL device capabilities");
14742
14743 return (-1);
14744 }
14745
14746 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14747 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14748
14749 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14750 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14751
14752 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14753 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14754
14755 // warning if profile has too low max values
14756
14757 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14758 {
14759 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14760 }
14761
14762 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14763 {
14764 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14765 }
14766
14767 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14768
14769 performance_state->iNumberOfPerformanceLevels = 2;
14770
14771 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14772 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14773 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14774 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14775
14776 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)
14777 {
14778 log_info ("ERROR: Failed to set ADL performance state");
14779
14780 return (-1);
14781 }
14782
14783 local_free (performance_state);
14784 }
14785 }
14786
14787 hc_thread_mutex_unlock (mux_adl);
14788 }
14789 #endif // HAVE_HWMON && HAVE_ADL
14790 }
14791
14792 data.kernel_power_all = kernel_power_all;
14793
14794 if (data.quiet == 0) log_info ("");
14795
14796 /**
14797 * In benchmark-mode, inform user which algorithm is checked
14798 */
14799
14800 if (benchmark == 1)
14801 {
14802 quiet = 0;
14803
14804 data.quiet = quiet;
14805
14806 char *hash_type = strhashtype (data.hash_mode); // not a bug
14807
14808 log_info ("Hashtype: %s", hash_type);
14809 log_info ("");
14810 }
14811
14812 /**
14813 * keep track of the progress
14814 */
14815
14816 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14817 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14818 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14819
14820 /**
14821 * open filehandles
14822 */
14823
14824 #if _WIN
14825 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14826 {
14827 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14828
14829 return (-1);
14830 }
14831
14832 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14833 {
14834 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14835
14836 return (-1);
14837 }
14838
14839 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14840 {
14841 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14842
14843 return (-1);
14844 }
14845 #endif
14846
14847 /**
14848 * dictionary pad
14849 */
14850
14851 segment_size *= (1024 * 1024);
14852
14853 data.segment_size = segment_size;
14854
14855 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14856
14857 wl_data->buf = (char *) mymalloc (segment_size);
14858 wl_data->avail = segment_size;
14859 wl_data->incr = segment_size;
14860 wl_data->cnt = 0;
14861 wl_data->pos = 0;
14862
14863 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14864
14865 data.wordlist_mode = wordlist_mode;
14866
14867 cs_t *css_buf = NULL;
14868 uint css_cnt = 0;
14869 uint dictcnt = 0;
14870 uint maskcnt = 1;
14871 char **masks = NULL;
14872 char **dictfiles = NULL;
14873
14874 uint mask_from_file = 0;
14875
14876 if (attack_mode == ATTACK_MODE_STRAIGHT)
14877 {
14878 if (wordlist_mode == WL_MODE_FILE)
14879 {
14880 int wls_left = myargc - (optind + 1);
14881
14882 for (int i = 0; i < wls_left; i++)
14883 {
14884 char *l0_filename = myargv[optind + 1 + i];
14885
14886 struct stat l0_stat;
14887
14888 if (stat (l0_filename, &l0_stat) == -1)
14889 {
14890 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14891
14892 return (-1);
14893 }
14894
14895 uint is_dir = S_ISDIR (l0_stat.st_mode);
14896
14897 if (is_dir == 0)
14898 {
14899 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14900
14901 dictcnt++;
14902
14903 dictfiles[dictcnt - 1] = l0_filename;
14904 }
14905 else
14906 {
14907 // do not allow --keyspace w/ a directory
14908
14909 if (keyspace == 1)
14910 {
14911 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14912
14913 return (-1);
14914 }
14915
14916 char **dictionary_files = NULL;
14917
14918 dictionary_files = scan_directory (l0_filename);
14919
14920 if (dictionary_files != NULL)
14921 {
14922 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14923
14924 for (int d = 0; dictionary_files[d] != NULL; d++)
14925 {
14926 char *l1_filename = dictionary_files[d];
14927
14928 struct stat l1_stat;
14929
14930 if (stat (l1_filename, &l1_stat) == -1)
14931 {
14932 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14933
14934 return (-1);
14935 }
14936
14937 if (S_ISREG (l1_stat.st_mode))
14938 {
14939 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14940
14941 dictcnt++;
14942
14943 dictfiles[dictcnt - 1] = strdup (l1_filename);
14944 }
14945 }
14946 }
14947
14948 local_free (dictionary_files);
14949 }
14950 }
14951
14952 if (dictcnt < 1)
14953 {
14954 log_error ("ERROR: No usable dictionary file found.");
14955
14956 return (-1);
14957 }
14958 }
14959 else if (wordlist_mode == WL_MODE_STDIN)
14960 {
14961 dictcnt = 1;
14962 }
14963 }
14964 else if (attack_mode == ATTACK_MODE_COMBI)
14965 {
14966 // display
14967
14968 char *dictfile1 = myargv[optind + 1 + 0];
14969 char *dictfile2 = myargv[optind + 1 + 1];
14970
14971 // find the bigger dictionary and use as base
14972
14973 FILE *fp1 = NULL;
14974 FILE *fp2 = NULL;
14975
14976 struct stat tmp_stat;
14977
14978 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14979 {
14980 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14981
14982 return (-1);
14983 }
14984
14985 if (stat (dictfile1, &tmp_stat) == -1)
14986 {
14987 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14988
14989 fclose (fp1);
14990
14991 return (-1);
14992 }
14993
14994 if (S_ISDIR (tmp_stat.st_mode))
14995 {
14996 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14997
14998 fclose (fp1);
14999
15000 return (-1);
15001 }
15002
15003 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15004 {
15005 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15006
15007 fclose (fp1);
15008
15009 return (-1);
15010 }
15011
15012 if (stat (dictfile2, &tmp_stat) == -1)
15013 {
15014 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15015
15016 fclose (fp1);
15017 fclose (fp2);
15018
15019 return (-1);
15020 }
15021
15022 if (S_ISDIR (tmp_stat.st_mode))
15023 {
15024 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15025
15026 fclose (fp1);
15027 fclose (fp2);
15028
15029 return (-1);
15030 }
15031
15032 data.combs_cnt = 1;
15033
15034 data.quiet = 1;
15035
15036 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15037
15038 data.quiet = quiet;
15039
15040 if (words1_cnt == 0)
15041 {
15042 log_error ("ERROR: %s: empty file", dictfile1);
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 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15055
15056 data.quiet = quiet;
15057
15058 if (words2_cnt == 0)
15059 {
15060 log_error ("ERROR: %s: empty file", dictfile2);
15061
15062 fclose (fp1);
15063 fclose (fp2);
15064
15065 return (-1);
15066 }
15067
15068 fclose (fp1);
15069 fclose (fp2);
15070
15071 data.dictfile = dictfile1;
15072 data.dictfile2 = dictfile2;
15073
15074 if (words1_cnt >= words2_cnt)
15075 {
15076 data.combs_cnt = words2_cnt;
15077 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15078
15079 dictfiles = &data.dictfile;
15080
15081 dictcnt = 1;
15082 }
15083 else
15084 {
15085 data.combs_cnt = words1_cnt;
15086 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15087
15088 dictfiles = &data.dictfile2;
15089
15090 dictcnt = 1;
15091
15092 // we also have to switch wordlist related rules!
15093
15094 char *tmpc = data.rule_buf_l;
15095
15096 data.rule_buf_l = data.rule_buf_r;
15097 data.rule_buf_r = tmpc;
15098
15099 int tmpi = data.rule_len_l;
15100
15101 data.rule_len_l = data.rule_len_r;
15102 data.rule_len_r = tmpi;
15103 }
15104 }
15105 else if (attack_mode == ATTACK_MODE_BF)
15106 {
15107 char *mask = NULL;
15108
15109 maskcnt = 0;
15110
15111 if (benchmark == 0)
15112 {
15113 mask = myargv[optind + 1];
15114
15115 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15116
15117 if ((optind + 2) <= myargc)
15118 {
15119 struct stat file_stat;
15120
15121 if (stat (mask, &file_stat) == -1)
15122 {
15123 maskcnt = 1;
15124
15125 masks[maskcnt - 1] = mystrdup (mask);
15126 }
15127 else
15128 {
15129 int wls_left = myargc - (optind + 1);
15130
15131 uint masks_avail = INCR_MASKS;
15132
15133 for (int i = 0; i < wls_left; i++)
15134 {
15135 if (i != 0)
15136 {
15137 mask = myargv[optind + 1 + i];
15138
15139 if (stat (mask, &file_stat) == -1)
15140 {
15141 log_error ("ERROR: %s: %s", mask, strerror (errno));
15142
15143 return (-1);
15144 }
15145 }
15146
15147 uint is_file = S_ISREG (file_stat.st_mode);
15148
15149 if (is_file == 1)
15150 {
15151 FILE *mask_fp;
15152
15153 if ((mask_fp = fopen (mask, "r")) == NULL)
15154 {
15155 log_error ("ERROR: %s: %s", mask, strerror (errno));
15156
15157 return (-1);
15158 }
15159
15160 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15161
15162 while (!feof (mask_fp))
15163 {
15164 memset (line_buf, 0, HCBUFSIZ);
15165
15166 int line_len = fgetl (mask_fp, line_buf);
15167
15168 if (line_len == 0) continue;
15169
15170 if (line_buf[0] == '#') continue;
15171
15172 if (masks_avail == maskcnt)
15173 {
15174 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15175
15176 masks_avail += INCR_MASKS;
15177 }
15178
15179 masks[maskcnt] = mystrdup (line_buf);
15180
15181 maskcnt++;
15182 }
15183
15184 myfree (line_buf);
15185
15186 fclose (mask_fp);
15187 }
15188 else
15189 {
15190 log_error ("ERROR: %s: unsupported file-type", mask);
15191
15192 return (-1);
15193 }
15194 }
15195
15196 mask_from_file = 1;
15197 }
15198 }
15199 else
15200 {
15201 custom_charset_1 = (char *) "?l?d?u";
15202 custom_charset_2 = (char *) "?l?d";
15203 custom_charset_3 = (char *) "?l?d*!$@_";
15204
15205 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15206 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15207 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15208
15209 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15210
15211 wordlist_mode = WL_MODE_MASK;
15212
15213 data.wordlist_mode = wordlist_mode;
15214
15215 increment = 1;
15216
15217 maskcnt = 1;
15218 }
15219 }
15220 else
15221 {
15222 /**
15223 * generate full masks and charsets
15224 */
15225
15226 masks = (char **) mymalloc (sizeof (char *));
15227
15228 switch (hash_mode)
15229 {
15230 case 1731: pw_min = 5;
15231 pw_max = 5;
15232 mask = mystrdup ("?b?b?b?b?b");
15233 break;
15234 case 12500: pw_min = 5;
15235 pw_max = 5;
15236 mask = mystrdup ("?b?b?b?b?b");
15237 break;
15238 default: pw_min = 7;
15239 pw_max = 7;
15240 mask = mystrdup ("?b?b?b?b?b?b?b");
15241 break;
15242 }
15243
15244 maskcnt = 1;
15245
15246 masks[maskcnt - 1] = mystrdup (mask);
15247
15248 wordlist_mode = WL_MODE_MASK;
15249
15250 data.wordlist_mode = wordlist_mode;
15251
15252 increment = 1;
15253 }
15254
15255 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15256
15257 if (increment)
15258 {
15259 if (increment_min > pw_min) pw_min = increment_min;
15260
15261 if (increment_max < pw_max) pw_max = increment_max;
15262 }
15263 }
15264 else if (attack_mode == ATTACK_MODE_HYBRID1)
15265 {
15266 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15267
15268 // display
15269
15270 char *mask = myargv[myargc - 1];
15271
15272 maskcnt = 0;
15273
15274 masks = (char **) mymalloc (1 * sizeof (char *));
15275
15276 // mod
15277
15278 struct stat file_stat;
15279
15280 if (stat (mask, &file_stat) == -1)
15281 {
15282 maskcnt = 1;
15283
15284 masks[maskcnt - 1] = mystrdup (mask);
15285 }
15286 else
15287 {
15288 uint is_file = S_ISREG (file_stat.st_mode);
15289
15290 if (is_file == 1)
15291 {
15292 FILE *mask_fp;
15293
15294 if ((mask_fp = fopen (mask, "r")) == NULL)
15295 {
15296 log_error ("ERROR: %s: %s", mask, strerror (errno));
15297
15298 return (-1);
15299 }
15300
15301 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15302
15303 uint masks_avail = 1;
15304
15305 while (!feof (mask_fp))
15306 {
15307 memset (line_buf, 0, HCBUFSIZ);
15308
15309 int line_len = fgetl (mask_fp, line_buf);
15310
15311 if (line_len == 0) continue;
15312
15313 if (line_buf[0] == '#') continue;
15314
15315 if (masks_avail == maskcnt)
15316 {
15317 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15318
15319 masks_avail += INCR_MASKS;
15320 }
15321
15322 masks[maskcnt] = mystrdup (line_buf);
15323
15324 maskcnt++;
15325 }
15326
15327 myfree (line_buf);
15328
15329 fclose (mask_fp);
15330
15331 mask_from_file = 1;
15332 }
15333 else
15334 {
15335 maskcnt = 1;
15336
15337 masks[maskcnt - 1] = mystrdup (mask);
15338 }
15339 }
15340
15341 // base
15342
15343 int wls_left = myargc - (optind + 2);
15344
15345 for (int i = 0; i < wls_left; i++)
15346 {
15347 char *filename = myargv[optind + 1 + i];
15348
15349 struct stat file_stat;
15350
15351 if (stat (filename, &file_stat) == -1)
15352 {
15353 log_error ("ERROR: %s: %s", filename, strerror (errno));
15354
15355 return (-1);
15356 }
15357
15358 uint is_dir = S_ISDIR (file_stat.st_mode);
15359
15360 if (is_dir == 0)
15361 {
15362 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15363
15364 dictcnt++;
15365
15366 dictfiles[dictcnt - 1] = filename;
15367 }
15368 else
15369 {
15370 // do not allow --keyspace w/ a directory
15371
15372 if (keyspace == 1)
15373 {
15374 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15375
15376 return (-1);
15377 }
15378
15379 char **dictionary_files = NULL;
15380
15381 dictionary_files = scan_directory (filename);
15382
15383 if (dictionary_files != NULL)
15384 {
15385 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15386
15387 for (int d = 0; dictionary_files[d] != NULL; d++)
15388 {
15389 char *l1_filename = dictionary_files[d];
15390
15391 struct stat l1_stat;
15392
15393 if (stat (l1_filename, &l1_stat) == -1)
15394 {
15395 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15396
15397 return (-1);
15398 }
15399
15400 if (S_ISREG (l1_stat.st_mode))
15401 {
15402 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15403
15404 dictcnt++;
15405
15406 dictfiles[dictcnt - 1] = strdup (l1_filename);
15407 }
15408 }
15409 }
15410
15411 local_free (dictionary_files);
15412 }
15413 }
15414
15415 if (dictcnt < 1)
15416 {
15417 log_error ("ERROR: No usable dictionary file found.");
15418
15419 return (-1);
15420 }
15421
15422 if (increment)
15423 {
15424 maskcnt = 0;
15425
15426 uint mask_min = increment_min; // we can't reject smaller masks here
15427 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15428
15429 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15430 {
15431 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15432
15433 if (cur_mask == NULL) break;
15434
15435 masks[maskcnt] = cur_mask;
15436
15437 maskcnt++;
15438
15439 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15440 }
15441 }
15442 }
15443 else if (attack_mode == ATTACK_MODE_HYBRID2)
15444 {
15445 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15446
15447 // display
15448
15449 char *mask = myargv[optind + 1 + 0];
15450
15451 maskcnt = 0;
15452
15453 masks = (char **) mymalloc (1 * sizeof (char *));
15454
15455 // mod
15456
15457 struct stat file_stat;
15458
15459 if (stat (mask, &file_stat) == -1)
15460 {
15461 maskcnt = 1;
15462
15463 masks[maskcnt - 1] = mystrdup (mask);
15464 }
15465 else
15466 {
15467 uint is_file = S_ISREG (file_stat.st_mode);
15468
15469 if (is_file == 1)
15470 {
15471 FILE *mask_fp;
15472
15473 if ((mask_fp = fopen (mask, "r")) == NULL)
15474 {
15475 log_error ("ERROR: %s: %s", mask, strerror (errno));
15476
15477 return (-1);
15478 }
15479
15480 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15481
15482 uint masks_avail = 1;
15483
15484 while (!feof (mask_fp))
15485 {
15486 memset (line_buf, 0, HCBUFSIZ);
15487
15488 int line_len = fgetl (mask_fp, line_buf);
15489
15490 if (line_len == 0) continue;
15491
15492 if (line_buf[0] == '#') continue;
15493
15494 if (masks_avail == maskcnt)
15495 {
15496 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15497
15498 masks_avail += INCR_MASKS;
15499 }
15500
15501 masks[maskcnt] = mystrdup (line_buf);
15502
15503 maskcnt++;
15504 }
15505
15506 myfree (line_buf);
15507
15508 fclose (mask_fp);
15509
15510 mask_from_file = 1;
15511 }
15512 else
15513 {
15514 maskcnt = 1;
15515
15516 masks[maskcnt - 1] = mystrdup (mask);
15517 }
15518 }
15519
15520 // base
15521
15522 int wls_left = myargc - (optind + 2);
15523
15524 for (int i = 0; i < wls_left; i++)
15525 {
15526 char *filename = myargv[optind + 2 + i];
15527
15528 struct stat file_stat;
15529
15530 if (stat (filename, &file_stat) == -1)
15531 {
15532 log_error ("ERROR: %s: %s", filename, strerror (errno));
15533
15534 return (-1);
15535 }
15536
15537 uint is_dir = S_ISDIR (file_stat.st_mode);
15538
15539 if (is_dir == 0)
15540 {
15541 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15542
15543 dictcnt++;
15544
15545 dictfiles[dictcnt - 1] = filename;
15546 }
15547 else
15548 {
15549 // do not allow --keyspace w/ a directory
15550
15551 if (keyspace == 1)
15552 {
15553 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15554
15555 return (-1);
15556 }
15557
15558 char **dictionary_files = NULL;
15559
15560 dictionary_files = scan_directory (filename);
15561
15562 if (dictionary_files != NULL)
15563 {
15564 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15565
15566 for (int d = 0; dictionary_files[d] != NULL; d++)
15567 {
15568 char *l1_filename = dictionary_files[d];
15569
15570 struct stat l1_stat;
15571
15572 if (stat (l1_filename, &l1_stat) == -1)
15573 {
15574 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15575
15576 return (-1);
15577 }
15578
15579 if (S_ISREG (l1_stat.st_mode))
15580 {
15581 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15582
15583 dictcnt++;
15584
15585 dictfiles[dictcnt - 1] = strdup (l1_filename);
15586 }
15587 }
15588 }
15589
15590 local_free (dictionary_files);
15591 }
15592 }
15593
15594 if (dictcnt < 1)
15595 {
15596 log_error ("ERROR: No usable dictionary file found.");
15597
15598 return (-1);
15599 }
15600
15601 if (increment)
15602 {
15603 maskcnt = 0;
15604
15605 uint mask_min = increment_min; // we can't reject smaller masks here
15606 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15607
15608 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15609 {
15610 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15611
15612 if (cur_mask == NULL) break;
15613
15614 masks[maskcnt] = cur_mask;
15615
15616 maskcnt++;
15617
15618 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15619 }
15620 }
15621 }
15622
15623 data.pw_min = pw_min;
15624 data.pw_max = pw_max;
15625
15626 /**
15627 * weak hash check
15628 */
15629
15630 if (weak_hash_threshold >= salts_cnt)
15631 {
15632 hc_device_param_t *device_param = NULL;
15633
15634 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15635 {
15636 device_param = &data.devices_param[device_id];
15637
15638 if (device_param->skipped) continue;
15639
15640 break;
15641 }
15642
15643 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15644
15645 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15646 {
15647 weak_hash_check (device_param, salt_pos);
15648 }
15649 }
15650
15651 // Display hack, guarantee that there is at least one \r before real start
15652
15653 if (data.quiet == 0) log_info_nn ("");
15654
15655 /**
15656 * status and monitor threads
15657 */
15658
15659 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15660
15661 hc_thread_t i_thread = 0;
15662
15663 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15664 {
15665 hc_thread_create (i_thread, thread_keypress, &benchmark);
15666 }
15667
15668 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15669
15670 uint ni_threads_cnt = 0;
15671
15672 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15673
15674 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15675
15676 ni_threads_cnt++;
15677
15678 /**
15679 * Outfile remove
15680 */
15681
15682 if (keyspace == 0)
15683 {
15684 if (outfile_check_timer != 0)
15685 {
15686 if (data.outfile_check_directory != NULL)
15687 {
15688 if ((hash_mode != 5200) &&
15689 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15690 (hash_mode != 9000))
15691 {
15692 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15693
15694 ni_threads_cnt++;
15695 }
15696 else
15697 {
15698 outfile_check_timer = 0;
15699 }
15700 }
15701 else
15702 {
15703 outfile_check_timer = 0;
15704 }
15705 }
15706 }
15707
15708 /**
15709 * Inform the user if we got some hashes remove because of the pot file remove feature
15710 */
15711
15712 if (data.quiet == 0)
15713 {
15714 if (potfile_remove_cracks > 0)
15715 {
15716 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15717 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15718 }
15719 }
15720
15721 data.outfile_check_timer = outfile_check_timer;
15722
15723 /**
15724 * main loop
15725 */
15726
15727 char **induction_dictionaries = NULL;
15728
15729 int induction_dictionaries_cnt = 0;
15730
15731 hcstat_table_t *root_table_buf = NULL;
15732 hcstat_table_t *markov_table_buf = NULL;
15733
15734 uint initial_restore_done = 0;
15735
15736 data.maskcnt = maskcnt;
15737
15738 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15739 {
15740 if (data.devices_status == STATUS_CRACKED) break;
15741
15742 data.devices_status = STATUS_INIT;
15743
15744 if (maskpos > rd->maskpos)
15745 {
15746 rd->dictpos = 0;
15747 }
15748
15749 rd->maskpos = maskpos;
15750 data.maskpos = maskpos;
15751
15752 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15753 {
15754 char *mask = masks[maskpos];
15755
15756 if (mask_from_file == 1)
15757 {
15758 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15759
15760 char *str_ptr;
15761 uint str_pos;
15762
15763 uint mask_offset = 0;
15764
15765 uint separator_cnt;
15766
15767 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15768 {
15769 str_ptr = strstr (mask + mask_offset, ",");
15770
15771 if (str_ptr == NULL) break;
15772
15773 str_pos = str_ptr - mask;
15774
15775 // escaped separator, i.e. "\,"
15776
15777 if (str_pos > 0)
15778 {
15779 if (mask[str_pos - 1] == '\\')
15780 {
15781 separator_cnt --;
15782
15783 mask_offset = str_pos + 1;
15784
15785 continue;
15786 }
15787 }
15788
15789 // reset the offset
15790
15791 mask_offset = 0;
15792
15793 mask[str_pos] = '\0';
15794
15795 switch (separator_cnt)
15796 {
15797 case 0:
15798 mp_reset_usr (mp_usr, 0);
15799
15800 custom_charset_1 = mask;
15801 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15802 break;
15803
15804 case 1:
15805 mp_reset_usr (mp_usr, 1);
15806
15807 custom_charset_2 = mask;
15808 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15809 break;
15810
15811 case 2:
15812 mp_reset_usr (mp_usr, 2);
15813
15814 custom_charset_3 = mask;
15815 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15816 break;
15817
15818 case 3:
15819 mp_reset_usr (mp_usr, 3);
15820
15821 custom_charset_4 = mask;
15822 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15823 break;
15824 }
15825
15826 mask = mask + str_pos + 1;
15827 }
15828 }
15829
15830 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15831 {
15832 if (maskpos > 0)
15833 {
15834 local_free (css_buf);
15835 local_free (data.root_css_buf);
15836 local_free (data.markov_css_buf);
15837
15838 local_free (masks[maskpos - 1]);
15839 }
15840
15841 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15842
15843 data.mask = mask;
15844 data.css_cnt = css_cnt;
15845 data.css_buf = css_buf;
15846
15847 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15848
15849 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15850
15851 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15852 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15853
15854 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15855
15856 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15857
15858 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15859 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15860
15861 data.root_css_buf = root_css_buf;
15862 data.markov_css_buf = markov_css_buf;
15863
15864 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15865
15866 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15867
15868 local_free (root_table_buf);
15869 local_free (markov_table_buf);
15870
15871 // args
15872
15873 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15874 {
15875 hc_device_param_t *device_param = &data.devices_param[device_id];
15876
15877 if (device_param->skipped) continue;
15878
15879 device_param->kernel_params_mp[0] = &device_param->d_combs;
15880 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15881 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15882
15883 device_param->kernel_params_mp_buf64[3] = 0;
15884 device_param->kernel_params_mp_buf32[4] = css_cnt;
15885 device_param->kernel_params_mp_buf32[5] = 0;
15886 device_param->kernel_params_mp_buf32[6] = 0;
15887 device_param->kernel_params_mp_buf32[7] = 0;
15888
15889 if (attack_mode == ATTACK_MODE_HYBRID1)
15890 {
15891 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15892 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15893 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15894 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15895 }
15896 else if (attack_mode == ATTACK_MODE_HYBRID2)
15897 {
15898 device_param->kernel_params_mp_buf32[5] = 0;
15899 device_param->kernel_params_mp_buf32[6] = 0;
15900 device_param->kernel_params_mp_buf32[7] = 0;
15901 }
15902
15903 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]);
15904 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]);
15905 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]);
15906
15907 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);
15908 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);
15909 }
15910 }
15911 else if (attack_mode == ATTACK_MODE_BF)
15912 {
15913 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15914
15915 if (increment)
15916 {
15917 for (uint i = 0; i < dictcnt; i++)
15918 {
15919 local_free (dictfiles[i]);
15920 }
15921
15922 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15923 {
15924 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15925
15926 if (l1_filename == NULL) break;
15927
15928 dictcnt++;
15929
15930 dictfiles[dictcnt - 1] = l1_filename;
15931 }
15932 }
15933 else
15934 {
15935 dictcnt++;
15936
15937 dictfiles[dictcnt - 1] = mask;
15938 }
15939
15940 if (dictcnt == 0)
15941 {
15942 log_error ("ERROR: Mask is too small");
15943
15944 return (-1);
15945 }
15946 }
15947 }
15948
15949 free (induction_dictionaries);
15950
15951 // induction_dictionaries_cnt = 0; // implied
15952
15953 if (attack_mode != ATTACK_MODE_BF)
15954 {
15955 if (keyspace == 0)
15956 {
15957 induction_dictionaries = scan_directory (induction_directory);
15958
15959 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15960 }
15961 }
15962
15963 if (induction_dictionaries_cnt)
15964 {
15965 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15966 }
15967
15968 /**
15969 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15970 */
15971 if (keyspace == 1)
15972 {
15973 if ((maskcnt > 1) || (dictcnt > 1))
15974 {
15975 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15976
15977 return (-1);
15978 }
15979 }
15980
15981 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15982 {
15983 char *subid = logfile_generate_subid ();
15984
15985 data.subid = subid;
15986
15987 logfile_sub_msg ("START");
15988
15989 data.devices_status = STATUS_INIT;
15990
15991 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15992 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15993 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15994
15995 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15996
15997 data.cpt_pos = 0;
15998
15999 data.cpt_start = time (NULL);
16000
16001 data.cpt_total = 0;
16002
16003 if (data.restore == 0)
16004 {
16005 rd->words_cur = skip;
16006
16007 skip = 0;
16008
16009 data.skip = 0;
16010 }
16011
16012 data.ms_paused = 0;
16013
16014 data.words_cur = rd->words_cur;
16015
16016 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16017 {
16018 hc_device_param_t *device_param = &data.devices_param[device_id];
16019
16020 if (device_param->skipped) continue;
16021
16022 device_param->speed_pos = 0;
16023
16024 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16025 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16026
16027 device_param->exec_pos = 0;
16028
16029 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16030
16031 device_param->kernel_power = device_param->kernel_power_user;
16032
16033 device_param->outerloop_pos = 0;
16034 device_param->outerloop_left = 0;
16035 device_param->innerloop_pos = 0;
16036 device_param->innerloop_left = 0;
16037
16038 // some more resets:
16039
16040 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16041
16042 device_param->pws_cnt = 0;
16043
16044 device_param->words_off = 0;
16045 device_param->words_done = 0;
16046 }
16047
16048 data.kernel_power_div = 0;
16049
16050 // figure out some workload
16051
16052 if (attack_mode == ATTACK_MODE_STRAIGHT)
16053 {
16054 if (data.wordlist_mode == WL_MODE_FILE)
16055 {
16056 char *dictfile = NULL;
16057
16058 if (induction_dictionaries_cnt)
16059 {
16060 dictfile = induction_dictionaries[0];
16061 }
16062 else
16063 {
16064 dictfile = dictfiles[dictpos];
16065 }
16066
16067 data.dictfile = dictfile;
16068
16069 logfile_sub_string (dictfile);
16070
16071 for (uint i = 0; i < rp_files_cnt; i++)
16072 {
16073 logfile_sub_var_string ("rulefile", rp_files[i]);
16074 }
16075
16076 FILE *fd2 = fopen (dictfile, "rb");
16077
16078 if (fd2 == NULL)
16079 {
16080 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16081
16082 return (-1);
16083 }
16084
16085 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16086
16087 fclose (fd2);
16088
16089 if (data.words_cnt == 0)
16090 {
16091 if (data.devices_status == STATUS_CRACKED) break;
16092 if (data.devices_status == STATUS_ABORTED) break;
16093
16094 dictpos++;
16095
16096 continue;
16097 }
16098 }
16099 }
16100 else if (attack_mode == ATTACK_MODE_COMBI)
16101 {
16102 char *dictfile = data.dictfile;
16103 char *dictfile2 = data.dictfile2;
16104
16105 logfile_sub_string (dictfile);
16106 logfile_sub_string (dictfile2);
16107
16108 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16109 {
16110 FILE *fd2 = fopen (dictfile, "rb");
16111
16112 if (fd2 == NULL)
16113 {
16114 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16115
16116 return (-1);
16117 }
16118
16119 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16120
16121 fclose (fd2);
16122 }
16123 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16124 {
16125 FILE *fd2 = fopen (dictfile2, "rb");
16126
16127 if (fd2 == NULL)
16128 {
16129 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16130
16131 return (-1);
16132 }
16133
16134 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16135
16136 fclose (fd2);
16137 }
16138
16139 if (data.words_cnt == 0)
16140 {
16141 if (data.devices_status == STATUS_CRACKED) break;
16142 if (data.devices_status == STATUS_ABORTED) break;
16143
16144 dictpos++;
16145
16146 continue;
16147 }
16148 }
16149 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16150 {
16151 char *dictfile = NULL;
16152
16153 if (induction_dictionaries_cnt)
16154 {
16155 dictfile = induction_dictionaries[0];
16156 }
16157 else
16158 {
16159 dictfile = dictfiles[dictpos];
16160 }
16161
16162 data.dictfile = dictfile;
16163
16164 char *mask = data.mask;
16165
16166 logfile_sub_string (dictfile);
16167 logfile_sub_string (mask);
16168
16169 FILE *fd2 = fopen (dictfile, "rb");
16170
16171 if (fd2 == NULL)
16172 {
16173 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16174
16175 return (-1);
16176 }
16177
16178 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16179
16180 fclose (fd2);
16181
16182 if (data.words_cnt == 0)
16183 {
16184 if (data.devices_status == STATUS_CRACKED) break;
16185 if (data.devices_status == STATUS_ABORTED) break;
16186
16187 dictpos++;
16188
16189 continue;
16190 }
16191 }
16192 else if (attack_mode == ATTACK_MODE_BF)
16193 {
16194 local_free (css_buf);
16195 local_free (data.root_css_buf);
16196 local_free (data.markov_css_buf);
16197
16198 char *mask = dictfiles[dictpos];
16199
16200 logfile_sub_string (mask);
16201
16202 // base
16203
16204 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16205
16206 if (opts_type & OPTS_TYPE_PT_UNICODE)
16207 {
16208 uint css_cnt_unicode = css_cnt * 2;
16209
16210 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16211
16212 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16213 {
16214 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16215
16216 css_buf_unicode[j + 1].cs_buf[0] = 0;
16217 css_buf_unicode[j + 1].cs_len = 1;
16218 }
16219
16220 free (css_buf);
16221
16222 css_buf = css_buf_unicode;
16223 css_cnt = css_cnt_unicode;
16224 }
16225
16226 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16227
16228 uint mask_min = pw_min;
16229 uint mask_max = pw_max;
16230
16231 if (opts_type & OPTS_TYPE_PT_UNICODE)
16232 {
16233 mask_min *= 2;
16234 mask_max *= 2;
16235 }
16236
16237 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16238 {
16239 if (css_cnt < mask_min)
16240 {
16241 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16242 }
16243
16244 if (css_cnt > mask_max)
16245 {
16246 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16247 }
16248
16249 // skip to next mask
16250
16251 dictpos++;
16252
16253 rd->dictpos = dictpos;
16254
16255 logfile_sub_msg ("STOP");
16256
16257 continue;
16258 }
16259
16260 uint save_css_cnt = css_cnt;
16261
16262 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16263 {
16264 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16265 {
16266 uint salt_len = (uint) data.salts_buf[0].salt_len;
16267 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16268
16269 uint css_cnt_salt = css_cnt + salt_len;
16270
16271 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16272
16273 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16274
16275 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16276 {
16277 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16278 css_buf_salt[j].cs_len = 1;
16279 }
16280
16281 free (css_buf);
16282
16283 css_buf = css_buf_salt;
16284 css_cnt = css_cnt_salt;
16285 }
16286 }
16287
16288 data.mask = mask;
16289 data.css_cnt = css_cnt;
16290 data.css_buf = css_buf;
16291
16292 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16293
16294 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16295
16296 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16297
16298 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16299 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16300
16301 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16302
16303 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16304
16305 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16306 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16307
16308 data.root_css_buf = root_css_buf;
16309 data.markov_css_buf = markov_css_buf;
16310
16311 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16312
16313 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16314
16315 local_free (root_table_buf);
16316 local_free (markov_table_buf);
16317
16318 // copy + args
16319
16320 uint css_cnt_l = css_cnt;
16321 uint css_cnt_r;
16322
16323 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16324 {
16325 if (save_css_cnt < 6)
16326 {
16327 css_cnt_r = 1;
16328 }
16329 else if (save_css_cnt == 6)
16330 {
16331 css_cnt_r = 2;
16332 }
16333 else
16334 {
16335 if (opts_type & OPTS_TYPE_PT_UNICODE)
16336 {
16337 if (save_css_cnt == 8 || save_css_cnt == 10)
16338 {
16339 css_cnt_r = 2;
16340 }
16341 else
16342 {
16343 css_cnt_r = 4;
16344 }
16345 }
16346 else
16347 {
16348 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16349 {
16350 css_cnt_r = 3;
16351 }
16352 else
16353 {
16354 css_cnt_r = 4;
16355 }
16356 }
16357 }
16358 }
16359 else
16360 {
16361 css_cnt_r = 1;
16362
16363 /* unfinished code?
16364 int sum = css_buf[css_cnt_r - 1].cs_len;
16365
16366 for (uint i = 1; i < 4 && i < css_cnt; i++)
16367 {
16368 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16369
16370 css_cnt_r++;
16371
16372 sum *= css_buf[css_cnt_r - 1].cs_len;
16373 }
16374 */
16375 }
16376
16377 css_cnt_l -= css_cnt_r;
16378
16379 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16380
16381 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16382 {
16383 hc_device_param_t *device_param = &data.devices_param[device_id];
16384
16385 if (device_param->skipped) continue;
16386
16387 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16388 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16389 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16390
16391 device_param->kernel_params_mp_l_buf64[3] = 0;
16392 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16393 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16394 device_param->kernel_params_mp_l_buf32[6] = 0;
16395 device_param->kernel_params_mp_l_buf32[7] = 0;
16396 device_param->kernel_params_mp_l_buf32[8] = 0;
16397
16398 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16399 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16400 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16401 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16402
16403 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16404 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16405 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16406
16407 device_param->kernel_params_mp_r_buf64[3] = 0;
16408 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16409 device_param->kernel_params_mp_r_buf32[5] = 0;
16410 device_param->kernel_params_mp_r_buf32[6] = 0;
16411 device_param->kernel_params_mp_r_buf32[7] = 0;
16412
16413 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]);
16414 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]);
16415 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]);
16416
16417 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]);
16418 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]);
16419 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]);
16420
16421 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);
16422 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);
16423 }
16424 }
16425
16426 u64 words_base = data.words_cnt;
16427
16428 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16429 {
16430 if (data.kernel_rules_cnt)
16431 {
16432 words_base /= data.kernel_rules_cnt;
16433 }
16434 }
16435 else if (data.attack_kern == ATTACK_KERN_COMBI)
16436 {
16437 if (data.combs_cnt)
16438 {
16439 words_base /= data.combs_cnt;
16440 }
16441 }
16442 else if (data.attack_kern == ATTACK_KERN_BF)
16443 {
16444 if (data.bfs_cnt)
16445 {
16446 words_base /= data.bfs_cnt;
16447 }
16448 }
16449
16450 data.words_base = words_base;
16451
16452 if (keyspace == 1)
16453 {
16454 log_info ("%llu", (unsigned long long int) words_base);
16455
16456 return (0);
16457 }
16458
16459 if (data.words_cur > data.words_base)
16460 {
16461 log_error ("ERROR: restore value greater keyspace");
16462
16463 return (-1);
16464 }
16465
16466 if (data.words_cur)
16467 {
16468 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16469 {
16470 for (uint i = 0; i < data.salts_cnt; i++)
16471 {
16472 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16473 }
16474 }
16475 else if (data.attack_kern == ATTACK_KERN_COMBI)
16476 {
16477 for (uint i = 0; i < data.salts_cnt; i++)
16478 {
16479 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16480 }
16481 }
16482 else if (data.attack_kern == ATTACK_KERN_BF)
16483 {
16484 for (uint i = 0; i < data.salts_cnt; i++)
16485 {
16486 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16487 }
16488 }
16489 }
16490
16491 /*
16492 * Inform user about possible slow speeds
16493 */
16494
16495 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16496 {
16497 if (data.words_base < kernel_power_all)
16498 {
16499 if (quiet == 0)
16500 {
16501 log_info ("");
16502 log_info ("ATTENTION!");
16503 log_info (" The wordlist or mask you are using is too small.");
16504 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16505 log_info (" The cracking speed will drop.");
16506 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16507 log_info ("");
16508 }
16509 }
16510 }
16511
16512 /*
16513 * Update loopback file
16514 */
16515
16516 if (loopback == 1)
16517 {
16518 time_t now;
16519
16520 time (&now);
16521
16522 uint random_num = get_random_num (0, 9999);
16523
16524 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16525
16526 data.loopback_file = loopback_file;
16527 }
16528
16529 /*
16530 * Update dictionary statistic
16531 */
16532
16533 if (keyspace == 0)
16534 {
16535 dictstat_fp = fopen (dictstat, "wb");
16536
16537 if (dictstat_fp)
16538 {
16539 lock_file (dictstat_fp);
16540
16541 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16542
16543 fclose (dictstat_fp);
16544 }
16545 }
16546
16547 data.devices_status = STATUS_RUNNING;
16548
16549 if (initial_restore_done == 0)
16550 {
16551 if (data.restore_disable == 0) cycle_restore ();
16552
16553 initial_restore_done = 1;
16554 }
16555
16556 hc_timer_set (&data.timer_running);
16557
16558 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16559 {
16560 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16561 {
16562 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16563 if (quiet == 0) fflush (stdout);
16564 }
16565 }
16566 else if (wordlist_mode == WL_MODE_STDIN)
16567 {
16568 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16569 if (data.quiet == 0) log_info ("");
16570 }
16571
16572 time_t runtime_start;
16573
16574 time (&runtime_start);
16575
16576 data.runtime_start = runtime_start;
16577
16578 /**
16579 * create cracker threads
16580 */
16581
16582 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16583
16584 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16585 {
16586 hc_device_param_t *device_param = &devices_param[device_id];
16587
16588 if (wordlist_mode == WL_MODE_STDIN)
16589 {
16590 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16591 }
16592 else
16593 {
16594 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16595 }
16596 }
16597
16598 // wait for crack threads to exit
16599
16600 hc_thread_wait (data.devices_cnt, c_threads);
16601
16602 local_free (c_threads);
16603
16604 data.restore = 0;
16605
16606 // finalize task
16607
16608 logfile_sub_var_uint ("status-after-work", data.devices_status);
16609
16610 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16611
16612 if (data.devices_status == STATUS_CRACKED) break;
16613 if (data.devices_status == STATUS_ABORTED) break;
16614
16615 if (data.devices_status == STATUS_BYPASS)
16616 {
16617 data.devices_status = STATUS_RUNNING;
16618 }
16619
16620 if (induction_dictionaries_cnt)
16621 {
16622 unlink (induction_dictionaries[0]);
16623 }
16624
16625 free (induction_dictionaries);
16626
16627 if (attack_mode != ATTACK_MODE_BF)
16628 {
16629 induction_dictionaries = scan_directory (induction_directory);
16630
16631 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16632 }
16633
16634 if (benchmark == 0)
16635 {
16636 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16637 {
16638 if (quiet == 0) clear_prompt ();
16639
16640 if (quiet == 0) log_info ("");
16641
16642 if (status == 1)
16643 {
16644 status_display ();
16645 }
16646 else
16647 {
16648 if (quiet == 0) status_display ();
16649 }
16650
16651 if (quiet == 0) log_info ("");
16652 }
16653 }
16654
16655 if (attack_mode == ATTACK_MODE_BF)
16656 {
16657 dictpos++;
16658
16659 rd->dictpos = dictpos;
16660 }
16661 else
16662 {
16663 if (induction_dictionaries_cnt)
16664 {
16665 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16666 }
16667 else
16668 {
16669 dictpos++;
16670
16671 rd->dictpos = dictpos;
16672 }
16673 }
16674
16675 time_t runtime_stop;
16676
16677 time (&runtime_stop);
16678
16679 data.runtime_stop = runtime_stop;
16680
16681 logfile_sub_uint (runtime_start);
16682 logfile_sub_uint (runtime_stop);
16683
16684 logfile_sub_msg ("STOP");
16685
16686 global_free (subid);
16687 }
16688
16689 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16690
16691 if (data.devices_status == STATUS_CRACKED) break;
16692 if (data.devices_status == STATUS_ABORTED) break;
16693 if (data.devices_status == STATUS_QUIT) break;
16694
16695 if (data.devices_status == STATUS_BYPASS)
16696 {
16697 data.devices_status = STATUS_RUNNING;
16698 }
16699 }
16700
16701 // 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
16702
16703 if (attack_mode == ATTACK_MODE_STRAIGHT)
16704 {
16705 if (data.wordlist_mode == WL_MODE_FILE)
16706 {
16707 if (data.dictfile == NULL)
16708 {
16709 if (dictfiles != NULL)
16710 {
16711 data.dictfile = dictfiles[0];
16712
16713 hc_timer_set (&data.timer_running);
16714 }
16715 }
16716 }
16717 }
16718 // NOTE: combi is okay because it is already set beforehand
16719 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16720 {
16721 if (data.dictfile == NULL)
16722 {
16723 if (dictfiles != NULL)
16724 {
16725 hc_timer_set (&data.timer_running);
16726
16727 data.dictfile = dictfiles[0];
16728 }
16729 }
16730 }
16731 else if (attack_mode == ATTACK_MODE_BF)
16732 {
16733 if (data.mask == NULL)
16734 {
16735 hc_timer_set (&data.timer_running);
16736
16737 data.mask = masks[0];
16738 }
16739 }
16740
16741 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16742 {
16743 data.devices_status = STATUS_EXHAUSTED;
16744 }
16745
16746 // if cracked / aborted remove last induction dictionary
16747
16748 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16749 {
16750 struct stat induct_stat;
16751
16752 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16753 {
16754 unlink (induction_dictionaries[file_pos]);
16755 }
16756 }
16757
16758 // wait for non-interactive threads
16759
16760 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16761 {
16762 hc_thread_wait (1, &ni_threads[thread_idx]);
16763 }
16764
16765 local_free (ni_threads);
16766
16767 // wait for interactive threads
16768
16769 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16770 {
16771 hc_thread_wait (1, &i_thread);
16772 }
16773
16774 // we dont need restore file anymore
16775 if (data.restore_disable == 0)
16776 {
16777 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16778 {
16779 unlink (eff_restore_file);
16780 unlink (new_restore_file);
16781 }
16782 else
16783 {
16784 cycle_restore ();
16785 }
16786 }
16787
16788 // finally save left hashes
16789
16790 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16791 {
16792 save_hash ();
16793 }
16794
16795 /**
16796 * Clean up
16797 */
16798
16799 if (benchmark == 1)
16800 {
16801 status_benchmark ();
16802
16803 log_info ("");
16804 }
16805 else
16806 {
16807 if (quiet == 0) clear_prompt ();
16808
16809 if (quiet == 0) log_info ("");
16810
16811 if (status == 1)
16812 {
16813 status_display ();
16814 }
16815 else
16816 {
16817 if (quiet == 0) status_display ();
16818 }
16819
16820 if (quiet == 0) log_info ("");
16821 }
16822
16823 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16824 {
16825 hc_device_param_t *device_param = &data.devices_param[device_id];
16826
16827 if (device_param->skipped) continue;
16828
16829 local_free (device_param->result);
16830
16831 local_free (device_param->combs_buf);
16832
16833 local_free (device_param->hooks_buf);
16834
16835 local_free (device_param->device_name);
16836
16837 local_free (device_param->device_name_chksum);
16838
16839 local_free (device_param->device_version);
16840
16841 local_free (device_param->driver_version);
16842
16843 if (device_param->pws_buf) myfree (device_param->pws_buf);
16844 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16845 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16846 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16847 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16848 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16849 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16850 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16851 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16852 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16853 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16854 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16855 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16856 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16857 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16858 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16859 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16860 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16861 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16862 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16863 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16864 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16865 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16866 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16867 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16868 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16869 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16870 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16871 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16872
16873 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16874 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16875 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16876 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16877 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16878 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16879 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16880 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16881 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16882 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16883
16884 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16885 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16886 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16887
16888 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16889 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16890 }
16891
16892 // reset default fan speed
16893
16894 #ifdef HAVE_HWMON
16895 if (gpu_temp_disable == 0)
16896 {
16897 #ifdef HAVE_ADL
16898 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16899 {
16900 hc_thread_mutex_lock (mux_adl);
16901
16902 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16903 {
16904 hc_device_param_t *device_param = &data.devices_param[device_id];
16905
16906 if (device_param->skipped) continue;
16907
16908 if (data.hm_device[device_id].fan_supported == 1)
16909 {
16910 int fanspeed = temp_retain_fanspeed_value[device_id];
16911
16912 if (fanspeed == -1) continue;
16913
16914 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16915
16916 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16917 }
16918 }
16919
16920 hc_thread_mutex_unlock (mux_adl);
16921 }
16922 #endif // HAVE_ADL
16923 }
16924
16925 #ifdef HAVE_ADL
16926 // reset power tuning
16927
16928 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16929 {
16930 hc_thread_mutex_lock (mux_adl);
16931
16932 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16933 {
16934 hc_device_param_t *device_param = &data.devices_param[device_id];
16935
16936 if (device_param->skipped) continue;
16937
16938 if (data.hm_device[device_id].od_version == 6)
16939 {
16940 // check powertune capabilities first, if not available then skip device
16941
16942 int powertune_supported = 0;
16943
16944 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16945 {
16946 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16947
16948 return (-1);
16949 }
16950
16951 if (powertune_supported != 0)
16952 {
16953 // powercontrol settings
16954
16955 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)
16956 {
16957 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16958
16959 return (-1);
16960 }
16961
16962 // clocks
16963
16964 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16965
16966 performance_state->iNumberOfPerformanceLevels = 2;
16967
16968 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16969 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16970 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16971 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16972
16973 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)
16974 {
16975 log_info ("ERROR: Failed to restore ADL performance state");
16976
16977 return (-1);
16978 }
16979
16980 local_free (performance_state);
16981 }
16982 }
16983 }
16984
16985 hc_thread_mutex_unlock (mux_adl);
16986 }
16987 #endif // HAVE_ADL
16988
16989 if (gpu_temp_disable == 0)
16990 {
16991 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
16992 if (data.hm_nv)
16993 {
16994 #if defined(LINUX) && defined(HAVE_NVML)
16995
16996 hm_NVML_nvmlShutdown (data.hm_nv);
16997
16998 nvml_close (data.hm_nv);
16999
17000 #elif defined(WIN) && (HAVE_NVAPI)
17001
17002 hm_NvAPI_Unload (data.hm_nv);
17003
17004 nvapi_close (data.hm_nv);
17005
17006 #endif
17007
17008 data.hm_nv = NULL;
17009 }
17010 #endif
17011
17012 #ifdef HAVE_ADL
17013 if (data.hm_amd)
17014 {
17015 hm_ADL_Main_Control_Destroy (data.hm_amd);
17016
17017 adl_close (data.hm_amd);
17018 data.hm_amd = NULL;
17019 }
17020 #endif
17021 }
17022 #endif // HAVE_HWMON
17023
17024 // free memory
17025
17026 local_free (masks);
17027
17028 local_free (dictstat_base);
17029
17030 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17031 {
17032 pot_t *pot_ptr = &pot[pot_pos];
17033
17034 hash_t *hash = &pot_ptr->hash;
17035
17036 local_free (hash->digest);
17037
17038 if (isSalted)
17039 {
17040 local_free (hash->salt);
17041 }
17042 }
17043
17044 local_free (pot);
17045
17046 local_free (all_kernel_rules_cnt);
17047 local_free (all_kernel_rules_buf);
17048
17049 local_free (wl_data->buf);
17050 local_free (wl_data);
17051
17052 local_free (bitmap_s1_a);
17053 local_free (bitmap_s1_b);
17054 local_free (bitmap_s1_c);
17055 local_free (bitmap_s1_d);
17056 local_free (bitmap_s2_a);
17057 local_free (bitmap_s2_b);
17058 local_free (bitmap_s2_c);
17059 local_free (bitmap_s2_d);
17060
17061 #ifdef HAVE_HWMON
17062 local_free (temp_retain_fanspeed_value);
17063 #ifdef HAVE_ADL
17064 local_free (od_clock_mem_status);
17065 local_free (od_power_control_status);
17066 #endif // ADL
17067 #endif
17068
17069 global_free (devices_param);
17070
17071 global_free (kernel_rules_buf);
17072
17073 global_free (root_css_buf);
17074 global_free (markov_css_buf);
17075
17076 global_free (digests_buf);
17077 global_free (digests_shown);
17078 global_free (digests_shown_tmp);
17079
17080 global_free (salts_buf);
17081 global_free (salts_shown);
17082
17083 global_free (esalts_buf);
17084
17085 global_free (words_progress_done);
17086 global_free (words_progress_rejected);
17087 global_free (words_progress_restored);
17088
17089 if (pot_fp) fclose (pot_fp);
17090
17091 if (data.devices_status == STATUS_QUIT) break;
17092 }
17093
17094 // destroy others mutex
17095
17096 hc_thread_mutex_delete (mux_dispatcher);
17097 hc_thread_mutex_delete (mux_counter);
17098 hc_thread_mutex_delete (mux_display);
17099 hc_thread_mutex_delete (mux_adl);
17100
17101 // free memory
17102
17103 local_free (eff_restore_file);
17104 local_free (new_restore_file);
17105
17106 local_free (rd);
17107
17108 // tuning db
17109
17110 tuning_db_destroy (tuning_db);
17111
17112 // loopback
17113
17114 local_free (loopback_file);
17115
17116 if (loopback == 1) unlink (loopback_file);
17117
17118 // induction directory
17119
17120 if (induction_dir == NULL)
17121 {
17122 if (attack_mode != ATTACK_MODE_BF)
17123 {
17124 if (rmdir (induction_directory) == -1)
17125 {
17126 if (errno == ENOENT)
17127 {
17128 // good, we can ignore
17129 }
17130 else if (errno == ENOTEMPTY)
17131 {
17132 // good, we can ignore
17133 }
17134 else
17135 {
17136 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17137
17138 return (-1);
17139 }
17140 }
17141
17142 local_free (induction_directory);
17143 }
17144 }
17145
17146 // outfile-check directory
17147
17148 if (outfile_check_dir == NULL)
17149 {
17150 if (rmdir (outfile_check_directory) == -1)
17151 {
17152 if (errno == ENOENT)
17153 {
17154 // good, we can ignore
17155 }
17156 else if (errno == ENOTEMPTY)
17157 {
17158 // good, we can ignore
17159 }
17160 else
17161 {
17162 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17163
17164 return (-1);
17165 }
17166 }
17167
17168 local_free (outfile_check_directory);
17169 }
17170
17171 time_t proc_stop;
17172
17173 time (&proc_stop);
17174
17175 logfile_top_uint (proc_start);
17176 logfile_top_uint (proc_stop);
17177
17178 logfile_top_msg ("STOP");
17179
17180 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17181 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17182
17183 if (data.ocl) ocl_close (data.ocl);
17184
17185 if (data.devices_status == STATUS_ABORTED) return 2;
17186 if (data.devices_status == STATUS_QUIT) return 2;
17187 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17188 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17189 if (data.devices_status == STATUS_CRACKED) return 0;
17190
17191 return -1;
17192 }
Hashcat additions to support pwdhash